@pellux/goodvibes-agent 0.1.75 → 0.1.77

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.77 - 2026-06-01
+
+- Added a first-class Agent profile creation form inside the fullscreen operator workspace instead of dispatching a placeholder command template.
+- Surfaced profile and starter-template summaries directly in the Profiles workspace so day-one setup can pick an isolated Agent home from the TUI.
+- Made Agent runtime profile creation refuse existing profile homes to protect local profile state across CLI, onboarding, and workspace flows.
+
+## 0.1.76 - 2026-05-31
+
+- Added optional starter profile creation to first-run onboarding so setup can create an isolated Agent home seeded with persona, skill, and routine templates.
+- Added onboarding apply/verify support for Agent profile creation with prevalidation, rollback, and overwrite protection.
+- Updated onboarding and renderer regressions so the first-run flow stays Agent-specific while exposing the starter profile path directly in the TUI.
+
 ## 0.1.75 - 2026-05-31
 
 - Reworded Agent status, doctor, and external runtime diagnostics away from copied service/surface ownership language.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/runtime-profile.ts

@@ -727,6 +727,9 @@ export function listAgentRuntimeProfiles(baseHomeDirectory: string): readonly Ag
 
 export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName: string, options: CreateAgentRuntimeProfileOptions = {}): AgentRuntimeProfileInfo {
   const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
+  if (existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile already exists: ${resolution.id}`);
+  }
   mkdirSync(resolution.homeDirectory, { recursive: true });
   const createdAt = new Date().toISOString();
   const appliedTemplate = options.templateId

package/src/input/agent-workspace-categories.ts

@@ -98,7 +98,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'profile-sync-list', label: 'Profile sync list', detail: 'Inspect saved config profiles available for export/import.', command: '/profilesync list', kind: 'command', safety: 'read-only' },
       { id: 'profile-sync-export', label: 'Export profile sync', detail: 'Export config profiles to a portable bundle. Requires a real path and explicit --yes.', command: '/profilesync export <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'setup-transfer-export', label: 'Export setup transfer', detail: 'Export Agent setup transfer data from the current home. Requires a real path and explicit --yes.', command: '/setup transfer export <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'runtime-profile-create', label: 'Create Agent profile', detail: 'Create an isolated Agent 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-create', label: 'Create Agent profile', detail: 'Open an in-workspace form that creates an isolated Agent home from a built-in or local starter.', editorKind: 'profile', kind: 'editor', 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 Agent 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/agent-workspace-editors.ts

@@ -1,9 +1,36 @@
 import type { AgentPersonaRecord } from '../agent/persona-registry.ts';
 import type { AgentRoutineRecord } from '../agent/routine-registry.ts';
 import type { AgentSkillRecord } from '../agent/skill-registry.ts';
-import type { AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem } from './agent-workspace-types.ts';
+import type {
+  AgentWorkspaceLocalEditor,
+  AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRuntimeStarterTemplateItem,
+} from './agent-workspace-types.ts';
+
+export function createProfileEditor(templates: readonly AgentWorkspaceRuntimeStarterTemplateItem[]): AgentWorkspaceLocalEditor {
+  const defaultTemplate = templates.find((template) => template.id === 'research')?.id ?? templates[0]?.id ?? 'none';
+  const preview = templates.length === 0
+    ? 'No starter templates found; use none to create an empty isolated profile.'
+    : templates
+      .slice(0, 6)
+      .map((template) => `${template.id} (${template.name})`)
+      .join(', ');
+  return {
+    kind: 'profile',
+    mode: 'create',
+    title: 'Create Agent Profile',
+    selectedFieldIndex: 0,
+    message: 'Create an isolated Agent home seeded with a persona, skills, and routines. The current process keeps using its existing home until relaunched with --agent-profile.',
+    fields: [
+      { id: 'name', label: 'Profile name', value: '', required: true, multiline: false, hint: 'Short profile name. It normalizes to lowercase letters, numbers, dots, underscores, and dashes.' },
+      { id: 'template', label: 'Starter template', value: defaultTemplate, required: false, multiline: false, hint: `Template id or none. Available: ${preview}.` },
+    ],
+  };
+}
 
 export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'profile') return createProfileEditor([]);
   if (kind === 'persona') {
     return {
       kind,
@@ -137,6 +164,7 @@ export function isAffirmative(value: string): boolean {
 }
 
 export function editorCategoryId(kind: AgentWorkspaceLocalEditorKind): string {
+  if (kind === 'profile') return 'profiles';
   if (kind === 'persona') return 'personas';
   if (kind === 'skill') return 'skills';
   return 'routines';

package/src/input/agent-workspace-snapshot.ts

@@ -6,7 +6,12 @@ import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-regist
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
-import type { AgentWorkspaceLocalLibraryItem, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
+import type {
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRuntimeProfileItem,
+  AgentWorkspaceRuntimeSnapshot,
+  AgentWorkspaceRuntimeStarterTemplateItem,
+} from './agent-workspace-types.ts';
 
 type AgentWorkspaceConfigReader = {
   get(key: string): unknown;
@@ -94,6 +99,28 @@ function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalL
   };
 }
 
+function summarizeRuntimeProfile(profile: ReturnType<typeof listAgentRuntimeProfiles>[number]): AgentWorkspaceRuntimeProfileItem {
+  return {
+    id: profile.id,
+    homeDirectory: profile.homeDirectory,
+    createdAt: profile.createdAt,
+    starterTemplateId: profile.starterTemplateId,
+    starterTemplateName: profile.starterTemplateName,
+  };
+}
+
+function summarizeStarterTemplate(template: ReturnType<typeof listAgentRuntimeProfileTemplates>[number]): AgentWorkspaceRuntimeStarterTemplateItem {
+  return {
+    id: template.id,
+    name: template.name,
+    description: template.description,
+    personaName: template.personaName,
+    skillNames: template.skillNames,
+    routineNames: template.routineNames,
+    source: template.source,
+  };
+}
+
 export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): AgentWorkspaceRuntimeSnapshot {
   const host = readConfigString(context, 'controlPlane.host', '127.0.0.1');
   const port = readConfigNumber(context, 'controlPlane.port', 3421);
@@ -255,9 +282,11 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     browserSurfacePublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeProfileCount: runtimeProfiles.length,
+    runtimeProfiles: runtimeProfiles.map(summarizeRuntimeProfile),
     runtimeProfileRoot: getAgentRuntimeProfilesRoot(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeStarterTemplateCount: runtimeStarterTemplates.length,
     localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
+    runtimeStarterTemplates: runtimeStarterTemplates.map(summarizeStarterTemplate),
     configProfileCount,
     setupChecklist,
     warnings,

package/src/input/agent-workspace-types.ts

@@ -7,7 +7,7 @@ export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
 export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'local-selection' | 'local-operation';
 
-export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine';
+export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine' | 'profile';
 
 export type AgentWorkspaceLocalOperation =
   | 'persona-edit'
@@ -94,6 +94,24 @@ export interface AgentWorkspaceLocalLibraryItem {
   readonly startCount?: number;
 }
 
+export interface AgentWorkspaceRuntimeProfileItem {
+  readonly id: string;
+  readonly homeDirectory: string;
+  readonly createdAt: string | null;
+  readonly starterTemplateId?: string;
+  readonly starterTemplateName?: string;
+}
+
+export interface AgentWorkspaceRuntimeStarterTemplateItem {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly personaName: string;
+  readonly skillNames: readonly string[];
+  readonly routineNames: readonly string[];
+  readonly source: string;
+}
+
 export interface AgentWorkspaceRuntimeSnapshot {
   readonly provider: string;
   readonly model: string;
@@ -133,9 +151,11 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly browserSurfacePublicBaseUrl: string;
   readonly activeRuntimeProfile: string;
   readonly runtimeProfileCount: number;
+  readonly runtimeProfiles: readonly AgentWorkspaceRuntimeProfileItem[];
   readonly runtimeProfileRoot: string;
   readonly runtimeStarterTemplateCount: number;
   readonly localStarterTemplateCount: number;
+  readonly runtimeStarterTemplates: readonly AgentWorkspaceRuntimeStarterTemplateItem[];
   readonly configProfileCount: number;
   readonly setupChecklist: readonly AgentWorkspaceSetupChecklistItem[];
   readonly warnings: readonly string[];

package/src/input/agent-workspace.ts

@@ -3,9 +3,10 @@ import type { ShellPathService } from '@/runtime/index.ts';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agent/runtime-profile.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { AGENT_WORKSPACE_CATEGORIES } from './agent-workspace-categories.ts';
-import { createDeleteEditor, createLocalEditor, createPersonaUpdateEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { createDeleteEditor, createLocalEditor, createPersonaUpdateEditor, createProfileEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 
@@ -25,7 +26,6 @@ export type {
 } from './agent-workspace-types.ts';
 export { AGENT_WORKSPACE_MODAL_NAME } from './agent-workspace-types.ts';
 export { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
-
 function parseCommand(command: string): { readonly name: string; readonly args: readonly string[] } {
   const trimmed = command.trim().replace(/^\//, '');
   if (!trimmed) return { name: '', args: [] };
@@ -46,6 +46,7 @@ export class AgentWorkspace {
     persona: 0,
     skill: 0,
     routine: 0,
+    profile: 0,
   };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
@@ -228,7 +229,9 @@ export class AgentWorkspace {
     const action = this.selectedAction;
     if (!action) return;
     if (action.kind === 'editor' && action.editorKind) {
-      this.localEditor = createLocalEditor(action.editorKind);
+      this.localEditor = action.editorKind === 'profile'
+        ? createProfileEditor(this.runtimeSnapshot?.runtimeStarterTemplates ?? [])
+        : createLocalEditor(action.editorKind);
       this.status = `Editing ${this.localEditor.title}.`;
       this.lastActionResult = {
         kind: 'guidance',
@@ -347,6 +350,7 @@ export class AgentWorkspace {
   private localLibraryItems(kind: AgentWorkspaceLocalEditorKind): readonly AgentWorkspaceLocalLibraryItem[] {
     if (kind === 'persona') return this.runtimeSnapshot?.localPersonas ?? [];
     if (kind === 'skill') return this.runtimeSnapshot?.localSkills ?? [];
+    if (kind === 'profile') return [];
     return this.runtimeSnapshot?.localRoutines ?? [];
   }
 
@@ -564,7 +568,14 @@ export class AgentWorkspace {
         this.submitLocalDeleteEditor(shellPaths, editor);
         return;
       }
-      if (editor.kind === 'persona') {
+      if (editor.kind === 'profile') {
+        const template = this.editorField('template');
+        const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
+        const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, this.editorField('name'), {
+          ...(templateId ? { templateId } : {}),
+        });
+        this.finishProfileEditor(profile);
+      } else if (editor.kind === 'persona') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
         if (editor.mode === 'update' && editor.recordId) {
           const wasActive = registry.snapshot().activePersonaId === editor.recordId;
@@ -699,6 +710,26 @@ export class AgentWorkspace {
     this.clampSelection();
   }
 
+  private finishProfileEditor(profile: AgentRuntimeProfileInfo): void {
+    this.localEditor = null;
+    const categoryIndex = this.categories.findIndex((category) => category.id === 'profiles');
+    if (categoryIndex >= 0) {
+      this.selectedCategoryIndex = categoryIndex;
+      this.selectedActionIndex = this.categories[categoryIndex]?.actions.findIndex((action) => action.id === 'runtime-profile-create') ?? 0;
+      if (this.selectedActionIndex < 0) this.selectedActionIndex = 0;
+    }
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    const starter = profile.starterTemplateId ? ` from ${profile.starterTemplateId}` : '';
+    this.status = `Created Agent profile: ${profile.id}.`;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title: 'Created Agent profile',
+      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current TUI session was not switched.`,
+      safety: 'safe',
+    };
+    this.clampSelection();
+  }
+
   private finishLocalDelete(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
     this.localEditor = null;
     const categoryId = editorCategoryId(kind);

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -38,6 +38,16 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
 
     setSecret('OPENAI_API_KEY', controller.getStringFieldValue('providers.openai-api-key', ''));
 
+    const profileName = controller.getStringFieldValue('agent-setup.profile-name', '').trim();
+    if (profileName.length > 0) {
+      const selectedTemplate = controller.getStringFieldValue('agent-setup.profile-template', 'none').trim();
+      operations.push({
+        kind: 'create-agent-profile',
+        name: profileName,
+        ...(selectedTemplate.length > 0 && selectedTemplate !== 'none' ? { templateId: selectedTemplate } : {}),
+      });
+    }
+
     return {
       mode: controller.mode,
       source: 'wizard',

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -1,7 +1,23 @@
 import { REASONING_OPTIONS, HITL_MODE_OPTIONS, GUIDANCE_MODE_OPTIONS, PERMISSION_MODE_OPTIONS, SECRET_POLICY_OPTIONS } from './onboarding-wizard-constants.ts';
 import { modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.ts';
+import { listAgentRuntimeProfileTemplates } from '../../agent/runtime-profile.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
-import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
+import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
+
+function buildStarterTemplateOptions(): readonly OnboardingWizardRadioOption[] {
+  return [
+    {
+      id: 'none',
+      label: 'No profile',
+      hint: 'Keep using the current Agent home. You can create isolated profiles later from the Agent workspace.',
+    },
+    ...listAgentRuntimeProfileTemplates().map((template): OnboardingWizardRadioOption => ({
+      id: template.id,
+      label: template.name,
+      hint: `${template.description} Includes persona ${template.personaName}, skills ${template.skillNames.join(', ')}, and routines ${template.routineNames.join(', ')}.`,
+    })),
+  ];
+}
 
 export function buildOnboardingWizardSteps(controller: OnboardingWizardController): readonly OnboardingWizardStepDefinition[] {
   if (controller.hydrationPending || controller.hydrationError !== null) return [buildLoadingStep(controller)];
@@ -169,6 +185,7 @@ export function buildAgentSetupStep(controller: OnboardingWizardController): Onb
     summaryTitle: 'Agent setup posture',
     summaryLines: [
       'Agent owns the operator TUI and local behavior registry.',
+      'Optional starter profile: create an isolated Agent home from setup.',
       'GoodVibes runtime lifecycle is external to this product.',
       `Secret policy: ${controller.getStringFieldValue('agent-setup.secret-policy', secretPolicy)}`,
       collectionIssues > 0 ? `${collectionIssues} setup snapshot issue(s)` : 'Setup snapshot collected cleanly',
@@ -198,12 +215,28 @@ export function buildAgentSetupStep(controller: OnboardingWizardController): Onb
         options: SECRET_POLICY_OPTIONS,
         defaultValue: secretPolicy,
       },
+      {
+        kind: 'text',
+        id: 'agent-setup.profile-name',
+        label: 'Create starter profile',
+        hint: 'Optional: enter a new Agent profile name to create an isolated home during setup. Leave blank to keep the current home.',
+        placeholder: 'research-desk',
+        defaultValue: '',
+      },
+      {
+        kind: 'radio',
+        id: 'agent-setup.profile-template',
+        label: 'Starter profile template',
+        hint: 'Choose the persona, skills, and routine bundle to seed into the optional new Agent profile.',
+        options: buildStarterTemplateOptions(),
+        defaultValue: 'none',
+      },
       {
         kind: 'status',
         id: 'agent-setup.profile-guide',
-        label: 'Agent profiles',
-        hint: 'Use /agent-profile guide after setup to create household, research, travel, operations, or custom Agent profiles.',
-        defaultValue: 'Profiles',
+        label: 'Profile guidance',
+        hint: 'Use /agent-profile guide after setup to export, customize, import, and launch Agent profiles.',
+        defaultValue: 'Available',
       },
     ],
   };

package/src/renderer/agent-workspace.ts

@@ -142,6 +142,47 @@ function localLibraryLines(
   return lines;
 }
 
+function profileLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: 'Agent Profiles', fg: PALETTE.title, bold: true },
+  ];
+  if (snapshot.runtimeProfiles.length === 0) {
+    lines.push({ text: 'No isolated Agent profiles yet. Use Create Agent profile in this workspace.', fg: PALETTE.warn });
+    return lines;
+  }
+  for (const profile of snapshot.runtimeProfiles.slice(0, 6)) {
+    const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : ' starter=none';
+    const created = profile.createdAt ? ` created=${profile.createdAt.slice(0, 10)}` : '';
+    lines.push({ text: `${profile.id}${starter}${created}`, fg: PALETTE.info, bold: profile.id === snapshot.activeRuntimeProfile });
+    lines.push({ text: `  home: ${profile.homeDirectory}`, fg: PALETTE.muted });
+  }
+  if (snapshot.runtimeProfiles.length > 6) {
+    lines.push({ text: `${snapshot.runtimeProfiles.length - 6} more profile(s).`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
+function starterTemplateLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: 'Starter Templates', fg: PALETTE.title, bold: true },
+  ];
+  for (const template of snapshot.runtimeStarterTemplates.slice(0, 6)) {
+    lines.push({
+      text: `${template.id}: ${template.name} [${template.source}]`,
+      fg: template.source === 'local' ? PALETTE.good : PALETTE.info,
+      bold: template.id === 'research',
+    });
+    lines.push({
+      text: `  ${template.description} Persona ${template.personaName}; skills ${template.skillNames.join(', ')}; routines ${template.routineNames.join(', ')}.`,
+      fg: PALETTE.muted,
+    });
+  }
+  if (snapshot.runtimeStarterTemplates.length > 6) {
+    lines.push({ text: `${snapshot.runtimeStarterTemplates.length - 6} more starter template(s).`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
 function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
   if (!snapshot) return [{ text: 'Runtime context is not loaded yet.', fg: PALETTE.warn }];
   const base: ContextLine[] = [{ text: 'Live Agent Context', fg: PALETTE.title, bold: true }];
@@ -206,8 +247,14 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: `Agent 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: `Starter ids: ${snapshot.runtimeStarterTemplates.map((template) => template.id).join(', ') || 'none'}`, fg: PALETTE.info },
+      { text: '' },
+      ...profileLines(snapshot),
+      { text: '' },
+      ...starterTemplateLines(snapshot),
+      { text: '' },
       { text: 'Named Agent profiles isolate local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
-      { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace via /agent-profile.', fg: PALETTE.info },
+      { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace.', fg: PALETTE.info },
       { text: 'The external GoodVibes runtime remains shared unless the owning 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/runtime/onboarding/apply.ts

@@ -1,7 +1,12 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
 import { CONFIG_SCHEMA, DEFAULT_CONFIG } from '../../config/index.ts';
+import {
+  createAgentRuntimeProfile,
+  getAgentRuntimeProfileTemplate,
+  resolveAgentRuntimeProfileHome,
+} from '../../agent/runtime-profile.ts';
 import type { FeatureFlagConfigKey } from '../surface-feature-flags.ts';
 import {
   getOnboardingRuntimeStatePath,
@@ -250,6 +255,22 @@ function validateAcknowledgementOperation(
   }
 }
 
+function validateCreateAgentProfileOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-agent-profile' }>,
+): void {
+  const name = operation.name.trim();
+  if (name.length === 0) throw new Error('Agent profile name is required.');
+
+  const resolution = resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, name);
+  if (existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile already exists: ${resolution.id}`);
+  }
+
+  const templateId = operation.templateId?.trim();
+  if (templateId) getAgentRuntimeProfileTemplate(templateId, deps.shellPaths.homeDirectory);
+}
+
 function applyConfigOperation(
   deps: OnboardingApplyDependencies,
   operation: Extract<OnboardingApplyOperation, { kind: 'set-config' }>,
@@ -441,6 +462,13 @@ async function buildRollbackAction(
     );
   }
 
+  if (operation.kind === 'create-agent-profile') {
+    const resolution = resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, operation.name);
+    return () => {
+      if (existsSync(resolution.homeDirectory)) rmSync(resolution.homeDirectory, { recursive: true, force: true });
+    };
+  }
+
   const neverOperation: never = operation;
   throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
 }
