@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/input/agent-workspace.ts

@@ -2,6 +2,7 @@ import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { CommandContext } from './command-registry.ts';
+import { AgentNoteRegistry } from '../agent/note-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agent/runtime-profile.ts';
@@ -9,26 +10,19 @@ import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { activateAgentWorkspaceSelection } from './agent-workspace-activation.ts';
 import { AGENT_WORKSPACE_CATEGORIES } from './agent-workspace-categories.ts';
 import { buildAgentWorkspaceCommandEditorSubmission, isAgentWorkspaceCommandEditorKind } from './agent-workspace-command-editor.ts';
-import { quoteSlashCommandArg } from './slash-command-parser.ts';
-import { createDeleteEditor, createMemoryUpdateEditor, createPersonaUpdateEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { createDeleteEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { createAgentWorkspaceLearnedBehavior } from './agent-workspace-learned-behavior.ts';
+import { clampAgentWorkspaceLocalLibrarySelection, moveAgentWorkspaceLocalLibraryItemSelection, selectedAgentWorkspaceLocalLibraryItem, type AgentWorkspaceLocalSelectionIndexes } from './agent-workspace-local-selection.ts';
+import { applyAgentWorkspaceLocalLibraryOperation } from './agent-workspace-local-operations.ts';
 import { deleteAgentWorkspaceMemoryEditor, submitAgentWorkspaceMemoryEditor } from './agent-workspace-memory-editor.ts';
+import { jumpAgentWorkspaceSelection, moveAgentWorkspaceSelection, selectAgentWorkspaceCategory } from './agent-workspace-navigation.ts';
+import { buildAgentWorkspaceRequirements } from './agent-workspace-requirements.ts';
+import { appendAgentWorkspaceActionSearchText, backspaceAgentWorkspaceActionSearch, beginAgentWorkspaceActionSearch, clearAgentWorkspaceActionSearch, commitAgentWorkspaceActionSearchSelection, searchAgentWorkspaceActions } from './agent-workspace-search.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
-import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
+import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceActionSearchResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspacePromptDispatcher, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 
 export type { AgentWorkspaceChannelRisk, AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
-export type {
-  AgentWorkspaceAction,
-  AgentWorkspaceActionResult,
-  AgentWorkspaceCategory,
-  AgentWorkspaceCommandDispatcher,
-  AgentWorkspaceEditorField,
-  AgentWorkspaceFocusPane,
-  AgentWorkspaceLocalEditor,
-  AgentWorkspaceLocalEditorKind,
-  AgentWorkspaceLocalLibraryItem,
-  AgentWorkspaceLocalOperation,
-  AgentWorkspaceRuntimeSnapshot,
-} from './agent-workspace-types.ts';
+export type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceActionSearchResult, AgentWorkspaceCategory, AgentWorkspaceCategoryId, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspacePromptDispatcher, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 export { AGENT_WORKSPACE_MODAL_NAME } from './agent-workspace-types.ts';
 export { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 export { handleAgentWorkspaceToken } from './agent-workspace-token.ts';
@@ -42,8 +36,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> = {
+  public actionSearchActive = false;
+  public actionSearchQuery = '';
+  public readonly selectedLibraryItemIndexes: AgentWorkspaceLocalSelectionIndexes = {
     memory: 0,
+    note: 0,
     persona: 0,
     skill: 0,
     routine: 0,
@@ -51,16 +48,30 @@ export class AgentWorkspace {
   };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
+  private dispatchPrompt: AgentWorkspacePromptDispatcher | null = null;
 
-  open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher): void {
+  open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher, categoryId?: string, dispatchPrompt?: AgentWorkspacePromptDispatcher): void {
     this.context = context;
     this.dispatchCommand = dispatchCommand;
+    this.dispatchPrompt = dispatchPrompt ?? null;
     this.runtimeSnapshot = buildAgentWorkspaceRuntimeSnapshot(context);
     this.active = true;
     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.actionSearchActive = false;
+    this.actionSearchQuery = '';
+    if (categoryId && !this.selectCategory(categoryId)) {
+      const normalized = categoryId.trim();
+      this.status = `Unknown Agent workspace area: ${normalized}`;
+      this.lastActionResult = {
+        kind: 'guidance',
+        title: 'Unknown Agent workspace area',
+        detail: `Use one of ${this.categories.map((category) => category.id).join(', ')}.`,
+        safety: 'safe',
+      };
+    }
     this.clampSelection();
   }
 
@@ -72,6 +83,8 @@ export class AgentWorkspace {
   close(): void {
     this.active = false;
     this.localEditor = null;
+    this.actionSearchActive = false;
+    this.actionSearchQuery = '';
   }
 
   get categories(): readonly AgentWorkspaceCategory[] {
@@ -83,6 +96,7 @@ export class AgentWorkspace {
   }
 
   get actions(): readonly AgentWorkspaceAction[] {
+    if (this.actionSearchActive) return this.actionSearchResults.map((result) => result.action);
     return this.selectedCategory.actions;
   }
 
@@ -90,11 +104,37 @@ export class AgentWorkspace {
     return this.actions[this.selectedActionIndex] ?? null;
   }
 
+  get selectedActionCategory(): AgentWorkspaceCategory {
+    if (this.actionSearchActive) return this.selectedActionSearchResult?.category ?? this.selectedCategory;
+    return this.selectedCategory;
+  }
+
+  get actionSearchResults(): readonly AgentWorkspaceActionSearchResult[] {
+    return this.actionSearchActive ? searchAgentWorkspaceActions(this.categories, this.actionSearchQuery) : [];
+  }
+
+  get selectedActionSearchResult(): AgentWorkspaceActionSearchResult | null {
+    if (!this.actionSearchActive) return null;
+    return this.actionSearchResults[this.selectedActionIndex] ?? null;
+  }
+
+  selectCategory(categoryIdOrLabel: string): boolean {
+    return selectAgentWorkspaceCategory(this, categoryIdOrLabel);
+  }
+
+  cycleCategory(direction: 'next' | 'prev'): void {
+    const total = this.categories.length;
+    if (total === 0) return;
+    const delta = direction === 'next' ? 1 : -1;
+    this.selectedCategoryIndex = (this.selectedCategoryIndex + delta + total) % total;
+    this.selectedActionIndex = 0;
+    this.focusPane = 'actions';
+    this.clampSelection();
+    this.status = `Agent workspace category: ${this.selectedCategory.label}.`;
+  }
+
   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;
+    return selectedAgentWorkspaceLocalLibraryItem(this.runtimeSnapshot, this.selectedLibraryItemIndexes, kind);
   }
 
   focusCategories(): void {
@@ -110,35 +150,19 @@ export class AgentWorkspace {
   }
 
   moveUp(): void {
-    if (this.focusPane === 'categories') {
-      this.selectedCategoryIndex = Math.max(0, this.selectedCategoryIndex - 1);
-      this.selectedActionIndex = 0;
-    } else {
-      this.selectedActionIndex = Math.max(0, this.selectedActionIndex - 1);
-    }
-    this.clampSelection();
+    moveAgentWorkspaceSelection(this, -1);
   }
 
   moveDown(): void {
-    if (this.focusPane === 'categories') {
-      this.selectedCategoryIndex = Math.min(this.categories.length - 1, this.selectedCategoryIndex + 1);
-      this.selectedActionIndex = 0;
-    } else {
-      this.selectedActionIndex = Math.min(this.actions.length - 1, this.selectedActionIndex + 1);
-    }
-    this.clampSelection();
+    moveAgentWorkspaceSelection(this, 1);
   }
 
   jumpHome(): void {
-    if (this.focusPane === 'categories') this.selectedCategoryIndex = 0;
-    else this.selectedActionIndex = 0;
-    this.clampSelection();
+    jumpAgentWorkspaceSelection(this, 'home');
   }
 
   jumpEnd(): void {
-    if (this.focusPane === 'categories') this.selectedCategoryIndex = this.categories.length - 1;
-    else this.selectedActionIndex = this.actions.length - 1;
-    this.clampSelection();
+    jumpAgentWorkspaceSelection(this, 'end');
   }
 
   refreshRuntimeSnapshot(): void {
@@ -168,10 +192,30 @@ export class AgentWorkspace {
     this.lastActionResult = {
       kind: 'guidance',
       title: `${title} cancelled`,
-      detail: 'No local Agent registry changes were written.',
+      detail: 'No Agent-local registry changes were written.',
     };
   }
 
+  beginActionSearch(): void {
+    beginAgentWorkspaceActionSearch(this);
+  }
+
+  appendActionSearchText(text: string): void {
+    appendAgentWorkspaceActionSearchText(this, text);
+  }
+
+  actionSearchBackspace(): void {
+    backspaceAgentWorkspaceActionSearch(this);
+  }
+
+  clearActionSearch(): void {
+    clearAgentWorkspaceActionSearch(this);
+  }
+
+  commitActionSearchSelection(): boolean {
+    return commitAgentWorkspaceActionSearchSelection(this, this.selectedActionSearchResult);
+  }
+
   moveEditorField(delta: number): void {
     const editor = this.localEditor;
     if (!editor) return;
@@ -184,7 +228,7 @@ export class AgentWorkspace {
     if (!editor || text.length === 0) return;
     const field = editor.fields[editor.selectedFieldIndex];
     if (!field) return;
-    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}${text}`, editor.message);
+    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}${field.multiline ? text.replace(/\r\n?/g, '\n') : text.replace(/[\r\n]+/g, ' ')}`, editor.message);
   }
 
   appendEditorNewline(): void {
@@ -226,201 +270,45 @@ export class AgentWorkspace {
     return Boolean(this.context?.executeCommand && this.dispatchCommand);
   }
 
+  hasPromptDispatch(): boolean {
+    return Boolean(this.context?.submitInput && this.dispatchPrompt);
+  }
+
   dispatchWorkspaceCommand(command: string): void {
     this.dispatchCommand?.(command);
   }
 
+  dispatchWorkspacePrompt(prompt: string): void {
+    this.dispatchPrompt?.(prompt);
+  }
+
   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('memory');
-    this.clampLocalLibrarySelection('persona');
-    this.clampLocalLibrarySelection('skill');
-    this.clampLocalLibrarySelection('routine');
-  }
-
-  private localLibraryItems(kind: AgentWorkspaceLocalEditorKind): readonly AgentWorkspaceLocalLibraryItem[] {
-    if (kind === 'memory') return this.runtimeSnapshot?.localMemories ?? [];
-    if (kind === 'persona') return this.runtimeSnapshot?.localPersonas ?? [];
-    if (kind === 'skill') return this.runtimeSnapshot?.localSkills ?? [];
-    if (kind === 'profile') return [];
-    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));
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'memory');
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'note');
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'persona');
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'skill');
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'routine');
   }
 
   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',
-    };
+    moveAgentWorkspaceLocalLibraryItemSelection(this, kind, delta);
   }
 
   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 === 'memory-edit') {
-        const memory = this.memoryApi();
-        const record = memory.get(selected.id);
-        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
-        this.localEditor = createMemoryUpdateEditor(record);
-        this.status = `Editing memory: ${record.id}.`;
-        this.lastActionResult = {
-          kind: 'guidance',
-          title: this.localEditor.title,
-          detail: this.localEditor.message,
-          safety: 'safe',
-        };
-      } else if (operation === 'memory-review') {
-        const record = this.memoryApi().review(selected.id, { state: 'reviewed', confidence: selected.confidence ?? 100, reviewedBy: 'operator' });
-        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
-        this.finishLocalOperation('memory', `Reviewed memory ${record.id}`, `${record.summary} is marked reviewed.`);
-      } else if (operation === 'memory-stale') {
-        const record = this.memoryApi().review(selected.id, { state: 'stale', staleReason: 'Marked stale from Agent workspace', reviewedBy: 'operator' });
-        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
-        this.finishLocalOperation('memory', `Marked memory stale ${record.id}`, `${record.summary} needs review before reuse.`);
-      } else if (operation === 'memory-delete') {
-        this.openDeleteEditor('memory', selected);
-      } else 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 === 'persona-delete') {
-        this.openDeleteEditor('persona', selected);
-      } 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 === 'skill-delete') {
-        this.openDeleteEditor('skill', selected);
-      } 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') {
-        if (this.hasCommandDispatch()) {
-          const command = `/routines start ${quoteSlashCommandArg(selected.id)}`;
-          this.dispatchWorkspaceCommand(command);
-          this.status = `Opening routine: ${selected.name}.`;
-          this.lastActionResult = {
-            kind: 'dispatched',
-            title: `Opening routine ${selected.name}`,
-            detail: `${selected.name} will print its workflow steps in the main conversation. No hidden job was created.`,
-            command,
-            safety: 'safe',
-          };
-          return;
-        }
-        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 if (operation === 'routine-review') {
-        AgentRoutineRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
-        this.finishLocalOperation('routine', `Reviewed routine ${selected.name}`, `${selected.name} is marked reviewed.`);
-      } else {
-        this.openDeleteEditor('routine', selected);
-      }
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      this.status = detail;
-      this.lastActionResult = {
-        kind: 'error',
-        title: 'Local registry action failed',
-        detail,
-      };
-    }
+    applyAgentWorkspaceLocalLibraryOperation(this, operation, {
+      shellPaths: () => this.context?.workspace?.shellPaths,
+      selectedItemForOperation: (selectedOperation) => this.selectedItemForOperation(selectedOperation),
+      memoryApi: () => this.memoryApi(),
+      finishLocalOperation: (kind, title, detail) => this.finishLocalOperation(kind, title, detail),
+      openDeleteEditor: (kind, selected) => this.openDeleteEditor(kind, selected),
+    });
   }
 
   private selectedItemForOperation(operation: AgentWorkspaceLocalOperation): AgentWorkspaceLocalLibraryItem | null {
     if (operation.startsWith('memory-')) return this.selectedLocalLibraryItem('memory');
+    if (operation.startsWith('note-')) return this.selectedLocalLibraryItem('note');
     if (operation.startsWith('persona-')) return this.selectedLocalLibraryItem('persona');
     if (operation.startsWith('skill-')) return this.selectedLocalLibraryItem('skill');
     return this.selectedLocalLibraryItem('routine');
@@ -428,13 +316,19 @@ export class AgentWorkspace {
 
   private memoryApi(): MemoryApi {
     const memory = this.context?.clients?.agentKnowledgeApi?.memory;
-    if (!memory) throw new Error('Agent Memory API is unavailable; refusing default Knowledge/Wiki or non-Agent fallback.');
+    if (!memory) throw new Error('Agent Memory API is unavailable; refusing default knowledge or non-Agent fallback.');
     return memory;
   }
 
+  private learnedBehaviorTarget(): Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'note' | 'profile'> {
+    const target = this.editorField('target').trim().toLowerCase();
+    if (target === 'persona' || target === 'skill' || target === 'routine') return target;
+    throw new Error('Behavior type must be skill, routine, or persona.');
+  }
+
   private finishLocalOperation(kind: AgentWorkspaceLocalEditorKind, title: string, detail: string): void {
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
-    this.clampLocalLibrarySelection(kind);
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, kind);
     this.status = title;
     this.lastActionResult = {
       kind: 'refreshed',
@@ -515,7 +409,7 @@ export class AgentWorkspace {
     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.status = 'Cannot save Agent-local registry item without shell paths.';
       this.lastActionResult = {
         kind: 'error',
         title: 'Local registry unavailable',
@@ -528,13 +422,46 @@ export class AgentWorkspace {
         this.submitLocalDeleteEditor(shellPaths, editor);
         return;
       }
-      if (editor.kind === 'profile') {
+      if (editor.kind === 'learned-behavior') {
+        const created = createAgentWorkspaceLearnedBehavior(shellPaths, {
+          target: this.learnedBehaviorTarget(),
+          name: this.editorField('name'),
+          description: this.editorField('description'),
+          notes: this.editorField('notes'),
+          tags: splitList(this.editorField('tags')),
+          triggers: splitList(this.editorField('triggers')),
+          enable: isAffirmative(this.editorField('enable')),
+        });
+        this.finishLocalEditor(created.kind, created.id, created.name, 'Created');
+      } else if (editor.kind === 'profile') {
         const template = this.editorField('template');
         const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
         const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, this.editorField('name'), {
           ...(templateId ? { templateId } : {}),
         });
         this.finishProfileEditor(profile);
+      } else if (editor.kind === 'note') {
+        const registry = AgentNoteRegistry.fromShellPaths(shellPaths);
+        if (editor.mode === 'update' && editor.recordId) {
+          const updated = registry.update(editor.recordId, {
+            title: this.editorField('title'),
+            body: this.editorField('body'),
+            sourceUrl: this.editorField('sourceUrl'),
+            tags: splitList(this.editorField('tags')),
+            provenance: 'Workspace',
+          });
+          this.finishLocalEditor(editor.kind, updated.id, updated.title, 'Updated');
+          return;
+        }
+        const created = registry.create({
+          title: this.editorField('title'),
+          body: this.editorField('body'),
+          sourceUrl: this.editorField('sourceUrl'),
+          tags: splitList(this.editorField('tags')),
+          source: 'user',
+          provenance: 'Workspace',
+        });
+        this.finishLocalEditor(editor.kind, created.id, created.title, 'Created');
       } else if (editor.kind === 'persona') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
         if (editor.mode === 'update' && editor.recordId) {
@@ -545,7 +472,7 @@ export class AgentWorkspace {
             body: this.editorField('body'),
             tags: splitList(this.editorField('tags')),
             triggers: splitList(this.editorField('triggers')),
-            provenance: 'agent-workspace',
+            provenance: 'Workspace',
           });
           if (isAffirmative(this.editorField('activate'))) registry.setActive(updated.id);
           else if (wasActive) registry.clearActive();
@@ -559,7 +486,7 @@ export class AgentWorkspace {
           tags: splitList(this.editorField('tags')),
           triggers: splitList(this.editorField('triggers')),
           source: 'user',
-          provenance: 'agent-workspace',
+          provenance: 'Workspace',
         });
         if (isAffirmative(this.editorField('activate'))) registry.setActive(created.id);
         this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
@@ -572,7 +499,8 @@ export class AgentWorkspace {
             procedure: this.editorField('procedure'),
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
-            provenance: 'agent-workspace',
+            requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
+            provenance: 'Workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
           this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
@@ -584,9 +512,10 @@ export class AgentWorkspace {
           procedure: this.editorField('procedure'),
           triggers: splitList(this.editorField('triggers')),
           tags: splitList(this.editorField('tags')),
+          requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
           enabled: isAffirmative(this.editorField('enabled')),
           source: 'user',
-          provenance: 'agent-workspace',
+          provenance: 'Workspace',
         });
         this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       } else {
@@ -598,7 +527,8 @@ export class AgentWorkspace {
             steps: this.editorField('steps'),
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
-            provenance: 'agent-workspace',
+            requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
+            provenance: 'Workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
           this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
@@ -610,9 +540,10 @@ export class AgentWorkspace {
           steps: this.editorField('steps'),
           triggers: splitList(this.editorField('triggers')),
           tags: splitList(this.editorField('tags')),
+          requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
           enabled: isAffirmative(this.editorField('enabled')),
           source: 'user',
-          provenance: 'agent-workspace',
+          provenance: 'Workspace',
         });
         this.finishLocalEditor(editor.kind, created.id, created.name, 'Created');
       }
@@ -629,7 +560,7 @@ export class AgentWorkspace {
   }
 
   private submitCommandEditor(editor: AgentWorkspaceLocalEditor): void {
-    const result = buildAgentWorkspaceCommandEditorSubmission(editor, (fieldId) => this.editorField(fieldId), this.hasCommandDispatch());
+    const result = buildAgentWorkspaceCommandEditorSubmission(editor, (fieldId) => this.editorField(fieldId), this.hasCommandDispatch(), this.hasPromptDispatch());
     if (result.kind === 'editor') {
       this.localEditor = result.editor;
       this.status = result.status;
@@ -640,6 +571,10 @@ export class AgentWorkspace {
     this.localEditor = null;
     this.status = result.status;
     this.lastActionResult = result.actionResult;
+    if (result.kind === 'prompt') {
+      this.dispatchWorkspacePrompt(result.prompt);
+      return;
+    }
     this.dispatchWorkspaceCommand(result.command);
   }
 
@@ -656,11 +591,14 @@ export class AgentWorkspace {
     }
     if (editor.kind === 'memory') {
       const removed = this.memoryApi().delete(expectedId);
-      if (!removed) throw new Error(`Unknown Agent memory: ${expectedId}`);
+      if (!removed) throw new Error(`Unknown Agent memory ${expectedId}`);
       this.finishLocalDelete(editor.kind, expectedId, expectedId);
     } else if (editor.kind === 'persona') {
       const removed = AgentPersonaRegistry.fromShellPaths(shellPaths).deletePersona(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    } else if (editor.kind === 'note') {
+      const removed = AgentNoteRegistry.fromShellPaths(shellPaths).deleteNote(expectedId);
+      this.finishLocalDelete(editor.kind, removed.id, removed.title);
     } else if (editor.kind === 'skill') {
       const removed = AgentSkillRegistry.fromShellPaths(shellPaths).deleteSkill(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
@@ -668,7 +606,7 @@ export class AgentWorkspace {
       const removed = AgentRoutineRegistry.fromShellPaths(shellPaths).deleteRoutine(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
     } else {
-      throw new Error(`Unsupported delete editor kind: ${editor.kind}`);
+      throw new Error(`Unsupported delete editor kind ${editor.kind}`);
     }
   }
 
@@ -712,7 +650,7 @@ export class AgentWorkspace {
       this.selectedCategoryIndex = categoryIndex;
       this.selectedActionIndex = 0;
     }
-    this.status = `${verb} memory: ${record.summary}.`;
+    this.status = `${verb} memory ${record.summary}.`;
     this.lastActionResult = {
       kind: 'refreshed',
       title: `${verb} memory`,
@@ -731,7 +669,7 @@ export class AgentWorkspace {
       this.selectedActionIndex = 0;
     }
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
-    this.status = `${verb} ${kind}: ${name}.`;
+    this.status = `${verb} ${kind} ${name}.`;
     this.lastActionResult = {
       kind: 'refreshed',
       title: `${verb} ${kind}`,
@@ -751,11 +689,11 @@ export class AgentWorkspace {
     }
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
     const starter = profile.starterTemplateId ? ` from ${profile.starterTemplateId}` : '';
-    this.status = `Created Agent profile: ${profile.id}.`;
+    this.status = `Created Agent profile ${profile.id}.`;
     this.lastActionResult = {
       kind: 'refreshed',
       title: 'Created Agent profile',
-      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current TUI session was not switched.`,
+      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current Agent session was not switched.`,
       safety: 'safe',
     };
     this.clampSelection();
@@ -770,7 +708,7 @@ export class AgentWorkspace {
       this.selectedActionIndex = 0;
     }
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
-    this.status = `Deleted ${kind}: ${name}.`;
+    this.status = `Deleted ${kind} ${name}.`;
     this.lastActionResult = {
       kind: 'refreshed',
       title: `Deleted ${kind}`,