@pellux/goodvibes-agent 0.1.35 → 0.1.36

package/CHANGELOG.md

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

package/README.md

@@ -46,6 +46,8 @@ 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

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; `profiles templates export/import` supports local custom starters.
+- 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:

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; starter JSON can be exported/imported for local custom lanes; 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.
-- Guided starter profile authoring inside the fullscreen Agent workspace.
+- 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.35",
+  "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

@@ -615,6 +615,10 @@ export function getAgentRuntimeProfileTemplate(templateId: AgentRuntimeProfileTe
   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,

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,11 +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-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-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

@@ -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, 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', 'editable starter templates'],
-    next: ['Add guided starter authoring inside the fullscreen Agent workspace.'],
+    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.35';
+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 {