@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/input/agent-workspace-local-operations.ts

@@ -0,0 +1,218 @@
+import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { AgentNoteRegistry } from '../agent/note-registry.ts';
+import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import {
+  createKnowledgeUrlEditorFromNote,
+  createMemoryEditorFromNote,
+  createMemoryUpdateEditor,
+  createNoteUpdateEditor,
+  createPersonaEditorFromNote,
+  createPersonaUpdateEditor,
+  createRoutineEditorFromNote,
+  createRoutineUpdateEditor,
+  createSkillEditorFromNote,
+  createSkillUpdateEditor,
+} from './agent-workspace-editors.ts';
+import type {
+  AgentWorkspaceActionResult,
+  AgentWorkspaceLocalEditor,
+  AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceLocalOperation,
+} from './agent-workspace-types.ts';
+
+interface AgentWorkspaceLocalOperationHost {
+  status: string;
+  lastActionResult: AgentWorkspaceActionResult | null;
+  localEditor: AgentWorkspaceLocalEditor | null;
+  hasCommandDispatch(): boolean;
+  dispatchWorkspaceCommand(command: string): void;
+}
+
+interface AgentWorkspaceLocalOperationCallbacks {
+  readonly shellPaths: () => ShellPathService | undefined;
+  readonly selectedItemForOperation: (operation: AgentWorkspaceLocalOperation) => AgentWorkspaceLocalLibraryItem | null;
+  readonly memoryApi: () => MemoryApi;
+  readonly finishLocalOperation: (kind: AgentWorkspaceLocalEditorKind, title: string, detail: string) => void;
+  readonly openDeleteEditor: (kind: AgentWorkspaceLocalEditorKind, selected: AgentWorkspaceLocalLibraryItem) => void;
+}
+
+function setGuidanceEditor(host: AgentWorkspaceLocalOperationHost, editor: AgentWorkspaceLocalEditor, status: string): void {
+  host.localEditor = editor;
+  host.status = status;
+  host.lastActionResult = {
+    kind: 'guidance',
+    title: editor.title,
+    detail: editor.message,
+    safety: 'safe',
+  };
+}
+
+export function applyAgentWorkspaceLocalLibraryOperation(
+  host: AgentWorkspaceLocalOperationHost,
+  operation: AgentWorkspaceLocalOperation,
+  callbacks: AgentWorkspaceLocalOperationCallbacks,
+): void {
+  const shellPaths = callbacks.shellPaths();
+  if (!shellPaths) {
+    host.status = 'Agent-local registry files are unavailable.';
+    host.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();
+      callbacks.finishLocalOperation('persona', 'Cleared active persona', 'The default Agent policy will apply to later turns.');
+      return;
+    }
+    const selected = callbacks.selectedItemForOperation(operation);
+    if (!selected) {
+      host.status = 'No selected local registry item.';
+      host.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 = callbacks.memoryApi();
+      const record = memory.get(selected.id);
+      if (!record) throw new Error(`Unknown Agent memory ${selected.id}`);
+      setGuidanceEditor(host, createMemoryUpdateEditor(record), `Editing memory ${record.id}.`);
+    } else if (operation === 'memory-review') {
+      const record = callbacks.memoryApi().review(selected.id, { state: 'reviewed', confidence: selected.confidence ?? 100, reviewedBy: 'operator' });
+      if (!record) throw new Error(`Unknown Agent memory ${selected.id}`);
+      callbacks.finishLocalOperation('memory', `Reviewed memory ${record.id}`, `${record.summary} is marked reviewed.`);
+    } else if (operation === 'memory-stale') {
+      const record = callbacks.memoryApi().review(selected.id, { state: 'stale', staleReason: 'Marked stale from Agent workspace', reviewedBy: 'operator' });
+      if (!record) throw new Error(`Unknown Agent memory ${selected.id}`);
+      callbacks.finishLocalOperation('memory', `Marked memory stale ${record.id}`, `${record.summary} needs review before reuse.`);
+    } else if (operation === 'memory-delete') {
+      callbacks.openDeleteEditor('memory', selected);
+    } else if (operation === 'note-edit') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      setGuidanceEditor(host, createNoteUpdateEditor(note), `Editing note ${note.title}.`);
+    } else if (operation === 'note-review') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
+      callbacks.finishLocalOperation('note', `Reviewed note ${note.title}`, `${note.title} is marked reviewed in the local scratchpad.`);
+    } else if (operation === 'note-stale') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).markStale(selected.id, 'Marked stale from Agent workspace');
+      callbacks.finishLocalOperation('note', `Marked note stale ${note.title}`, `${note.title} needs review before reuse.`);
+    } else if (operation === 'note-delete') {
+      callbacks.openDeleteEditor('note', selected);
+    } else if (operation === 'note-promote-memory') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      setGuidanceEditor(host, createMemoryEditorFromNote(note), `Creating memory from note ${note.title}.`);
+    } else if (operation === 'note-promote-persona') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      setGuidanceEditor(host, createPersonaEditorFromNote(note), `Creating persona from note ${note.title}.`);
+    } else if (operation === 'note-promote-skill') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      setGuidanceEditor(host, createSkillEditorFromNote(note), `Creating skill from note ${note.title}.`);
+    } else if (operation === 'note-promote-routine') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      setGuidanceEditor(host, createRoutineEditorFromNote(note), `Creating routine from note ${note.title}.`);
+    } else if (operation === 'note-promote-knowledge-url') {
+      const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(selected.id);
+      if (!note) throw new Error(`Unknown note ${selected.id}`);
+      const sourceUrl = note.sourceUrl?.trim();
+      if (!sourceUrl) {
+        host.status = 'Selected note has no reviewed source URL.';
+        host.lastActionResult = {
+          kind: 'guidance',
+          title: 'No note source URL',
+          detail: 'Edit the selected note and add a reviewed HTTP(S) source URL before ingesting it into Agent Knowledge.',
+          safety: 'safe',
+        };
+        return;
+      }
+      const parsed = new URL(sourceUrl);
+      if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('Selected note source URL must be HTTP or HTTPS before Agent Knowledge ingest.');
+      }
+      setGuidanceEditor(host, createKnowledgeUrlEditorFromNote(note), `Preparing Agent Knowledge ingest from note ${note.title}.`);
+    } 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}`);
+      setGuidanceEditor(host, createPersonaUpdateEditor(persona, registry.snapshot().activePersonaId === persona.id), `Editing persona ${persona.name}.`);
+    } else if (operation === 'persona-use') {
+      AgentPersonaRegistry.fromShellPaths(shellPaths).setActive(selected.id);
+      callbacks.finishLocalOperation('persona', `Using persona ${selected.name}`, `${selected.name} will shape later main-conversation turns.`);
+    } else if (operation === 'persona-review') {
+      AgentPersonaRegistry.fromShellPaths(shellPaths).markReviewed(selected.id);
+      callbacks.finishLocalOperation('persona', `Reviewed persona ${selected.name}`, `${selected.name} is marked reviewed.`);
+    } else if (operation === 'persona-delete') {
+      callbacks.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}`);
+      setGuidanceEditor(host, createSkillUpdateEditor(skill), `Editing skill ${skill.name}.`);
+    } else if (operation === 'skill-enable') {
+      AgentSkillRegistry.fromShellPaths(shellPaths).setEnabled(selected.id, true);
+      callbacks.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);
+      callbacks.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);
+      callbacks.finishLocalOperation('skill', `Reviewed skill ${selected.name}`, `${selected.name} is marked reviewed.`);
+    } else if (operation === 'skill-delete') {
+      callbacks.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}`);
+      setGuidanceEditor(host, createRoutineUpdateEditor(routine), `Editing routine ${routine.name}.`);
+    } else if (operation === 'routine-start') {
+      if (host.hasCommandDispatch()) {
+        const command = `/routines start ${quoteSlashCommandArg(selected.id)}`;
+        host.dispatchWorkspaceCommand(command);
+        host.status = `Opening routine ${selected.name}.`;
+        host.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);
+      callbacks.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);
+      callbacks.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);
+      callbacks.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);
+      callbacks.finishLocalOperation('routine', `Reviewed routine ${selected.name}`, `${selected.name} is marked reviewed.`);
+    } else {
+      callbacks.openDeleteEditor('routine', selected);
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    host.status = detail;
+    host.lastActionResult = {
+      kind: 'error',
+      title: 'Local registry action failed',
+      detail,
+    };
+  }
+}

package/src/input/agent-workspace-local-selection.ts

@@ -0,0 +1,75 @@
+import type {
+  AgentWorkspaceActionResult,
+  AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRuntimeSnapshot,
+} from './agent-workspace-types.ts';
+
+export type AgentWorkspaceLocalSelectionIndexes = Record<AgentWorkspaceLocalEditorKind, number>;
+
+export interface AgentWorkspaceLocalSelectionHost {
+  readonly runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null;
+  readonly selectedLibraryItemIndexes: AgentWorkspaceLocalSelectionIndexes;
+  status: string;
+  lastActionResult: AgentWorkspaceActionResult | null;
+  selectedLocalLibraryItem(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalLibraryItem | null;
+}
+
+export function agentWorkspaceLocalLibraryItems(
+  snapshot: AgentWorkspaceRuntimeSnapshot | null,
+  kind: AgentWorkspaceLocalEditorKind,
+): readonly AgentWorkspaceLocalLibraryItem[] {
+  if (kind === 'memory') return snapshot?.localMemories ?? [];
+  if (kind === 'note') return snapshot?.localNotes ?? [];
+  if (kind === 'persona') return snapshot?.localPersonas ?? [];
+  if (kind === 'skill') return snapshot?.localSkills ?? [];
+  if (kind === 'profile') return [];
+  return snapshot?.localRoutines ?? [];
+}
+
+export function selectedAgentWorkspaceLocalLibraryItem(
+  snapshot: AgentWorkspaceRuntimeSnapshot | null,
+  indexes: AgentWorkspaceLocalSelectionIndexes,
+  kind: AgentWorkspaceLocalEditorKind,
+): AgentWorkspaceLocalLibraryItem | null {
+  const items = agentWorkspaceLocalLibraryItems(snapshot, kind);
+  if (items.length === 0) return null;
+  const index = Math.max(0, Math.min(indexes[kind], items.length - 1));
+  return items[index] ?? null;
+}
+
+export function clampAgentWorkspaceLocalLibrarySelection(
+  snapshot: AgentWorkspaceRuntimeSnapshot | null,
+  indexes: AgentWorkspaceLocalSelectionIndexes,
+  kind: AgentWorkspaceLocalEditorKind,
+): void {
+  const length = agentWorkspaceLocalLibraryItems(snapshot, kind).length;
+  indexes[kind] = length === 0 ? 0 : Math.max(0, Math.min(indexes[kind], length - 1));
+}
+
+export function moveAgentWorkspaceLocalLibraryItemSelection(
+  host: AgentWorkspaceLocalSelectionHost,
+  kind: AgentWorkspaceLocalEditorKind,
+  delta: number,
+): void {
+  const items = agentWorkspaceLocalLibraryItems(host.runtimeSnapshot, kind);
+  if (items.length === 0) {
+    host.status = `No local ${kind} records to select.`;
+    host.lastActionResult = {
+      kind: 'guidance',
+      title: `No ${kind} records`,
+      detail: `Create a local ${kind} before using selection actions.`,
+      safety: 'safe',
+    };
+    return;
+  }
+  host.selectedLibraryItemIndexes[kind] = Math.max(0, Math.min(items.length - 1, host.selectedLibraryItemIndexes[kind] + delta));
+  const selected = host.selectedLocalLibraryItem(kind);
+  host.status = selected ? `Selected ${kind}: ${selected.name}.` : `Selected ${kind} updated.`;
+  host.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',
+  };
+}

package/src/input/agent-workspace-media-command-editor-submission.ts

@@ -0,0 +1,62 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceMediaCommandEditorKind } from './agent-workspace-media-command-editors.ts';
+import { isAgentWorkspaceMediaCommandEditorKind } from './agent-workspace-media-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceMediaCommandEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+export function isAgentWorkspaceMediaCommandSubmissionKind(kind: string): kind is AgentWorkspaceMediaCommandEditorKind {
+  return isAgentWorkspaceMediaCommandEditorKind(kind as AgentWorkspaceMediaCommandEditorKind);
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+export function buildAgentWorkspaceMediaCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceMediaCommandEditorSubmission {
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Media generation not confirmed. Type yes, then press Enter.' },
+      status: 'Agent media generation not confirmed.',
+    };
+  }
+  const parts = ['/media', 'generate'];
+  const provider = readField('provider');
+  const model = readField('model');
+  const mime = readField('mime');
+  if (provider) parts.push('--provider', quoteSlashCommandArg(provider));
+  if (model) parts.push('--model', quoteSlashCommandArg(model));
+  if (mime) parts.push('--mime', quoteSlashCommandArg(mime));
+  parts.push(quoteSlashCommandArg(readField('prompt')), '--yes');
+  const command = parts.join(' ');
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Opening media generation.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Opening media generation',
+      detail: 'The workspace handed confirmed media generation to the shell-owned command router.',
+      command,
+      safety: 'safe',
+    },
+  };
+}

package/src/input/agent-workspace-media-command-editors.ts

@@ -0,0 +1,27 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceMediaCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  'media-generate'
+>;
+
+export function isAgentWorkspaceMediaCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMediaCommandEditorKind {
+  return kind === 'media-generate';
+}
+
+export function createAgentWorkspaceMediaCommandEditor(kind: AgentWorkspaceMediaCommandEditorKind): AgentWorkspaceLocalEditor {
+  return {
+    kind,
+    mode: 'create',
+    title: 'Generate Media',
+    selectedFieldIndex: 0,
+    message: 'Generate image or video artifacts through a configured media provider. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'prompt', label: 'Prompt', value: '', required: true, multiline: true, hint: 'Describe the media to generate. Ctrl-J inserts a new line.' },
+      { id: 'provider', label: 'Provider', value: '', required: false, multiline: false, hint: 'Optional media provider id, such as fal, comfy, runway, alibaba, or byteplus.' },
+      { id: 'model', label: 'Model', value: '', required: false, multiline: false, hint: 'Optional provider-specific media model id.' },
+      { id: 'mime', label: 'Output MIME', value: '', required: false, multiline: false, hint: 'Optional output type, such as image/png or video/mp4.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /media generate with --yes.' },
+    ],
+  };
+}

package/src/input/agent-workspace-memory-command-editors.ts

@@ -36,7 +36,7 @@ export function createAgentWorkspaceMemoryCommandEditor(kind: AgentWorkspaceMemo
       mode: 'create',
       title: 'Search Agent Memory',
       selectedFieldIndex: 0,
-      message: 'Search Agent-local memory only. This does not query default Knowledge/Wiki or other product routes.',
+      message: 'Search Agent-local memory only. This does not query default knowledge or other product routes.',
       fields: [
         { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional text query. Blank searches by filters.' },
         { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional session, project, or team.' },

package/src/input/agent-workspace-memory-editor.ts

@@ -34,7 +34,7 @@ export async function submitAgentWorkspaceMemoryEditor(
       detail: detail.length > 0 ? detail : undefined,
       tags,
     });
-    if (!updated) throw new Error(`Unknown Agent memory: ${editor.recordId}`);
+    if (!updated) throw new Error(`Unknown Agent memory ${editor.recordId}`);
     return { record: updated, verb: 'Updated' };
   }
 
@@ -67,7 +67,7 @@ export function deleteAgentWorkspaceMemoryEditor(
   const expectedId = editor.recordId ?? '';
   if (!expectedId || confirmedId !== expectedId) return null;
   const removed = memory.delete(expectedId);
-  if (!removed) throw new Error(`Unknown Agent memory: ${expectedId}`);
+  if (!removed) throw new Error(`Unknown Agent memory ${expectedId}`);
   return { id: expectedId, name: expectedId };
 }
 

package/src/input/agent-workspace-navigation.ts

@@ -1,4 +1,4 @@
-import type { AgentWorkspaceAction, AgentWorkspaceCategory, AgentWorkspaceFocusPane } from './agent-workspace-types.ts';
+import type { AgentWorkspaceAction, AgentWorkspaceCategory, AgentWorkspaceCategoryId, AgentWorkspaceFocusPane } from './agent-workspace-types.ts';
 
 interface AgentWorkspaceNavigationHost {
   readonly categories: readonly AgentWorkspaceCategory[];
@@ -9,6 +9,42 @@ interface AgentWorkspaceNavigationHost {
   clampSelection(): void;
 }
 
+const AGENT_WORKSPACE_CATEGORY_ALIASES = {
+  connected: 'host',
+  'connected-host': 'host',
+  host: 'host',
+  mcp: 'tools',
+  tool: 'tools',
+  channel: 'channels',
+  voice: 'voice-media',
+  media: 'voice-media',
+  profile: 'profiles',
+  persona: 'personas',
+  skill: 'skills',
+  routine: 'routines',
+  schedule: 'automation',
+  schedules: 'automation',
+  plan: 'work',
+  planning: 'work',
+  task: 'host',
+  tasks: 'host',
+  note: 'notes',
+  scratchpad: 'notes',
+  kb: 'knowledge',
+} as const satisfies Readonly<Record<string, AgentWorkspaceCategoryId>>;
+
+type AgentWorkspaceCategoryAlias = keyof typeof AGENT_WORKSPACE_CATEGORY_ALIASES;
+
+function isAgentWorkspaceCategoryAlias(categoryIdOrLabel: string): categoryIdOrLabel is AgentWorkspaceCategoryAlias {
+  return Object.prototype.hasOwnProperty.call(AGENT_WORKSPACE_CATEGORY_ALIASES, categoryIdOrLabel);
+}
+
+function normalizeAgentWorkspaceCategoryRequest(categoryIdOrLabel: string): string {
+  const normalized = categoryIdOrLabel.trim().toLowerCase();
+  if (!normalized) return '';
+  return isAgentWorkspaceCategoryAlias(normalized) ? AGENT_WORKSPACE_CATEGORY_ALIASES[normalized] : normalized;
+}
+
 export function moveAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost, delta: -1 | 1): void {
   if (host.focusPane === 'categories') {
     host.selectedCategoryIndex = Math.max(0, Math.min(host.categories.length - 1, host.selectedCategoryIndex + delta));
@@ -29,7 +65,7 @@ export function jumpAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost,
 }
 
 export function selectAgentWorkspaceCategory(host: AgentWorkspaceNavigationHost, categoryIdOrLabel: string): boolean {
-  const normalized = categoryIdOrLabel.trim().toLowerCase();
+  const normalized = normalizeAgentWorkspaceCategoryRequest(categoryIdOrLabel);
   if (!normalized) return false;
   const categoryIndex = host.categories.findIndex((category) =>
     category.id.toLowerCase() === normalized

package/src/input/agent-workspace-notify-editor-submission.ts

@@ -3,7 +3,7 @@ import { quoteSlashCommandArg } from './slash-command-parser.ts';
 
 type AgentWorkspaceFieldReader = (fieldId: string) => string;
 
-export type AgentWorkspaceNotifyEditorKind = 'notify-webhook' | 'notify-webhook-remove' | 'notify-webhook-clear' | 'notify-webhook-test';
+export type AgentWorkspaceNotifyEditorKind = 'notify-webhook' | 'notify-webhook-remove' | 'notify-webhook-clear' | 'notify-webhook-test' | 'notify-send';
 
 export type AgentWorkspaceNotifyEditorSubmission =
   | {
@@ -23,7 +23,8 @@ export function isAgentWorkspaceNotifyEditorKind(kind: string): kind is AgentWor
   return kind === 'notify-webhook'
     || kind === 'notify-webhook-remove'
     || kind === 'notify-webhook-clear'
-    || kind === 'notify-webhook-test';
+    || kind === 'notify-webhook-test'
+    || kind === 'notify-send';
 }
 
 function isAffirmative(value: string): boolean {
@@ -95,6 +96,19 @@ export function buildAgentWorkspaceNotifyEditorSubmission(
     );
   }
 
+  if (editor.kind === 'notify-send') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification send not confirmed. Type yes, then press Enter.', 'Notification send not confirmed.');
+    }
+    const command = `/notify send ${quoteSlashCommandArg(readField('message'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification send',
+      'Opening notification send.',
+      'The workspace handed a confirmed notification send command to the shell-owned command router.',
+    );
+  }
+
   if (!isAffirmative(readField('confirm'))) {
     return unconfirmed(editor, 'Notification webhook test not confirmed. Type yes, then press Enter.', 'Notification webhook test not confirmed.');
   }

package/src/input/agent-workspace-operations-command-editor-submission.ts

@@ -9,6 +9,17 @@ function isAffirmative(value: string): boolean {
   return /^(y|yes|true)$/i.test(value.trim());
 }
 
+function optionalNoteArgs(value: string): string {
+  const trimmed = value.trim();
+  return trimmed ? ` --note ${quoteSlashCommandArg(trimmed)}` : '';
+}
+
+function optionalRememberArgs(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+  return isAffirmative(trimmed) ? ' --remember' : ' --no-remember';
+}
+
 function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceOperationsCommandEditorSubmission {
   return {
     kind: 'editor',
@@ -48,7 +59,7 @@ export function buildAgentWorkspaceOperationsCommandEditorSubmission(
       actionResult: {
         kind: 'dispatched',
         title: 'Opening planning goal seeding',
-        detail: 'The workspace handed a concrete planning goal to the shell-owned command router without spawning coding agents.',
+        detail: 'The workspace handed a concrete planning goal to the shell-owned command router without creating coding-role Agent jobs.',
         command,
         safety: 'safe',
       },
@@ -100,6 +111,57 @@ export function buildAgentWorkspaceOperationsCommandEditorSubmission(
       },
     };
   }
+  if (editor.kind === 'approval-approve' || editor.kind === 'approval-deny' || editor.kind === 'approval-cancel') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Approval action not confirmed. Type yes, then press Enter.');
+    const verb = editor.kind.replace('approval-', '');
+    const command = `/approval ${verb} ${quoteSlashCommandArg(readField('approvalId'))}${optionalNoteArgs(readField('note'))}${optionalRememberArgs(readField('remember'))} --yes`;
+    const title = `${verb[0]?.toUpperCase() ?? ''}${verb.slice(1)} approval`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: `${title}.`,
+      actionResult: {
+        kind: 'dispatched',
+        title,
+        detail: 'The workspace handed an explicit confirmed approval action to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (
+    editor.kind === 'automation-job-run'
+    || editor.kind === 'automation-job-pause'
+    || editor.kind === 'automation-job-resume'
+    || editor.kind === 'automation-run-cancel'
+    || editor.kind === 'automation-run-retry'
+    || editor.kind === 'schedule-run'
+  ) {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Automation action not confirmed. Type yes, then press Enter.');
+    const command = editor.kind === 'automation-job-run'
+      ? `/automation job run ${quoteSlashCommandArg(readField('jobId'))} --yes`
+      : editor.kind === 'automation-job-pause'
+        ? `/automation job pause ${quoteSlashCommandArg(readField('jobId'))} --yes`
+        : editor.kind === 'automation-job-resume'
+          ? `/automation job resume ${quoteSlashCommandArg(readField('jobId'))} --yes`
+          : editor.kind === 'automation-run-cancel'
+            ? `/automation run cancel ${quoteSlashCommandArg(readField('runId'))} --yes`
+            : editor.kind === 'automation-run-retry'
+              ? `/automation run retry ${quoteSlashCommandArg(readField('runId'))} --yes`
+              : `/automation schedule run ${quoteSlashCommandArg(readField('scheduleId'))} --yes`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening confirmed automation action.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening confirmed automation action',
+        detail: 'The workspace handed an explicit connected-host automation action to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
   if (editor.kind === 'routine-receipt' || editor.kind === 'schedule-receipt') {
     const routine = editor.kind === 'routine-receipt';
     const command = `/${routine ? 'routines' : 'schedule'} receipt ${quoteSlashCommandArg(readField('receiptId'))}`;