@pellux/goodvibes-agent 0.1.34 → 0.1.36

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.36 - 2026-05-31
+
+- 9de2f5e Add guided Agent starter authoring
+
+## 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

@@ -46,16 +46,20 @@ Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator
 
 Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps.
 
+Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated runtime profiles from them.
+
 Use isolated Agent runtime profiles when one machine needs separate operator identities or local state:
 
 ```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` and `/agent-profile guide` support 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

@@ -37,6 +37,8 @@ bun run dev
 
 Once the TUI opens, run `/agent`, `/home`, or `/operator` to open the Agent operator workspace. That fullscreen workspace is the current front door for setup/config, knowledge status, local memory and skills, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+Use `/agent-profile guide` inside that workspace to walk through starter-profile authoring. It lists built-in and local starters, exports a JSON starter for editing, imports the edited starter back into this Agent home, and creates isolated profiles from the result.
+
 ## Isolated Agent Profiles
 
 Use a separate Agent home when you want isolated local state:
@@ -50,11 +52,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; `/agent-profile guide` brings starter authoring into the Agent workspace; 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.
+- Visual starter-template editing inside the fullscreen Agent workspace after the command-guided authoring path.
 - 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.36",
   "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,33 +487,169 @@ 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));
+}
+
+export function getAgentRuntimeProfileTemplateFile(templateId: AgentRuntimeProfileTemplateId, baseHomeDirectory?: string): AgentRuntimeProfileStarterTemplateFile {
+  return templateFilePayload(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;
@@ -522,9 +680,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 +701,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 +730,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

@@ -4,7 +4,7 @@ import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
-import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles } from '../agent/runtime-profile.ts';
+import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -97,6 +97,8 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly activeRuntimeProfile: string;
   readonly runtimeProfileCount: number;
   readonly runtimeProfileRoot: string;
+  readonly runtimeStarterTemplateCount: number;
+  readonly localStarterTemplateCount: number;
   readonly configProfileCount: number;
   readonly warnings: readonly string[];
 }
@@ -378,6 +380,13 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return 0;
     }
   })();