@@ -465,6 +493,24 @@ function applyAcknowledgementOperation(
   };
 }
 
+function applyCreateAgentProfileOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-agent-profile' }>,
+): OnboardingAppliedOperation {
+  validateCreateAgentProfileOperation(deps, operation);
+  const templateId = operation.templateId?.trim();
+  const profile = createAgentRuntimeProfile(deps.shellPaths.homeDirectory, operation.name, {
+    ...(templateId ? { templateId } : {}),
+  });
+
+  return {
+    kind: operation.kind,
+    summary: profile.starterTemplateId
+      ? `Created Agent profile ${profile.id} from ${profile.starterTemplateId}.`
+      : `Created Agent profile ${profile.id}.`,
+  };
+}
+
 function orderApplyOperations(
   operations: readonly OnboardingApplyOperation[],
 ): readonly OnboardingApplyOperation[] {
@@ -476,6 +522,7 @@ function orderApplyOperations(
   const configOperations = operations.filter((operation) => (
     operation.kind === 'set-config' && operation.key !== 'storage.secretPolicy'
   ));
+  const agentProfileOperations = operations.filter((operation) => operation.kind === 'create-agent-profile');
   const finalOperations = operations.filter((operation) => (
     operation.kind === 'acknowledge'
   ));
@@ -485,6 +532,7 @@ function orderApplyOperations(
     ...authOperations,
     ...secretOperations,
     ...configOperations,
+    ...agentProfileOperations,
     ...finalOperations,
   ];
 }
@@ -521,6 +569,11 @@ function prevalidateApplyRequest(
         continue;
       }
 
+      if (operation.kind === 'create-agent-profile') {
+        validateCreateAgentProfileOperation(deps, operation);
+        continue;
+      }
+
       const neverOperation: never = operation;
       throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
     } catch (error) {
@@ -539,6 +592,7 @@ function getVerificationFailureKind(itemId: string): OnboardingApplyOperation['k
   if (itemId.startsWith('secret:')) return 'set-secret';
   if (itemId.startsWith('auth:')) return 'ensure-auth-user';
   if (itemId.startsWith('acknowledge:')) return 'acknowledge';
+  if (itemId.startsWith('agent-profile:')) return 'create-agent-profile';
   return 'set-config';
 }
 
@@ -590,6 +644,12 @@ export async function applyOnboardingRequest(
           continue;
         }
 
+        if (operation.kind === 'create-agent-profile') {
+          applied.push(applyCreateAgentProfileOperation(deps, operation));
+          rollbacks.push(rollback);
+          continue;
+        }
+
         const neverOperation: never = operation;
         throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
       } catch (error) {

package/src/runtime/onboarding/types.ts

@@ -264,6 +264,11 @@ export type OnboardingApplyOperation =
       readonly kind: 'acknowledge';
       readonly target: OnboardingAcknowledgementTarget;
       readonly acknowledged: boolean;
+    }
+  | {
+      readonly kind: 'create-agent-profile';
+      readonly name: string;
+      readonly templateId?: string;
     };
 
 export interface OnboardingApplyRequest {
@@ -358,7 +363,7 @@ export interface OnboardingProviderAccountReadHelper {
 
 export type OnboardingShellPaths = Pick<
   ShellPathService,
-  'workingDirectory' | 'resolveProjectPath' | 'resolveUserPath'
+  'homeDirectory' | 'workingDirectory' | 'resolveProjectPath' | 'resolveUserPath'
 >;
 
 export interface OnboardingSnapshotDependencies {

package/src/runtime/onboarding/verify.ts

@@ -1,4 +1,7 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
+import { resolveAgentRuntimeProfileHome } from '../../agent/runtime-profile.ts';
 import { readOnboardingRuntimeState } from './state.ts';
 import type {
   OnboardingApplyOperation,
@@ -147,6 +150,22 @@ function verifyAuthOperation(
   };
 }
 
+function verifyCreateAgentProfileOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-agent-profile' }>,
+): OnboardingVerificationItem {
+  const resolution = resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, operation.name);
+  const ok = existsSync(join(resolution.homeDirectory, 'profile.json'));
+  return {
+    id: `agent-profile:${resolution.id}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${resolution.id} Agent profile exists.`
+      : `${resolution.id} Agent profile was not created.`,
+    target: resolution.id,
+  };
+}
+
 async function verifyOperation(
   deps: OnboardingVerificationDependencies,
   operation: OnboardingApplyOperation,
@@ -154,7 +173,8 @@ async function verifyOperation(
   if (operation.kind === 'set-config') return verifyConfigOperation(deps, operation);
   if (operation.kind === 'set-secret') return verifySecretOperation(deps, operation);
   if (operation.kind === 'ensure-auth-user') return verifyAuthOperation(deps, operation);
-  return verifyAcknowledgementOperation(deps, operation);
+  if (operation.kind === 'acknowledge') return verifyAcknowledgementOperation(deps, operation);
+  return verifyCreateAgentProfileOperation(deps, operation);
 }
 
 export async function verifyOnboardingRequest(

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.75';
+let _version = '0.1.77';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {