@pellux/goodvibes-agent 0.1.117 → 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,17 +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';
@@ -33,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,
@@ -42,23 +48,27 @@ export class AgentWorkspace {
   };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
+  private dispatchPrompt: AgentWorkspacePromptDispatcher | null = null;
 
-  open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher, categoryId?: string): 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.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(', ')}.`,
+        detail: `Use one of ${this.categories.map((category) => category.id).join(', ')}.`,
         safety: 'safe',
       };
     }
@@ -73,6 +83,8 @@ export class AgentWorkspace {
   close(): void {
     this.active = false;
     this.localEditor = null;
+    this.actionSearchActive = false;
+    this.actionSearchQuery = '';
   }
 
   get categories(): readonly AgentWorkspaceCategory[] {
@@ -84,6 +96,7 @@ export class AgentWorkspace {
   }
 
   get actions(): readonly AgentWorkspaceAction[] {
+    if (this.actionSearchActive) return this.actionSearchResults.map((result) => result.action);
     return this.selectedCategory.actions;
   }
 
@@ -91,15 +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 {
@@ -157,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;
@@ -215,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');
@@ -417,11 +316,11 @@ 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' | 'profile'> {
+  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.');
@@ -429,7 +328,7 @@ export class AgentWorkspace {
 
   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',
@@ -510,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',
@@ -541,6 +440,28 @@ export class AgentWorkspace {
           ...(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) {
@@ -551,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();
@@ -565,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');
@@ -579,7 +500,7 @@ export class AgentWorkspace {
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
             requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
-            provenance: 'agent-workspace',
+            provenance: 'Workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
           this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
@@ -594,7 +515,7 @@ export class AgentWorkspace {
           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 {
@@ -607,7 +528,7 @@ export class AgentWorkspace {
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
             requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
-            provenance: 'agent-workspace',
+            provenance: 'Workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
           this.finishLocalEditor(editor.kind, updated.id, updated.name, 'Updated');
@@ -622,7 +543,7 @@ export class AgentWorkspace {
           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');
       }
@@ -639,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;
@@ -650,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);
   }
 
@@ -666,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);
@@ -678,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}`);
     }
   }
 
@@ -722,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`,
@@ -741,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}`,
@@ -761,7 +689,7 @@ 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',
@@ -780,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}`,

package/src/input/command-registry.ts

@@ -21,6 +21,8 @@ import type { PeerClient } from '@/runtime/index.ts';
 import type { DirectTransport } from '@/runtime/index.ts';
 import type { VoiceProviderRegistry, VoiceService } from '@pellux/goodvibes-sdk/platform/voice';
 import type { MediaProviderRegistry } from '@pellux/goodvibes-sdk/platform/media';
+import type { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
+import type { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
 import type {
   CommandWorkspaceShellServices,
 } from '@/runtime/index.ts';
@@ -108,7 +110,6 @@ export interface CommandShellUiOpeners {
   showPanel?: (panelId: string, pane?: 'top' | 'bottom') => void;
   focusPanels?: () => void;
   focusPrompt?: () => void;
-  openPolicyPanel?: () => void;
   openMcpWorkspace?: () => void;
   openAgentWorkspace?: (categoryId?: string) => void;
   openSecurityPanel?: () => void;
@@ -157,6 +158,8 @@ export interface CommandPlatformConfigServices {
   readonly voiceProviderRegistry?: VoiceProviderRegistry;
   readonly voiceService?: VoiceService;
   readonly mediaProviderRegistry?: MediaProviderRegistry;
+  readonly artifactStore?: Pick<ArtifactStore, 'create'>;
+  readonly channelDeliveryRouter?: Pick<ChannelDeliveryRouter, 'deliver' | 'listStrategies'>;
 }
 
 export interface CommandPlatformServices