@pellux/goodvibes-agent 0.1.51 → 0.1.53

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.53 - 2026-05-31
+
+- 77ad0cf Add local library edit workspace flow
+
+## 0.1.52 - 2026-05-31
+
+- e543fa5 Add selected local library actions
+
 ## 0.1.51 - 2026-05-31
 
 - 6a8e8a6 Add local library workspace editors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "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

@@ -20,10 +20,25 @@ export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
 export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
-export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor';
+export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'local-selection' | 'local-operation';
 
 export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine';
 
+export type AgentWorkspaceLocalOperation =
+  | 'persona-edit'
+  | 'persona-use'
+  | 'persona-review'
+  | 'persona-clear'
+  | 'skill-edit'
+  | 'skill-enable'
+  | 'skill-disable'
+  | 'skill-review'
+  | 'routine-edit'
+  | 'routine-start'
+  | 'routine-enable'
+  | 'routine-disable'
+  | 'routine-review';
+
 export interface AgentWorkspaceEditorField {
   readonly id: string;
   readonly label: string;
@@ -35,6 +50,8 @@ export interface AgentWorkspaceEditorField {
 
 export interface AgentWorkspaceLocalEditor {
   readonly kind: AgentWorkspaceLocalEditorKind;
+  readonly mode: 'create' | 'update';
+  readonly recordId?: string;
   readonly title: string;
   readonly fields: readonly AgentWorkspaceEditorField[];
   readonly selectedFieldIndex: number;
@@ -48,6 +65,9 @@ export interface AgentWorkspaceAction {
   readonly command?: string;
   readonly targetCategoryId?: string;
   readonly editorKind?: AgentWorkspaceLocalEditorKind;
+  readonly localKind?: AgentWorkspaceLocalEditorKind;
+  readonly selectionDelta?: number;
+  readonly localOperation?: AgentWorkspaceLocalOperation;
   readonly kind: AgentWorkspaceActionKind;
   readonly safety: 'safe' | 'read-only' | 'delegates' | 'blocked';
 }
@@ -515,10 +535,13 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     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-prev', label: 'Previous persona', detail: 'Move the local persona selection up without changing active state.', localKind: 'persona', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
+      { id: 'personas-next', label: 'Next persona', detail: 'Move the local persona selection down without changing active state.', localKind: 'persona', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { 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: 'personas-edit', label: 'Edit selected', detail: 'Open the selected local persona in an in-workspace editor.', localKind: 'persona', localOperation: 'persona-edit', kind: 'local-operation', safety: 'safe' },
+      { id: 'personas-use', label: 'Use selected', detail: 'Activate the selected local persona for future main-conversation turns.', localKind: 'persona', localOperation: 'persona-use', kind: 'local-operation', safety: 'safe' },
+      { id: 'personas-review', label: 'Review selected', detail: 'Mark the selected local persona reviewed after inspecting it.', localKind: 'persona', localOperation: 'persona-review', kind: 'local-operation', safety: 'safe' },
+      { id: 'personas-clear', label: 'Clear active persona', detail: 'Return to the default Agent policy without deleting any persona.', localKind: 'persona', localOperation: 'persona-clear', kind: 'local-operation', safety: 'safe' },
     ],
   },
   {
@@ -530,9 +553,13 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     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-prev', label: 'Previous skill', detail: 'Move the local skill selection up without changing enabled state.', localKind: 'skill', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
+      { id: 'skills-next', label: 'Next skill', detail: 'Move the local skill selection down without changing enabled state.', localKind: 'skill', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { 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: 'skills-edit', label: 'Edit selected', detail: 'Open the selected local Agent skill in an in-workspace editor.', localKind: 'skill', localOperation: 'skill-edit', kind: 'local-operation', safety: 'safe' },
+      { id: 'skills-enable', label: 'Enable selected', detail: 'Enable the selected local Agent skill for future main-conversation guidance.', localKind: 'skill', localOperation: 'skill-enable', kind: 'local-operation', safety: 'safe' },
+      { id: 'skills-disable', label: 'Disable selected', detail: 'Disable the selected local Agent skill without deleting it.', localKind: 'skill', localOperation: 'skill-disable', kind: 'local-operation', safety: 'safe' },
+      { id: 'skills-review', label: 'Review selected', detail: 'Mark the selected local skill reviewed after inspecting it.', localKind: 'skill', localOperation: 'skill-review', kind: 'local-operation', safety: 'safe' },
     ],
   },
   {
@@ -544,8 +571,14 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     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-prev', label: 'Previous routine', detail: 'Move the local routine selection up without changing enabled state.', localKind: 'routine', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
+      { id: 'routines-next', label: 'Next routine', detail: 'Move the local routine selection down without changing enabled state.', localKind: 'routine', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { 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-edit', label: 'Edit selected', detail: 'Open the selected local Agent routine in an in-workspace editor.', localKind: 'routine', localOperation: 'routine-edit', kind: 'local-operation', safety: 'safe' },
+      { id: 'routines-start', label: 'Start selected', detail: 'Mark the selected routine started and show it as a main-conversation workflow. This creates no hidden job.', localKind: 'routine', localOperation: 'routine-start', kind: 'local-operation', safety: 'safe' },
+      { id: 'routines-enable', label: 'Enable selected', detail: 'Enable the selected routine for future main-conversation guidance.', localKind: 'routine', localOperation: 'routine-enable', kind: 'local-operation', safety: 'safe' },
+      { id: 'routines-disable', label: 'Disable selected', detail: 'Disable the selected routine without deleting it.', localKind: 'routine', localOperation: 'routine-disable', kind: 'local-operation', safety: 'safe' },
+      { id: 'routines-review', label: 'Review selected', detail: 'Mark the selected local routine reviewed after inspecting it.', localKind: 'routine', localOperation: 'routine-review', kind: 'local-operation', 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' },
     ],
@@ -602,6 +635,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   if (kind === 'persona') {
     return {
       kind,
+      mode: 'create',
       title: 'Create Persona',
       selectedFieldIndex: 0,
       message: 'Enter a local behavior profile for the serial main-conversation assistant.',
@@ -618,6 +652,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   if (kind === 'skill') {
     return {
       kind,
+      mode: 'create',
       title: 'Create Skill',
       selectedFieldIndex: 0,
       message: 'Enter a reusable local procedure the assistant can apply from the main conversation.',
@@ -633,6 +668,7 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   }
   return {
     kind,
+    mode: 'create',
     title: 'Create Routine',
     selectedFieldIndex: 0,
     message: 'Enter a repeatable workflow. It runs in the main conversation unless explicitly promoted to a daemon schedule.',
@@ -647,6 +683,63 @@ function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceL
   };
 }
 
+function createPersonaUpdateEditor(record: AgentPersonaRecord, active: boolean): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'persona',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Persona',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short persona name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of when to use it.' },
+      { id: 'body', label: 'Instructions', value: record.body, required: true, multiline: true, hint: 'Operating guidance. Ctrl-J inserts a new line.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this persona.' },
+      { id: 'activate', label: 'Active', value: active ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no. Setting no clears this persona only if it is currently active.' },
+    ],
+  };
+}
+
+function createSkillUpdateEditor(record: AgentSkillRecord): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'skill',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Skill',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short skill name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of the procedure.' },
+      { id: 'procedure', label: 'Procedure', value: record.procedure, required: true, multiline: true, hint: 'Reusable steps. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this skill.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
+    ],
+  };
+}
+
+function createRoutineUpdateEditor(record: AgentRoutineRecord): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'routine',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Routine',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.name}. Saving marks it fresh for review.`,
+    fields: [
+      { id: 'name', label: 'Name', value: record.name, required: true, multiline: false, hint: 'Short routine name.' },
+      { id: 'description', label: 'Description', value: record.description, required: true, multiline: false, hint: 'One-line summary of the workflow.' },
+      { id: 'steps', label: 'Steps', value: record.steps, required: true, multiline: true, hint: 'Workflow steps. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this routine.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
+    ],
+  };
+}
+
 function splitList(value: string): string[] {
   return value.split(',').map((part) => part.trim()).filter(Boolean);
 }
@@ -671,6 +764,11 @@ export class AgentWorkspace {
   public runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null = null;
   public lastActionResult: AgentWorkspaceActionResult | null = null;
   public localEditor: AgentWorkspaceLocalEditor | null = null;
+  private readonly selectedLibraryItemIndexes: Record<AgentWorkspaceLocalEditorKind, number> = {
+    persona: 0,
+    skill: 0,
+    routine: 0,
+  };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
 
@@ -712,6 +810,13 @@ export class AgentWorkspace {
     return this.actions[this.selectedActionIndex] ?? null;
   }
 
+  selectedLocalLibraryItem(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalLibraryItem | null {
+    const items = this.localLibraryItems(kind);
+    if (items.length === 0) return null;
+    const index = Math.max(0, Math.min(this.selectedLibraryItemIndexes[kind], items.length - 1));
+    return items[index] ?? null;
+  }
+
   focusCategories(): void {
     this.focusPane = 'categories';
   }
@@ -855,6 +960,14 @@ export class AgentWorkspace {
       };
       return;
     }
+    if (action.kind === 'local-selection' && action.localKind) {
+      this.moveLocalLibraryItemSelection(action.localKind, action.selectionDelta ?? 0);
+      return;
+    }
+    if (action.kind === 'local-operation' && action.localOperation) {
+      this.applyLocalLibraryOperation(action.localOperation);
+      return;
+    }
     if (action.kind === 'guidance' || !action.command) {
       if (action.kind === 'workspace' && action.targetCategoryId) {
         const targetIndex = this.categories.findIndex((category) => category.id === action.targetCategoryId);
@@ -948,6 +1061,164 @@ export class AgentWorkspace {
   private clampSelection(): void {
     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));
+    this.clampLocalLibrarySelection('persona');
+    this.clampLocalLibrarySelection('skill');
+    this.clampLocalLibrarySelection('routine');
+  }
+
+  private localLibraryItems(kind: AgentWorkspaceLocalEditorKind): readonly AgentWorkspaceLocalLibraryItem[] {
+    if (kind === 'persona') return this.runtimeSnapshot?.localPersonas ?? [];
+    if (kind === 'skill') return this.runtimeSnapshot?.localSkills ?? [];
+    return this.runtimeSnapshot?.localRoutines ?? [];
+  }
+
+  private clampLocalLibrarySelection(kind: AgentWorkspaceLocalEditorKind): void {
+    const length = this.localLibraryItems(kind).length;
+    this.selectedLibraryItemIndexes[kind] = length === 0
+      ? 0
+      : Math.max(0, Math.min(this.selectedLibraryItemIndexes[kind], length - 1));
+  }
+
+  private moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void {
+    const items = this.localLibraryItems(kind);
+    if (items.length === 0) {
+      this.status = `No local ${kind} records to select.`;
+      this.lastActionResult = {
+        kind: 'guidance',
+        title: `No ${kind} records`,
+        detail: `Create a local ${kind} before using selection actions.`,
+        safety: 'safe',
+      };
+      return;
+    }
+    this.selectedLibraryItemIndexes[kind] = Math.max(0, Math.min(items.length - 1, this.selectedLibraryItemIndexes[kind] + delta));
+    const selected = this.selectedLocalLibraryItem(kind);
+    this.status = selected ? `Selected ${kind}: ${selected.name}.` : `Selected ${kind} updated.`;
+    this.lastActionResult = {
+      kind: 'guidance',
+      title: selected ? `Selected ${selected.name}` : `Selected ${kind}`,
+      detail: selected ? `${selected.name} (${selected.id}) is now the selected local ${kind}.` : `Selection changed for ${kind}.`,
+      safety: 'safe',
+    };
+  }
+
+  private applyLocalLibraryOperation(operation: AgentWorkspaceLocalOperation): void {
+    const shellPaths = this.context?.workspace?.shellPaths;
+    if (!shellPaths) {
+      this.status = 'Local Agent registry files are unavailable.';
+      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 (operation === 'persona-clear') {
+        AgentPersonaRegistry.fromShellPaths(shellPaths).clearActive();
+        this.finishLocalOperation('persona', 'Cleared active persona', 'The default Agent policy will apply to future turns.');
+        return;
+      }
+      const selected = this.selectedItemForOperation(operation);
+      if (!selected) {
+        this.status = 'No selected local registry item.';
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: 'Nothing selected',
+          detail: 'Create or select a local library item before running this action.',
+          safety: 'safe',
+        };
+        return;
+      }
+      if (operation === 'persona-edit') {
+        const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+        const persona = registry.get(selected.id);
+        if (!persona) throw new Error(`Unknown persona: ${selected.id}`);
+        this.localEditor = createPersonaUpdateEditor(persona, registry.snapshot().activePersonaId === persona.id);
+        this.status = `Editing persona: ${persona.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
+      } else if (operation === 'persona-use') {
+        AgentPersonaRegistry.fromShellPaths(shellPaths).setActive(selected.id);
+        this.finishLocalOperation('persona', `Using persona ${selected.name}`, `${selected.name} will shape future main-conversation turns.`);
+      } else if (operation === 'persona-review') {
+        AgentPersonaRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
+        this.finishLocalOperation('persona', `Reviewed persona ${selected.name}`, `${selected.name} is marked reviewed.`);
+      } else if (operation === 'skill-edit') {
+        const skill = AgentSkillRegistry.fromShellPaths(shellPaths).get(selected.id);
+        if (!skill) throw new Error(`Unknown skill: ${selected.id}`);
+        this.localEditor = createSkillUpdateEditor(skill);
+        this.status = `Editing skill: ${skill.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
+      } else if (operation === 'skill-enable') {
+        AgentSkillRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, true);
+        this.finishLocalOperation('skill', `Enabled skill ${selected.name}`, `${selected.name} can now inform main-conversation turns.`);
+      } else if (operation === 'skill-disable') {
+        AgentSkillRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, false);
+        this.finishLocalOperation('skill', `Disabled skill ${selected.name}`, `${selected.name} remains saved but is no longer injected into guidance.`);
+      } else if (operation === 'skill-review') {
+        AgentSkillRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
+        this.finishLocalOperation('skill', `Reviewed skill ${selected.name}`, `${selected.name} is marked reviewed.`);
+      } else if (operation === 'routine-edit') {
+        const routine = AgentRoutineRegistry.fromShellPaths(shellPaths).get(selected.id);
+        if (!routine) throw new Error(`Unknown routine: ${selected.id}`);
+        this.localEditor = createRoutineUpdateEditor(routine);
+        this.status = `Editing routine: ${routine.name}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
+      } else if (operation === 'routine-start') {
+        AgentRoutineRegistry.fromShellPaths(shellPaths).markStarted(selected.id);
+        this.finishLocalOperation('routine', `Started routine ${selected.name}`, `${selected.name} was marked started for this main-conversation workflow. No hidden job was created.`);
+      } else if (operation === 'routine-enable') {
+        AgentRoutineRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, true);
+        this.finishLocalOperation('routine', `Enabled routine ${selected.name}`, `${selected.name} can now inform main-conversation turns.`);
+      } else if (operation === 'routine-disable') {
+        AgentRoutineRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, false);
+        this.finishLocalOperation('routine', `Disabled routine ${selected.name}`, `${selected.name} remains saved but is no longer injected into guidance.`);
+      } else {
+        AgentRoutineRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
+        this.finishLocalOperation('routine', `Reviewed routine ${selected.name}`, `${selected.name} is marked reviewed.`);
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      this.status = detail;
+      this.lastActionResult = {
+        kind: 'error',
+        title: 'Local registry action failed',
+        detail,
+      };
+    }
+  }
+
+  private selectedItemForOperation(operation: AgentWorkspaceLocalOperation): AgentWorkspaceLocalLibraryItem | null {
+    if (operation.startsWith('persona-')) return this.selectedLocalLibraryItem('persona');
+    if (operation.startsWith('skill-')) return this.selectedLocalLibraryItem('skill');
+    return this.selectedLocalLibraryItem('routine');
+  }
+
+  private finishLocalOperation(kind: AgentWorkspaceLocalEditorKind, title: string, detail: string): void {
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    this.clampLocalLibrarySelection(kind);
+    this.status = title;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title,
+      detail,
+      safety: 'safe',
+    };
   }
 
   private replaceEditorField(index: number, value: string, message: string): void {
@@ -996,6 +1267,21 @@ export class AgentWorkspace {
     try {
       if (editor.kind === 'persona') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const wasActive = registry.snapshot().activePersonaId === editor.recordId;
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            body: this.editorField('body'),
+            tags: splitList(this.editorField('tags')),
+            triggers: splitList(this.editorField('triggers')),
+            provenance: 'agent-workspace',
+          });
+          if (isAffirmative(this.editorField('activate'))) registry.setActive(updated.id);
+          else if (wasActive) registry.clearActive();
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1006,9 +1292,22 @@ export class AgentWorkspace {
           provenance: 'agent-workspace',
         });
         if (isAffirmative(this.editorField('activate'))) registry.setActive(created.id);
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       } else if (editor.kind === 'skill') {
         const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            procedure: this.editorField('procedure'),
+            triggers: splitList(this.editorField('triggers')),
+            tags: splitList(this.editorField('tags')),
+            provenance: 'agent-workspace',
+          });
+          registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1019,9 +1318,22 @@ export class AgentWorkspace {
           source: 'user',
           provenance: 'agent-workspace',
         });
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       } else {
         const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const updated = registry.update(editor.recordId, {
+            name: this.editorField('name'),
+            description: this.editorField('description'),
+            steps: this.editorField('steps'),
+            triggers: splitList(this.editorField('triggers')),
+            tags: splitList(this.editorField('tags')),
+            provenance: 'agent-workspace',
+          });
+          registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
+          this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
+          return;
+        }
         const created = registry.create({
           name: this.editorField('name'),
           description: this.editorField('description'),
@@ -1032,7 +1344,7 @@ export class AgentWorkspace {
           source: 'user',
           provenance: 'agent-workspace',
         });
-        this.finishLocalEditor(editor.kind, created.id, created.name);
+        this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       }
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
@@ -1046,7 +1358,7 @@ export class AgentWorkspace {
     }
   }
 
-  private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
+  private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string, verb: 'Created' | 'Updated'): void {
     this.localEditor = null;
     const categoryId = editorCategoryId(kind);
     const categoryIndex = this.categories.findIndex((category) => category.id === categoryId);
@@ -1055,10 +1367,10 @@ export class AgentWorkspace {
       this.selectedActionIndex = 0;
     }
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
-    this.status = `Created ${kind}: ${name}.`;
+    this.status = `${verb} ${kind}: ${name}.`;
     this.lastActionResult = {
       kind: 'refreshed',
-      title: `Created ${kind}`,
+      title: `${verb} ${kind}`,
       detail: `${name} (${id}) was saved to the Agent-local ${categoryId} registry.`,
       safety: 'safe',
     };

package/src/renderer/agent-workspace.ts

@@ -70,6 +70,8 @@ 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)';
+  if (action.kind === 'local-selection') return action.selectionDelta && action.selectionDelta < 0 ? 'select previous' : 'select next';
+  if (action.kind === 'local-operation') return action.localOperation ?? '(local action)';
   return action.command ?? '(guidance)';
 }
 
@@ -106,6 +108,7 @@ function localLibraryLines(
   title: string,
   items: readonly AgentWorkspaceRuntimeSnapshot['localPersonas'][number][],
   emptyText: string,
+  selectedId: string | null,
 ): ContextLine[] {
   const lines: ContextLine[] = [
     { text: title, fg: PALETTE.title, bold: true },
@@ -115,7 +118,9 @@ function localLibraryLines(
     return lines;
   }
   for (const item of items.slice(0, 8)) {
+    const selected = item.id === selectedId;
     const status = [
+      selected ? 'selected' : '',
       item.active ? 'active' : '',
       item.enabled === true ? 'enabled' : item.enabled === false ? 'disabled' : '',
       item.reviewState,
@@ -123,10 +128,11 @@ function localLibraryLines(
     ].filter(Boolean).join(' / ');
     const tags = item.tags.length > 0 ? ` tags=${item.tags.join(',')}` : '';
     const triggers = item.triggers.length > 0 ? ` triggers=${item.triggers.join(',')}` : '';
+    const marker = selected ? `${GLYPHS.navigation.selected} ` : '';
     lines.push({
-      text: `${item.id}: ${item.name} (${status})`,
+      text: `${marker}${item.id}: ${item.name} (${status})`,
       fg: item.reviewState === 'stale' ? PALETTE.warn : PALETTE.info,
-      bold: item.active === true,
+      bold: selected || item.active === true,
     });
     lines.push({ text: `  ${item.description}${tags}${triggers}`, fg: PALETTE.muted });
   }
@@ -136,7 +142,7 @@ function localLibraryLines(
   return lines;
 }
 
-function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
+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 }];
   if (category.id === 'home') {
@@ -220,7 +226,7 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { 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 ...'),
+      ...localLibraryLines('Persona Library', snapshot.localPersonas, 'No local personas yet. Create one here with Create persona.', workspace.selectedLocalLibraryItem('persona')?.id ?? null),
     );
   } else if (category.id === 'skills') {
     base.push(
@@ -228,7 +234,7 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { 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 ...'),
+      ...localLibraryLines('Skill Library', snapshot.localSkills, 'No local skills yet. Create one here with Create skill.', workspace.selectedLocalLibraryItem('skill')?.id ?? null),
     );
   } else if (category.id === 'routines') {
     base.push(
@@ -236,7 +242,7 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { 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 ...'),
+      ...localLibraryLines('Routine Library', snapshot.localRoutines, 'No local routines yet. Create one here with Create routine.', workspace.selectedLocalLibraryItem('routine')?.id ?? null),
     );
   } else if (category.id === 'work') {
     base.push(
@@ -288,7 +294,7 @@ function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCat
     { text: '' },
     ...(workspace.localEditor ? editorContextLines(workspace.localEditor) : []),
     ...(workspace.localEditor ? [{ text: '' }] : []),
-    ...snapshotLines(category, workspace.runtimeSnapshot),
+    ...snapshotLines(workspace, category, workspace.runtimeSnapshot),
   ];
 
   if (action) {

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