+  const runtimeStarterTemplates = (() => {
+    try {
+      return listAgentRuntimeProfileTemplates(context.workspace?.shellPaths?.homeDirectory ?? '');
+    } catch {
+      return [];
+    }
+  })();
   const voiceProviders = (() => {
     try {
       return context.platform?.voiceProviderRegistry?.list?.() ?? [];
@@ -437,6 +446,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeProfileCount: runtimeProfiles.length,
     runtimeProfileRoot: getAgentRuntimeProfilesRoot(context.workspace?.shellPaths?.homeDirectory ?? ''),
+    runtimeStarterTemplateCount: runtimeStarterTemplates.length,
+    localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
     configProfileCount,
     warnings,
   };
@@ -522,10 +533,13 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Hermes profiles isolate agent state. GoodVibes Agent exposes named runtime homes, config profile pickers, profile-sync bundles, setup transfer bundles, and support bundles while keeping the daemon external.',
     actions: [
       { id: 'profiles-open', label: 'Open config profiles', detail: 'Open the TUI-derived config profile picker for display/provider/behavior profile files.', command: '/profiles', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-guide', label: 'Starter authoring guide', detail: 'Open the Agent-local starter authoring flow inside the TUI command surface.', command: '/agent-profile guide', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-templates', label: 'Browse starter templates', detail: 'List built-in and local Agent starter templates with persona, skill, routine, and source details.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
       { 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 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-create', label: 'Create runtime profile', detail: 'Create an isolated Agent runtime profile from a built-in or local starter. Requires a real name and explicit --yes.', command: '/agent-profile create <name> --template <id> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-template-edit', label: 'Customize starter', detail: 'Export a starter JSON file, edit it, import it as a local starter, then create a profile from it.', command: '/agent-profile template export <id> <path> --yes', kind: 'command', 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/input/commands/agent-runtime-profile-runtime.ts

@@ -0,0 +1,223 @@
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  createAgentRuntimeProfile,
+  deleteAgentRuntimeProfile,
+  exportAgentRuntimeProfileTemplate,
+  getAgentRuntimeProfileTemplateFile,
+  importAgentRuntimeProfileTemplate,
+  listAgentRuntimeProfiles,
+  listAgentRuntimeProfileTemplates,
+  type AgentRuntimeProfileInfo,
+  type AgentRuntimeProfileTemplateSummary,
+} from '../../agent/runtime-profile.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+function parseFlag(args: readonly string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  return value && !value.startsWith('--') ? value : undefined;
+}
+
+function profileLine(profile: AgentRuntimeProfileInfo): string {
+  const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
+  const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
+  return `  ${profile.id}  home=${profile.homeDirectory}${created}${starter}`;
+}
+
+function templateLine(template: AgentRuntimeProfileTemplateSummary): string {
+  const source = template.source === 'local' ? `local ${template.path ?? ''}`.trim() : 'builtin';
+  return [
+    `  ${template.id}  [${source}]`,
+    `    ${template.name}: ${template.description}`,
+    `    persona: ${template.personaName}`,
+    `    skills: ${template.skillNames.join(', ')}`,
+    `    routines: ${template.routineNames.join(', ')}`,
+  ].join('\n');
+}
+
+function renderProfiles(homeDirectory: string): string {
+  const profiles = listAgentRuntimeProfiles(homeDirectory);
+  if (profiles.length === 0) {
+    return [
+      'Agent Runtime Profiles',
+      '  No isolated Agent runtime profiles yet.',
+      '  Create one with /agent-profile create <name> --template <id> --yes.',
+    ].join('\n');
+  }
+  return ['Agent Runtime Profiles', ...profiles.map(profileLine)].join('\n');
+}
+
+function renderTemplates(homeDirectory: string): string {
+  const templates = listAgentRuntimeProfileTemplates(homeDirectory);
+  return [
+    `Agent Starter Templates (${templates.length})`,
+    ...templates.map(templateLine),
+    '',
+    'Authoring flow:',
+    '  /agent-profile template export research ./agent-starter.json --yes',
+    '  edit the JSON file',
+    '  /agent-profile template import ./agent-starter.json --yes',
+    '  /agent-profile create <name> --template <imported-id> --yes',
+  ].join('\n');
+}
+
+function renderGuide(homeDirectory: string): string {
+  const templates = listAgentRuntimeProfileTemplates(homeDirectory);
+  const localCount = templates.filter((template) => template.source === 'local').length;
+  return [
+    'Agent Starter Authoring Guide',
+    `  built-in starters: ${templates.length - localCount}`,
+    `  local starters: ${localCount}`,
+    '',
+    '1. Pick a base starter:',
+    '   /agent-profile templates',
+    '2. Export a starter JSON file:',
+    '   /agent-profile template export research ./agent-starter.json --yes',
+    '3. Edit id, name, description, persona, skills, and routines in that JSON file.',
+    '4. Import it into this Agent home:',
+    '   /agent-profile template import ./agent-starter.json --yes',
+    '5. Create a runtime profile from the imported starter:',
+    '   /agent-profile create <name> --template <imported-id> --yes',
+    '',
+    'This writes only Agent-local starter/profile state. It does not mutate the daemon, default wiki, or HomeGraph.',
+  ].join('\n');
+}
+
+function renderTemplatePreview(homeDirectory: string, templateId: string): string {
+  const file = getAgentRuntimeProfileTemplateFile(templateId, homeDirectory);
+  return [
+    `Agent Starter Template: ${file.template.id}`,
+    `  name: ${file.template.name}`,
+    `  source: ${file.template.source}`,
+    `  description: ${file.template.description}`,
+    `  persona: ${file.template.persona.name}`,
+    `  skills: ${file.template.skills.map((skill) => skill.name).join(', ')}`,
+    `  routines: ${file.template.routines.map((routine) => routine.name).join(', ')}`,
+    '',
+    'Export/edit/import to customize this starter:',
+    `  /agent-profile template export ${file.template.id} ./agent-starter.json --yes`,
+  ].join('\n');
+}
+
+export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'agent-profile',
+    aliases: ['runtime-profile', 'agent-profiles'],
+    description: 'Manage isolated Agent runtime profiles and starter templates',
+    usage: '[list|templates|guide|template show|template export|template import|create|delete]',
+    handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const homeDirectory = shellPaths.homeDirectory;
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'list').toLowerCase();
+
+      try {
+        if (sub === 'list' || sub === 'profiles') {
+          ctx.print(renderProfiles(homeDirectory));
+          return;
+        }
+
+        if (sub === 'templates' || sub === 'starters') {
+          ctx.print(renderTemplates(homeDirectory));
+          return;
+        }
+
+        if (sub === 'guide' || sub === 'author') {
+          ctx.print(renderGuide(homeDirectory));
+          return;
+        }
+
+        if (sub === 'template' || sub === 'starter') {
+          const mode = (commandArgs[1] ?? 'show').toLowerCase();
+          if (mode === 'show' || mode === 'preview') {
+            const templateId = commandArgs[2];
+            if (!templateId) {
+              ctx.print('Usage: /agent-profile template show <id>');
+              return;
+            }
+            ctx.print(renderTemplatePreview(homeDirectory, templateId));
+            return;
+          }
+          if (mode === 'export') {
+            const templateId = commandArgs[2];
+            const pathArg = commandArgs[3];
+            if (!templateId || !pathArg) {
+              ctx.print('Usage: /agent-profile template export <id> <path> --yes');
+              return;
+            }
+            if (!parsed.yes) {
+              requireYesFlag(ctx, `export Agent starter template ${templateId}`, '/agent-profile template export <id> <path> --yes');
+              return;
+            }
+            const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+            mkdirSync(dirname(targetPath), { recursive: true });
+            const template = exportAgentRuntimeProfileTemplate(homeDirectory, templateId, targetPath);
+            ctx.print(`Agent starter template exported: ${template.id}\n  path: ${template.path ?? targetPath}\n  edit it, then import it with /agent-profile template import <path> --yes`);
+            return;
+          }
+          if (mode === 'import') {
+            const pathArg = commandArgs[2];
+            if (!pathArg) {
+              ctx.print('Usage: /agent-profile template import <path> --yes');
+              return;
+            }
+            if (!parsed.yes) {
+              requireYesFlag(ctx, 'import Agent starter template', '/agent-profile template import <path> --yes');
+              return;
+            }
+            const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+            const template = importAgentRuntimeProfileTemplate(homeDirectory, sourcePath);
+            ctx.print(`Agent starter template imported: ${template.id}\n  source: ${template.source}\n  use: /agent-profile create <name> --template ${template.id} --yes`);
+            return;
+          }
+          ctx.print('Usage: /agent-profile template [show <id>|export <id> <path> --yes|import <path> --yes]');
+          return;
+        }
+
+        if (sub === 'create') {
+          const name = commandArgs[1];
+          const templateId = parseFlag(commandArgs, '--template') ?? parseFlag(commandArgs, '--starter');
+          if (!name) {
+            ctx.print('Usage: /agent-profile create <name> [--template <id>] --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `create Agent runtime profile ${name}`, '/agent-profile create <name> [--template <id>] --yes');
+            return;
+          }
+          const profile = createAgentRuntimeProfile(homeDirectory, name, { templateId });
+          ctx.print([
+            `Agent runtime profile created: ${profile.id}`,
+            `  home: ${profile.homeDirectory}`,
+            profile.starterTemplateId ? `  starter: ${profile.starterTemplateId}` : '',
+            `  launch: goodvibes-agent --agent-profile ${profile.id}`,
+          ].filter(Boolean).join('\n'));
+          return;
+        }
+
+        if (sub === 'delete') {
+          const name = commandArgs[1];
+          if (!name) {
+            ctx.print('Usage: /agent-profile delete <name> --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `delete Agent runtime profile ${name}`, '/agent-profile delete <name> --yes');
+            return;
+          }
+          ctx.print(deleteAgentRuntimeProfile(homeDirectory, name) ? `Agent runtime profile deleted: ${name}` : `Agent runtime profile not found: ${name}`);
+          return;
+        }
+
+        ctx.print('Usage: /agent-profile [list|templates|guide|template show <id>|template export <id> <path> --yes|template import <path> --yes|create <name> [--template <id>] --yes|delete <name> --yes]');
+      } catch (error) {
+        ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    },
+  });
+}

package/src/input/commands.ts

@@ -53,6 +53,7 @@ import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
 import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
 import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 import { registerAgentWorkspaceRuntimeCommands } from './commands/agent-workspace-runtime.ts';
+import { registerAgentRuntimeProfileRuntimeCommands } from './commands/agent-runtime-profile-runtime.ts';
 import { registerAgentExternalizedTuiCommands } from './commands/agent-externalized-tui.ts';
 import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
@@ -67,6 +68,7 @@ import { registerCapabilitiesRuntimeCommands } from './commands/capabilities-run
 export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
+  registerAgentRuntimeProfileRuntimeCommands(registry);
   registerCapabilitiesRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);

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'],
-    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.'],
+    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 authoring.',
+    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-profile guide', '/agent → Profiles & Portability'],
+    use: ['goodvibes-agent --agent-profile household', '/agent-profile templates', '/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', 'editable starter templates', 'TUI-guided starter authoring'],
+    next: ['Add visual starter-template editing inside the fullscreen Agent workspace.'],
   },
   {
     id: 'security-approvals',

package/src/renderer/agent-workspace.ts

@@ -132,9 +132,10 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: `Active runtime profile: ${snapshot.activeRuntimeProfile}`, fg: PALETTE.info },
       { text: `Runtime profiles under this home: ${snapshot.runtimeProfileCount}`, fg: PALETTE.info },
       { text: `Runtime profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
+      { text: `Starter templates: ${snapshot.runtimeStarterTemplateCount}; local custom: ${snapshot.localStarterTemplateCount}`, fg: PALETTE.info },
       { 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: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace via /agent-profile.', 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.34';
+let _version = '0.1.36';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {