@pellux/goodvibes-agent 0.1.34 → 0.1.35

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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

package/README.md

@@ -51,11 +51,13 @@ Use isolated Agent runtime profiles when one machine needs separate operator ide
 ```sh
 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. 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.
+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

@@ -21,7 +21,7 @@ Important baseline constraints:
 - 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> --template <starter> --yes` plus `--agent-profile <name>`.
-- Agent ships starter profile templates for household, research, travel, operations, and personal productivity local state.
+- 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

@@ -50,11 +50,13 @@ Use named runtime profiles for repeatable local identities:
 ```sh
 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. 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.
+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; starter templates seed local personas/skills/routines; 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.
-- Custom starter profile authoring/import for teams and repeatable operator lanes.
+- 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.34",
+  "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,11 +1,12 @@
 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 = 'household' | 'research' | 'travel' | 'operations' | 'personal-productivity';
+export type AgentRuntimeProfileTemplateId = string;
+export type AgentRuntimeProfileTemplateSource = 'builtin' | 'local';
 
 export interface AgentRuntimeProfileTemplateSummary {
   readonly id: AgentRuntimeProfileTemplateId;
@@ -14,6 +15,8 @@ export interface AgentRuntimeProfileTemplateSummary {
   readonly personaName: string;
   readonly skillNames: readonly string[];
   readonly routineNames: readonly string[];
+  readonly source: AgentRuntimeProfileTemplateSource;
+  readonly path?: string;
 }
 
 export interface AgentRuntimeProfileResolution {
@@ -31,6 +34,7 @@ export interface AgentRuntimeProfileInfo extends AgentRuntimeProfileResolution {
 export interface AgentRuntimeProfileTemplateApplication {
   readonly id: AgentRuntimeProfileTemplateId;
   readonly name: string;
+  readonly source: AgentRuntimeProfileTemplateSource;
   readonly appliedAt: string;
   readonly personaIds: readonly string[];
   readonly skillIds: readonly string[];
@@ -47,6 +51,8 @@ export interface AgentRuntimeProfileCommandResult {
     | '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';
@@ -55,6 +61,8 @@ export interface AgentRuntimeProfileCommandResult {
     readonly profile?: AgentRuntimeProfileInfo;
     readonly templates?: readonly AgentRuntimeProfileTemplateSummary[];
     readonly appliedTemplate?: AgentRuntimeProfileTemplateApplication;
+    readonly template?: AgentRuntimeProfileTemplateSummary;
+    readonly path?: string;
     readonly nextCommand?: string;
   };
   readonly error?: string;
@@ -87,9 +95,15 @@ interface AgentRuntimeProfileStarterTemplate extends AgentRuntimeProfileTemplate
   }[];
 }
 
+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',
@@ -149,6 +163,7 @@ const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
   },
   {
     id: 'research',
+    source: 'builtin',
     name: 'Research Analyst',
     description: 'Source-grounded research, brief generation, question tracking, and evidence review.',
     personaName: 'Research Analyst',
@@ -208,6 +223,7 @@ const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
   },
   {
     id: 'travel',
+    source: 'builtin',
     name: 'Travel Planner',
     description: 'Trip planning, itinerary decisions, packing, local constraints, and travel follow-through.',
     personaName: 'Travel Planner',
@@ -267,6 +283,7 @@ const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
   },
   {
     id: 'operations',
+    source: 'builtin',
     name: 'Operations Lead',
     description: 'Operational monitoring, incident triage, approvals, schedules, and service health.',
     personaName: 'Operations Lead',
@@ -325,6 +342,7 @@ const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
   },
   {
     id: 'personal-productivity',
+    source: 'builtin',
     name: 'Personal Productivity',
     description: 'Task capture, weekly planning, focus blocks, reminders, and decision hygiene.',
     personaName: 'Personal Productivity Coach',
@@ -408,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 {
@@ -465,31 +487,163 @@ function profileStorePath(homeDirectory: string, folder: string, file: string):
 }
 
 export function isAgentRuntimeProfileTemplateId(value: unknown): value is AgentRuntimeProfileTemplateId {
-  return typeof value === 'string' && STARTER_TEMPLATES.some((template) => template.id === value);
+  if (typeof value !== 'string') return false;
+  try {
+    assertValidAgentRuntimeProfileId(value);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-export function listAgentRuntimeProfileTemplates(): readonly AgentRuntimeProfileTemplateSummary[] {
-  return STARTER_TEMPLATES.map((template) => ({
+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>;
 }
 
-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}`);
+function parseTemplateSkill(value: unknown): AgentRuntimeProfileStarterTemplate['skills'][number] {
+  const record = readTemplateObject(value, 'skill');
   return {
-    id: template.id,
-    name: template.name,
-    description: template.description,
-    personaName: template.personaName,
-    skillNames: [...template.skillNames],
-    routineNames: [...template.routineNames],
+    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 {
@@ -522,9 +676,8 @@ function createMissingRoutine(registry: AgentRoutineRegistry, template: AgentRun
   }).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}`);
+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'));
@@ -544,6 +697,7 @@ export function applyAgentRuntimeProfileTemplate(homeDirectory: string, template
   return {
     id: template.id,
     name: template.name,
+    source: template.source,
     appliedAt: new Date().toISOString(),
     personaIds: [persona.id],
     skillIds,
@@ -572,7 +726,7 @@ export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName
   mkdirSync(resolution.homeDirectory, { recursive: true });
   const createdAt = new Date().toISOString();
   const appliedTemplate = options.templateId
-    ? applyAgentRuntimeProfileTemplate(resolution.homeDirectory, options.templateId)
+    ? applyAgentRuntimeProfileTemplate(resolution.homeDirectory, options.templateId, baseHomeDirectory)
     : undefined;
   writeFileSync(
     join(resolution.homeDirectory, PROFILE_CREATED_FILE),

package/src/cli/help.ts

@@ -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 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'],
+    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,6 +1,8 @@
 import {
   createAgentRuntimeProfile,
   deleteAgentRuntimeProfile,
+  exportAgentRuntimeProfileTemplate,
+  importAgentRuntimeProfileTemplate,
   isAgentRuntimeProfileTemplateId,
   listAgentRuntimeProfiles,
   listAgentRuntimeProfileTemplates,
@@ -72,13 +74,29 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
     return [
       `Agent starter profile templates (${templates.length})`,
       ...templates.map((template) => [
-        `  ${template.id}  ${template.name}`,
+        `  ${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;
@@ -123,10 +141,79 @@ 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() },
+        data: { templates: listAgentRuntimeProfileTemplates(runtime.homeDirectory) },
       };
       return {
         output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),

package/src/input/agent-workspace.ts

@@ -526,6 +526,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { 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 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. 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'],
+    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'],
-    next: ['Add import/export editing for custom starter 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, 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'],
+    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', 'curated local starter packs'],
-    next: ['Add custom starter template authoring and import.'],
+    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/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.34';
+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 {