@pellux/goodvibes-agent 0.1.49 → 0.1.51

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.51 - 2026-05-31
+
+- 6a8e8a6 Add local library workspace editors
+
+## 0.1.50 - 2026-05-31
+
+- bdb654a Improve local library workspaces
+
 ## 0.1.49 - 2026-05-31
 
 - 445e694 Show isolated Agent Knowledge in TUI panel

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "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/input/agent-workspace.ts

@@ -1,9 +1,9 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import { basename, sep } from 'node:path';
 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 { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-registry.ts';
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import {
   buildAgentWorkspaceChannels,
@@ -20,7 +20,26 @@ export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
 export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
-export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace';
+export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor';
+
+export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine';
+
+export interface AgentWorkspaceEditorField {
+  readonly id: string;
+  readonly label: string;
+  readonly value: string;
+  readonly required: boolean;
+  readonly multiline: boolean;
+  readonly hint: string;
+}
+
+export interface AgentWorkspaceLocalEditor {
+  readonly kind: AgentWorkspaceLocalEditorKind;
+  readonly title: string;
+  readonly fields: readonly AgentWorkspaceEditorField[];
+  readonly selectedFieldIndex: number;
+  readonly message: string;
+}
 
 export interface AgentWorkspaceAction {
   readonly id: string;
@@ -28,6 +47,7 @@ export interface AgentWorkspaceAction {
   readonly detail: string;
   readonly command?: string;
   readonly targetCategoryId?: string;
+  readonly editorKind?: AgentWorkspaceLocalEditorKind;
   readonly kind: AgentWorkspaceActionKind;
   readonly safety: 'safe' | 'read-only' | 'delegates' | 'blocked';
 }
@@ -53,6 +73,19 @@ export interface AgentWorkspaceActionResult {
   readonly safety?: AgentWorkspaceAction['safety'];
 }
 
+export interface AgentWorkspaceLocalLibraryItem {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly reviewState: string;
+  readonly source: string;
+  readonly tags: readonly string[];
+  readonly triggers: readonly string[];
+  readonly active?: boolean;
+  readonly enabled?: boolean;
+  readonly startCount?: number;
+}
+
 type AgentWorkspaceConfigReader = {
   get(key: string): unknown;
 };
@@ -69,10 +102,13 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly sessionMemoryCount: number;
   readonly localRoutineCount: number;
   readonly enabledRoutineCount: number;
+  readonly localRoutines: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localSkillCount: number;
   readonly enabledSkillCount: number;
+  readonly localSkills: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localPersonaCount: number;
   readonly activePersonaName: string;
+  readonly localPersonas: readonly AgentWorkspaceLocalLibraryItem[];
   readonly knowledgeRoute: '/api/goodvibes-agent/knowledge';
   readonly knowledgeIsolation: 'agent-only';
   readonly executionPolicy: 'serial-proactive';
@@ -143,6 +179,46 @@ function inferActiveRuntimeProfile(homeDirectory: string): string {
   return homeDirectory.includes(marker) ? basename(homeDirectory) : '(default home)';
 }
 
+function summarizePersonaItem(persona: AgentPersonaRecord, activePersonaId: string | null): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: persona.id,
+    name: persona.name,
+    description: persona.description,
+    reviewState: persona.reviewState,
+    source: persona.source,
+    tags: persona.tags,
+    triggers: persona.triggers,
+    active: persona.id === activePersonaId,
+  };
+}
+
+function summarizeSkillItem(skill: AgentSkillRecord): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    reviewState: skill.reviewState,
+    source: skill.source,
+    tags: skill.tags,
+    triggers: skill.triggers,
+    enabled: skill.enabled,
+  };
+}
+
+function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: routine.id,
+    name: routine.name,
+    description: routine.description,
+    reviewState: routine.reviewState,
+    source: routine.source,
+    tags: routine.tags,
+    triggers: routine.triggers,
+    enabled: routine.enabled,
+    startCount: routine.startCount,
+  };
+}
+
 export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): AgentWorkspaceRuntimeSnapshot {
   const host = readConfigString(context, 'controlPlane.host', '127.0.0.1');
   const port = readConfigNumber(context, 'controlPlane.port', 3421);
@@ -165,31 +241,43 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const personaSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, activeName: '(none)' };
+      if (!shellPaths) return { count: 0, activeName: '(none)', items: [] };
       const snapshot = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.personas.length, activeName: snapshot.activePersona?.name ?? '(none)' };
+      return {
+        count: snapshot.personas.length,
+        activeName: snapshot.activePersona?.name ?? '(none)',
+        items: snapshot.personas.map((persona) => summarizePersonaItem(persona, snapshot.activePersonaId)),
+      };
     } catch {
-      return { count: 0, activeName: '(unavailable)' };
+      return { count: 0, activeName: '(unavailable)', items: [] };
     }
   })();
   const skillSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, enabled: 0 };
+      if (!shellPaths) return { count: 0, enabled: 0, items: [] };
       const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.skills.length, enabled: snapshot.enabledSkills.length };
+      return {
+        count: snapshot.skills.length,
+        enabled: snapshot.enabledSkills.length,
+        items: snapshot.skills.map(summarizeSkillItem),
+      };
     } catch {
-      return { count: 0, enabled: 0 };
+      return { count: 0, enabled: 0, items: [] };
     }
   })();
   const routineSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, enabled: 0 };
+      if (!shellPaths) return { count: 0, enabled: 0, items: [] };
       const snapshot = AgentRoutineRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.routines.length, enabled: snapshot.enabledRoutines.length };
+      return {
+        count: snapshot.routines.length,
+        enabled: snapshot.enabledRoutines.length,
+        items: snapshot.routines.map(summarizeRoutineItem),
+      };
     } catch {
-      return { count: 0, enabled: 0 };
+      return { count: 0, enabled: 0, items: [] };
     }
   })();
   const runtimeProfiles = (() => {
@@ -265,10 +353,13 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionMemoryCount,
     localRoutineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
+    localRoutines: routineSnapshot.items,
     localSkillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
+    localSkills: skillSnapshot.items,
     localPersonaCount: personaSnapshot.count,
     activePersonaName: personaSnapshot.activeName,
+    localPersonas: personaSnapshot.items,
     knowledgeRoute: '/api/goodvibes-agent/knowledge',
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',
@@ -329,9 +420,9 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'setup-provider-model', label: 'Provider and model', detail: 'Choose the provider/model route for normal assistant chat.', command: '/model', kind: 'command', safety: 'safe' },
       { id: 'setup-agent-knowledge', label: 'Agent Knowledge', detail: 'Inspect the isolated Agent Knowledge store before ingesting source-backed material.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
       { id: 'setup-runtime-profiles', label: 'Runtime profiles', detail: 'Browse starter templates for isolated Agent homes and operator identities.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
-      { id: 'setup-personas', label: 'Personas', detail: 'Create or select the active local Agent persona.', command: '/personas', kind: 'command', safety: 'safe' },
-      { id: 'setup-skills', label: 'Skills', detail: 'Create, review, and enable reusable local Agent skills.', command: '/agent-skills', kind: 'command', safety: 'safe' },
-      { id: 'setup-routines', label: 'Routines', detail: 'Create, review, and enable local Agent routines before any explicit schedule promotion.', command: '/routines', kind: 'command', safety: 'safe' },
+      { id: 'setup-personas', label: 'Personas', detail: 'Create or select the active local Agent persona.', targetCategoryId: 'personas', kind: 'workspace', safety: 'safe' },
+      { id: 'setup-skills', label: 'Skills', detail: 'Create, review, and enable reusable local Agent skills.', targetCategoryId: 'skills', kind: 'workspace', safety: 'safe' },
+      { id: 'setup-routines', label: 'Routines', detail: 'Create, review, and enable local Agent routines before any explicit schedule promotion.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
       { id: 'setup-memory', label: 'Local memory', detail: 'Inspect local/session memory; secrets stay rejected or redacted.', command: '/memory', kind: 'command', safety: 'read-only' },
       { id: 'setup-channels', label: 'Channels', detail: 'Open companion pairing and channel readiness setup.', command: '/pair', kind: 'command', safety: 'safe' },
       { id: 'setup-voice-media', label: 'Voice and media', detail: 'Open TTS/media settings for voice and image-capable Agent flows.', command: '/config tts', kind: 'command', safety: 'safe' },
@@ -410,9 +501,53 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Memory, routines, skills, and personas stay Agent-local until stable shared daemon registry contracts exist. Secrets must not be stored as memory.',
     actions: [
       { id: 'memory', label: 'Open memory', detail: 'Inspect local/session memory commands and surfaces.', command: '/memory', kind: 'command', safety: 'read-only' },
-      { id: 'routines', label: 'Routine library', detail: 'Create, review, enable, and start local Agent routines in the main conversation.', command: '/routines', kind: 'command', safety: 'safe' },
-      { id: 'skills', label: 'Local skill library', detail: 'Create, review, and enable local Agent reusable procedures.', command: '/agent-skills', kind: 'command', safety: 'safe' },
-      { id: 'personas', label: 'Persona library', detail: 'Use local Agent personas to shape serial assistant behavior without spawning background agents.', command: '/personas', kind: 'command', safety: 'safe' },
+      { id: 'personas', label: 'Persona library', detail: 'Open the local persona workspace for active role selection and review.', targetCategoryId: 'personas', kind: 'workspace', safety: 'safe' },
+      { id: 'skills', label: 'Local skill library', detail: 'Open the local skill workspace for reusable procedures and review.', targetCategoryId: 'skills', kind: 'workspace', safety: 'safe' },
+      { id: 'routines', label: 'Routine library', detail: 'Open the local routine workspace for repeatable workflows and schedule promotion review.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'personas',
+    group: 'LEARN',
+    label: 'Personas',
+    summary: 'Local behavior profiles for the main assistant.',
+    detail: 'Personas shape the serial Agent in the main conversation. They are not background agents and they never spawn specialist roots.',
+    actions: [
+      { id: 'personas-list', label: 'List personas', detail: 'Print the full local persona library.', command: '/personas list', kind: 'command', safety: 'read-only' },
+      { id: 'personas-active', label: 'Show active persona', detail: 'Inspect the active local persona applied to new turns.', command: '/personas active', kind: 'command', safety: 'read-only' },
+      { id: 'personas-create', label: 'Create persona', detail: 'Open an in-workspace form for a local persona. No placeholder command is dispatched.', editorKind: 'persona', kind: 'editor', safety: 'safe' },
+      { id: 'personas-use', label: 'Use persona', detail: 'Activate a local persona by id or name.', command: '/personas use <id>', kind: 'command', safety: 'safe' },
+      { id: 'personas-review', label: 'Review persona', detail: 'Mark a local persona reviewed after inspecting it.', command: '/personas review <id>', kind: 'command', safety: 'safe' },
+      { id: 'personas-clear', label: 'Clear active persona', detail: 'Return to the default Agent policy without deleting any persona.', command: '/personas clear', kind: 'command', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'skills',
+    group: 'LEARN',
+    label: 'Skills',
+    summary: 'Reusable local procedures the assistant can apply on demand.',
+    detail: 'Skills are local, reviewable procedures. Enabled skills inform the main conversation; secret-looking content is rejected.',
+    actions: [
+      { id: 'skills-list', label: 'List skills', detail: 'Print the full local Agent skill library.', command: '/agent-skills list', kind: 'command', safety: 'read-only' },
+      { id: 'skills-enabled', label: 'Enabled skills', detail: 'Show only skills currently injected into Agent guidance.', command: '/agent-skills enabled', kind: 'command', safety: 'read-only' },
+      { id: 'skills-create', label: 'Create skill', detail: 'Open an in-workspace form for a reusable local procedure. No placeholder command is dispatched.', editorKind: 'skill', kind: 'editor', safety: 'safe' },
+      { id: 'skills-enable', label: 'Enable skill', detail: 'Enable a local Agent skill by id or name.', command: '/agent-skills enable <id>', kind: 'command', safety: 'safe' },
+      { id: 'skills-review', label: 'Review skill', detail: 'Mark a local skill reviewed after inspecting it.', command: '/agent-skills review <id>', kind: 'command', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'routines',
+    group: 'LEARN',
+    label: 'Routines',
+    summary: 'Repeatable workflows for the main conversation.',
+    detail: 'Routines run in the main conversation by default. Promotion to an external daemon schedule requires a real schedule command and --yes.',
+    actions: [
+      { id: 'routines-list', label: 'List routines', detail: 'Print the full local Agent routine library.', command: '/routines list', kind: 'command', safety: 'read-only' },
+      { id: 'routines-enabled', label: 'Enabled routines', detail: 'Show routines available for direct use.', command: '/routines enabled', kind: 'command', safety: 'read-only' },
+      { id: 'routines-create', label: 'Create routine', detail: 'Open an in-workspace form for a repeatable local workflow. No placeholder command is dispatched.', editorKind: 'routine', kind: 'editor', safety: 'safe' },
+      { id: 'routines-start', label: 'Start routine', detail: 'Start a local routine in the main conversation without creating a hidden job.', command: '/routines start <id>', kind: 'command', safety: 'safe' },
+      { id: 'routines-promote', label: 'Promote to schedule', detail: 'Create an external daemon schedule from a reviewed routine only with real timing and --yes.', command: '/routines promote <id> --cron <expr> --yes', kind: 'command', safety: 'safe' },
+      { id: 'routines-receipts', label: 'Promotion receipts', detail: 'Inspect local redacted routine schedule promotion receipts.', command: '/routines receipts', kind: 'command', safety: 'read-only' },
     ],
   },
   {
@@ -463,6 +598,70 @@ function parseCommand(command: string): { readonly name: string; readonly args:
   return { name: parts[0] ?? '', args: parts.slice(1) };
 }
 
+function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'persona') {
+    return {
+      kind,
+      title: 'Create Persona',
+      selectedFieldIndex: 0,
+      message: 'Enter a local behavior profile for the serial main-conversation assistant.',
+      fields: [
+        { id: 'name', label: 'Name', value: '', required: true, multiline: false, hint: 'Short persona name.' },
+        { id: 'description', label: 'Description', value: '', required: true, multiline: false, hint: 'One-line summary of when to use it.' },
+        { id: 'body', label: 'Instructions', value: '', required: true, multiline: true, hint: 'Operating guidance. Ctrl-J inserts a new line.' },
+        { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+        { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this persona.' },
+        { id: 'activate', label: 'Activate now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
+      ],
+    };
+  }
+  if (kind === 'skill') {
+    return {
+      kind,
+      title: 'Create Skill',
+      selectedFieldIndex: 0,
+      message: 'Enter a reusable local procedure the assistant can apply from the main conversation.',
+      fields: [
+        { id: 'name', label: 'Name', value: '', required: true, multiline: false, hint: 'Short skill name.' },
+        { id: 'description', label: 'Description', value: '', required: true, multiline: false, hint: 'One-line summary of the procedure.' },
+        { id: 'procedure', label: 'Procedure', value: '', required: true, multiline: true, hint: 'Reusable steps. Ctrl-J inserts a new line.' },
+        { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this skill.' },
+        { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+        { id: 'enabled', label: 'Enable now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
+      ],
+    };
+  }
+  return {
+    kind,
+    title: 'Create Routine',
+    selectedFieldIndex: 0,
+    message: 'Enter a repeatable workflow. It runs in the main conversation unless explicitly promoted to a daemon schedule.',
+    fields: [
+      { id: 'name', label: 'Name', value: '', required: true, multiline: false, hint: 'Short routine name.' },
+      { id: 'description', label: 'Description', value: '', required: true, multiline: false, hint: 'One-line summary of the workflow.' },
+      { id: 'steps', label: 'Steps', value: '', required: true, multiline: true, hint: 'Workflow steps. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this routine.' },
+      { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enabled', label: 'Enable now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
+    ],
+  };
+}
+
+function splitList(value: string): string[] {
+  return value.split(',').map((part) => part.trim()).filter(Boolean);
+}
+
+function isAffirmative(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === '' || normalized === 'yes' || normalized === 'y' || normalized === 'true' || normalized === 'enabled' || normalized === 'on';
+}
+
+function editorCategoryId(kind: AgentWorkspaceLocalEditorKind): string {
+  if (kind === 'persona') return 'personas';
+  if (kind === 'skill') return 'skills';
+  return 'routines';
+}
+
 export class AgentWorkspace {
   public active = false;
   public focusPane: AgentWorkspaceFocusPane = 'actions';
@@ -471,6 +670,7 @@ export class AgentWorkspace {
   public status = 'Ready. Choose an operator flow; ordinary assistant work stays in the main conversation.';
   public runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null = null;
   public lastActionResult: AgentWorkspaceActionResult | null = null;
+  public localEditor: AgentWorkspaceLocalEditor | null = null;
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
 
@@ -482,6 +682,7 @@ export class AgentWorkspace {
     this.focusPane = 'actions';
     this.status = 'Ready. Choose an operator flow; ordinary assistant work stays in the main conversation.';
     this.lastActionResult = null;
+    this.localEditor = null;
     this.clampSelection();
   }
 
@@ -492,6 +693,7 @@ export class AgentWorkspace {
 
   close(): void {
     this.active = false;
+    this.localEditor = null;
   }
 
   get categories(): readonly AgentWorkspaceCategory[] {
@@ -573,13 +775,86 @@ export class AgentWorkspace {
     };
   }
 
+  cancelLocalEditor(): void {
+    if (!this.localEditor) return;
+    const title = this.localEditor.title;
+    this.localEditor = null;
+    this.status = `${title} cancelled.`;
+    this.lastActionResult = {
+      kind: 'guidance',
+      title: `${title} cancelled`,
+      detail: 'No local Agent registry changes were written.',
+    };
+  }
+
+  moveEditorField(delta: number): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    const nextIndex = Math.max(0, Math.min(editor.fields.length - 1, editor.selectedFieldIndex + delta));
+    this.localEditor = { ...editor, selectedFieldIndex: nextIndex };
+  }
+
+  appendEditorText(text: string): void {
+    const editor = this.localEditor;
+    if (!editor || text.length === 0) return;
+    const field = editor.fields[editor.selectedFieldIndex];
+    if (!field) return;
+    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}${text}`, editor.message);
+  }
+
+  appendEditorNewline(): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    const field = editor.fields[editor.selectedFieldIndex];
+    if (!field || !field.multiline) {
+      this.moveEditorField(1);
+      return;
+    }
+    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}\n`, editor.message);
+  }
+
+  editorBackspace(): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    const field = editor.fields[editor.selectedFieldIndex];
+    if (!field || field.value.length === 0) return;
+    const characters = Array.from(field.value);
+    characters.pop();
+    this.replaceEditorField(editor.selectedFieldIndex, characters.join(''), editor.message);
+  }
+
+  submitEditorFieldOrForm(): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    if (editor.selectedFieldIndex < editor.fields.length - 1) {
+      this.moveEditorField(1);
+      return;
+    }
+    this.submitLocalEditor();
+  }
+
   activateSelected(): void {
+    if (this.localEditor) {
+      this.submitEditorFieldOrForm();
+      return;
+    }
     if (this.focusPane === 'categories') {
       this.focusActions();
       return;
     }
     const action = this.selectedAction;
     if (!action) return;
+    if (action.kind === 'editor' && action.editorKind) {
+      this.localEditor = createLocalEditor(action.editorKind);
+      this.status = `Editing ${this.localEditor.title}.`;
+      this.lastActionResult = {
+        kind: 'guidance',
+        title: this.localEditor.title,
+        detail: this.localEditor.message,
+        safety: action.safety,
+      };
+      return;
+    }
     if (action.kind === 'guidance' || !action.command) {
       if (action.kind === 'workspace' && action.targetCategoryId) {
         const targetIndex = this.categories.findIndex((category) => category.id === action.targetCategoryId);
@@ -674,6 +949,121 @@ export class AgentWorkspace {
     this.selectedCategoryIndex = Math.max(0, Math.min(this.selectedCategoryIndex, this.categories.length - 1));
     this.selectedActionIndex = Math.max(0, Math.min(this.selectedActionIndex, this.actions.length - 1));
   }
+
+  private replaceEditorField(index: number, value: string, message: string): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    const fields = editor.fields.map((field, fieldIndex) => fieldIndex === index ? { ...field, value } : field);
+    this.localEditor = { ...editor, fields, message };
+  }
+
+  private editorField(id: string): string {
+    const editor = this.localEditor;
+    return editor?.fields.find((field) => field.id === id)?.value.trim() ?? '';
+  }
+
+  private missingEditorField(): AgentWorkspaceEditorField | null {
+    const editor = this.localEditor;
+    if (!editor) return null;
+    return editor.fields.find((field) => field.required && field.value.trim().length === 0) ?? null;
+  }
+
+  private submitLocalEditor(): void {
+    const editor = this.localEditor;
+    if (!editor) return;
+    const missing = this.missingEditorField();
+    if (missing) {
+      const missingIndex = editor.fields.findIndex((field) => field.id === missing.id);
+      this.localEditor = {
+        ...editor,
+        selectedFieldIndex: Math.max(0, missingIndex),
+        message: `${missing.label} is required before saving.`,
+      };
+      this.status = `${missing.label} is required.`;
+      return;
+    }
+    const shellPaths = this.context?.workspace?.shellPaths;
+    if (!shellPaths) {
+      this.localEditor = { ...editor, message: 'Cannot save because Agent shell paths are unavailable.' };
+      this.status = 'Cannot save local Agent registry item without shell paths.';
+      this.lastActionResult = {
+        kind: 'error',
+        title: 'Local registry unavailable',
+        detail: 'The Agent workspace cannot locate the Agent-local registry files for this runtime.',
+      };
+      return;
+    }
+    try {
+      if (editor.kind === 'persona') {
+        const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+        const created = registry.create({
+          name: this.editorField('name'),
+          description: this.editorField('description'),
+          body: this.editorField('body'),
+          tags: splitList(this.editorField('tags')),
+          triggers: splitList(this.editorField('triggers')),
+          source: 'user',
+          provenance: 'agent-workspace',
+        });
+        if (isAffirmative(this.editorField('activate'))) registry.setActive(created.id);
+        this.finishLocalEditor(editor.kind, created.id, created.name);
+      } else if (editor.kind === 'skill') {
+        const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+        const created = registry.create({
+          name: this.editorField('name'),
+          description: this.editorField('description'),
+          procedure: this.editorField('procedure'),
+          triggers: splitList(this.editorField('triggers')),
+          tags: splitList(this.editorField('tags')),
+          enabled: isAffirmative(this.editorField('enabled')),
+          source: 'user',
+          provenance: 'agent-workspace',
+        });
+        this.finishLocalEditor(editor.kind, created.id, created.name);
+      } else {
+        const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+        const created = registry.create({
+          name: this.editorField('name'),
+          description: this.editorField('description'),
+          steps: this.editorField('steps'),
+          triggers: splitList(this.editorField('triggers')),
+          tags: splitList(this.editorField('tags')),
+          enabled: isAffirmative(this.editorField('enabled')),
+          source: 'user',
+          provenance: 'agent-workspace',
+        });
+        this.finishLocalEditor(editor.kind, created.id, created.name);
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      this.localEditor = { ...editor, message: detail };
+      this.status = detail;
+      this.lastActionResult = {
+        kind: 'error',
+        title: `${editor.title} failed`,
+        detail,
+      };
+    }
+  }
+
+  private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
+    this.localEditor = null;
+    const categoryId = editorCategoryId(kind);
+    const categoryIndex = this.categories.findIndex((category) => category.id === categoryId);
+    if (categoryIndex >= 0) {
+      this.selectedCategoryIndex = categoryIndex;
+      this.selectedActionIndex = 0;
+    }
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    this.status = `Created ${kind}: ${name}.`;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title: `Created ${kind}`,
+      detail: `${name} (${id}) was saved to the Agent-local ${categoryId} registry.`,
+      safety: 'safe',
+    };
+    this.clampSelection();
+  }
 }
 
 export function handleAgentWorkspaceToken(
@@ -684,6 +1074,21 @@ export function handleAgentWorkspaceToken(
 ): boolean {
   if (!workspace.active) return false;
 
+  if (workspace.localEditor) {
+    if (token.type === 'text') {
+      workspace.appendEditorText(token.value);
+    } else if (token.type === 'key') {
+      if (token.logicalName === 'escape') workspace.cancelLocalEditor();
+      else if (token.logicalName === 'enter') workspace.submitEditorFieldOrForm();
+      else if (token.logicalName === 'tab' || token.logicalName === 'down') workspace.moveEditorField(1);
+      else if (token.logicalName === 'up') workspace.moveEditorField(-1);
+      else if (token.logicalName === 'backspace' || token.logicalName === 'delete') workspace.editorBackspace();
+      else if (token.logicalName === 'j' && token.ctrl === true) workspace.appendEditorNewline();
+    }
+    requestRender();
+    return true;
+  }
+
   if (token.type === 'key') {
     if (token.logicalName === 'escape') {
       handleEscape();

package/src/renderer/agent-workspace.ts

@@ -3,6 +3,7 @@ import type {
   AgentWorkspaceAction,
   AgentWorkspaceActionResult,
   AgentWorkspaceCategory,
+  AgentWorkspaceLocalEditor,
   AgentWorkspaceRuntimeSnapshot,
 } from '../input/agent-workspace.ts';
 import type { Line } from '../types/grid.ts';
@@ -68,6 +69,7 @@ function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[
 
 function actionCommand(action: AgentWorkspaceAction): string {
   if (action.kind === 'workspace') return action.targetCategoryId ? `open ${action.targetCategoryId}` : '(workspace)';
+  if (action.kind === 'editor') return action.editorKind ? `edit ${action.editorKind}` : '(editor)';
   return action.command ?? '(guidance)';
 }
 
@@ -100,6 +102,40 @@ function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLi
   return lines;
 }
 
+function localLibraryLines(
+  title: string,
+  items: readonly AgentWorkspaceRuntimeSnapshot['localPersonas'][number][],
+  emptyText: string,
+): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: title, fg: PALETTE.title, bold: true },
+  ];
+  if (items.length === 0) {
+    lines.push({ text: emptyText, fg: PALETTE.warn });
+    return lines;
+  }
+  for (const item of items.slice(0, 8)) {
+    const status = [
+      item.active ? 'active' : '',
+      item.enabled === true ? 'enabled' : item.enabled === false ? 'disabled' : '',
+      item.reviewState,
+      item.startCount !== undefined ? `starts ${item.startCount}` : '',
+    ].filter(Boolean).join(' / ');
+    const tags = item.tags.length > 0 ? ` tags=${item.tags.join(',')}` : '';
+    const triggers = item.triggers.length > 0 ? ` triggers=${item.triggers.join(',')}` : '';
+    lines.push({
+      text: `${item.id}: ${item.name} (${status})`,
+      fg: item.reviewState === 'stale' ? PALETTE.warn : PALETTE.info,
+      bold: item.active === true,
+    });
+    lines.push({ text: `  ${item.description}${tags}${triggers}`, fg: PALETTE.muted });
+  }
+  if (items.length > 8) {
+    lines.push({ text: `${items.length - 8} more item(s). Open the library command for the full list.`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
 function snapshotLines(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 }];
@@ -178,6 +214,30 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: 'Durable memory, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
       { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
     );
+  } else if (category.id === 'personas') {
+    base.push(
+      { text: `Personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
+      { text: 'Personas are local behavior profiles for the serial main-conversation assistant, not spawned agents.', fg: PALETTE.good },
+      { text: 'Use them for tone, role, domain constraints, tool posture, and repeatable operating preferences.', fg: PALETTE.muted },
+      { text: '' },
+      ...localLibraryLines('Persona Library', snapshot.localPersonas, 'No local personas yet. Create one with /personas create ...'),
+    );
+  } else if (category.id === 'skills') {
+    base.push(
+      { text: `Skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}`, fg: PALETTE.info },
+      { text: 'Skills are reusable local procedures the assistant can apply from the main conversation.', fg: PALETTE.good },
+      { text: 'Enabled skills are injected as operating guidance; secret-looking content is rejected.', fg: PALETTE.warn },
+      { text: '' },
+      ...localLibraryLines('Skill Library', snapshot.localSkills, 'No local skills yet. Create one with /agent-skills create ...'),
+    );
+  } else if (category.id === 'routines') {
+    base.push(
+      { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
+      { text: 'Routines are repeatable main-conversation workflows. Starting one does not create hidden jobs.', fg: PALETTE.good },
+      { text: 'Scheduling a reviewed routine is explicit and writes to the externally owned daemon only with --yes.', fg: PALETTE.warn },
+      { text: '' },
+      ...localLibraryLines('Routine Library', snapshot.localRoutines, 'No local routines yet. Create one with /routines create ...'),
+    );
   } else if (category.id === 'work') {
     base.push(
       { text: 'Work plan and approvals are read or explicitly confirmed through public operator routes.', fg: PALETTE.info },
@@ -202,6 +262,23 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
   return base;
 }
 
+function editorContextLines(editor: AgentWorkspaceLocalEditor): ContextLine[] {
+  const selected = editor.fields[editor.selectedFieldIndex];
+  const lines: ContextLine[] = [
+    { text: editor.title, fg: PALETTE.title, bold: true },
+    { text: editor.message, fg: editor.message.includes('required') || editor.message.includes('cannot') || editor.message.includes('Cannot') ? PALETTE.warn : PALETTE.info },
+    { text: 'Enter advances fields and saves from the final field. Ctrl-J adds a line inside multiline fields. Esc cancels without writing.', fg: PALETTE.muted },
+  ];
+  if (selected) {
+    lines.push(
+      { text: '' },
+      { text: `Editing: ${selected.label}${selected.required ? ' (required)' : ''}`, fg: PALETTE.title, bold: true },
+      { text: selected.hint, fg: PALETTE.muted },
+    );
+  }
+  return lines;
+}
+
 function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction | null, width: number): WorkspaceRow[] {
   const lines: ContextLine[] = [
     { text: category.label, fg: PALETTE.title, bold: true },
@@ -209,6 +286,8 @@ function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCat
     { text: '' },
     { text: category.detail, fg: PALETTE.text },
     { text: '' },
+    ...(workspace.localEditor ? editorContextLines(workspace.localEditor) : []),
+    ...(workspace.localEditor ? [{ text: '' }] : []),
     ...snapshotLines(category, workspace.runtimeSnapshot),
   ];
 
@@ -245,7 +324,42 @@ function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCat
   });
 }
 
+function buildEditorRows(editor: AgentWorkspaceLocalEditor, width: number, height: number): WorkspaceRow[] {
+  const rows: WorkspaceRow[] = [
+    { text: editor.title, fg: PALETTE.title, bold: true },
+    { text: editor.message, fg: PALETTE.info },
+    { text: '' },
+  ];
+  for (let index = 0; index < editor.fields.length; index += 1) {
+    const field = editor.fields[index]!;
+    const selected = index === editor.selectedFieldIndex;
+    const marker = selected ? GLYPHS.navigation.selected : ' ';
+    const required = field.required ? ' *' : '';
+    const value = field.value.length > 0 ? field.value : '(empty)';
+    const color = selected ? PALETTE.text : field.value.length > 0 ? PALETTE.info : PALETTE.muted;
+    rows.push({
+      text: `${marker} ${field.label}${required}`,
+      selected,
+      fg: color,
+      bold: selected,
+    });
+    const valueLines = value.split('\n');
+    for (const valueLine of valueLines.slice(0, 4)) {
+      for (const wrapped of wrapText(`  ${valueLine}`, Math.max(1, width - 2))) {
+        rows.push({ text: wrapped, fg: field.value.length > 0 ? PALETTE.text : PALETTE.dim, dim: field.value.length === 0 });
+      }
+    }
+    if (valueLines.length > 4) rows.push({ text: `  ${valueLines.length - 4} more line(s)`, fg: PALETTE.dim, dim: true });
+    rows.push({ text: `  ${field.hint}`, fg: PALETTE.dim, dim: true });
+  }
+  rows.push({ text: '' });
+  rows.push({ text: 'Enter next/save · Up/Down field · Backspace edit · Ctrl-J newline · Esc cancel', fg: PALETTE.muted });
+  while (rows.length < height) rows.push({ text: '', kind: 'empty' });
+  return rows.slice(0, height);
+}
+
 function buildActionRows(workspace: AgentWorkspace, width: number, height: number): WorkspaceRow[] {
+  if (workspace.localEditor) return buildEditorRows(workspace.localEditor, width, height);
   const rows: WorkspaceRow[] = [];
   const labelWidth = Math.min(28, Math.max(16, Math.floor(width * 0.30)));
   const safetyWidth = 10;
@@ -292,6 +406,9 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
 }
 
 function footerText(workspace: AgentWorkspace): string {
+  if (workspace.localEditor) {
+    return `Agent workspace · editing ${workspace.localEditor.kind} · Enter next/save · Ctrl-J newline · Esc cancel`;
+  }
   const focus = workspace.focusPane === 'categories' ? 'categories' : 'actions';
   return `Agent workspace · focus ${focus} · Up/Down navigate · Left/Right pane · Enter open/action · R refresh · Esc close`;
 }
@@ -313,7 +430,7 @@ export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, h
     width,
     height,
     title: 'GoodVibes Agent / Operator Workspace',
-    stateLabel: workspace.focusPane === 'categories' ? 'Categories' : 'Actions',
+    stateLabel: workspace.localEditor ? 'Editor' : workspace.focusPane === 'categories' ? 'Categories' : 'Actions',
     leftHeader: 'Operator Areas',
     mainHeader: `${category.label} · ${category.actions.length} action(s)`,
     leftRows: buildLeftRows(workspace, metrics.bodyRows),

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