@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

@@ -0,0 +1,132 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceKnowledgeCommandEditorKind } from './agent-workspace-knowledge-command-editors.ts';
+import { isAgentWorkspaceKnowledgeCommandEditorKind } from './agent-workspace-knowledge-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceKnowledgeCommandEditorSubmission =
+  | {
+    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 isAgentWorkspaceKnowledgeCommandSubmissionKind(kind: string): kind is AgentWorkspaceKnowledgeCommandEditorKind {
+  return isAgentWorkspaceKnowledgeCommandEditorKind(kind as AgentWorkspaceKnowledgeCommandEditorKind);
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function splitCommaList(value: string): readonly string[] {
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceKnowledgeCommandEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status: message,
+  };
+}
+
+function dispatch(command: string, title: string, detail: string, safety: AgentWorkspaceActionResult['safety']): AgentWorkspaceKnowledgeCommandEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: { kind: 'dispatched', title, detail, command, safety },
+  };
+}
+
+export function buildAgentWorkspaceKnowledgeCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceKnowledgeCommandEditorSubmission {
+  if (editor.kind === 'knowledge-get') {
+    return dispatch(
+      `/knowledge get ${quoteSlashCommandArg(readField('id'))}`,
+      'Opening Agent Knowledge item',
+      'The workspace handed a read-only Agent Knowledge item command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'knowledge-map') {
+    const query = readField('query');
+    const limit = readField('limit');
+    const parts = ['/knowledge', 'map'];
+    if (query.length > 0) parts.push(quoteSlashCommandArg(query));
+    if (limit.length > 0) parts.push('--limit', quoteSlashCommandArg(limit));
+    return dispatch(
+      parts.join(' '),
+      'Opening Agent Knowledge map',
+      'The workspace handed a read-only Agent Knowledge map command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'knowledge-connector-show') {
+    return dispatch(
+      `/knowledge connectors ${quoteSlashCommandArg(readField('connectorId'))}`,
+      'Opening Agent Knowledge connector',
+      'The workspace handed a read-only Agent Knowledge connector detail command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'knowledge-connector-doctor') {
+    return dispatch(
+      `/knowledge connectors doctor ${quoteSlashCommandArg(readField('connectorId'))}`,
+      'Opening Agent Knowledge connector doctor',
+      'The workspace handed a read-only Agent Knowledge connector doctor command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'knowledge-review-issue') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Agent Knowledge issue review not confirmed. Type yes, then press Enter.');
+    const parts = [
+      '/knowledge',
+      'review-issue',
+      quoteSlashCommandArg(readField('issueId')),
+      quoteSlashCommandArg(readField('action')),
+    ];
+    const reviewer = readField('reviewer');
+    const value = readField('value');
+    if (reviewer.length > 0) parts.push('--reviewer', quoteSlashCommandArg(reviewer));
+    if (value.length > 0) parts.push('--value', quoteSlashCommandArg(value));
+    parts.push('--yes');
+    return dispatch(
+      parts.join(' '),
+      'Opening Agent Knowledge issue review',
+      'The workspace handed a confirmed Agent Knowledge issue review command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  if (editor.kind === 'knowledge-consolidate') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Agent Knowledge consolidation not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/knowledge consolidate ${quoteSlashCommandArg(readField('mode'))} --yes`,
+      'Opening Agent Knowledge consolidation',
+      'The workspace handed a confirmed Agent Knowledge consolidation command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  const subcommand = editor.kind === 'knowledge-explain' ? 'explain' : 'packet';
+  const parts = ['/knowledge', subcommand, quoteSlashCommandArg(readField('task'))];
+  for (const scope of splitCommaList(readField('scopes'))) {
+    parts.push('--scope', quoteSlashCommandArg(scope));
+  }
+  return dispatch(
+    parts.join(' '),
+    subcommand === 'explain' ? 'Opening Agent Knowledge explanation' : 'Opening Agent Knowledge prompt packet',
+    'The workspace handed a read-only Agent Knowledge context command to the shell-owned command router.',
+    'read-only',
+  );
+}

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

@@ -0,0 +1,110 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceKnowledgeCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'knowledge-get'
+  | 'knowledge-map'
+  | 'knowledge-connector-show'
+  | 'knowledge-connector-doctor'
+  | 'knowledge-review-issue'
+  | 'knowledge-consolidate'
+  | 'knowledge-packet'
+  | 'knowledge-explain'
+>;
+
+export function isAgentWorkspaceKnowledgeCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceKnowledgeCommandEditorKind {
+  return kind === 'knowledge-get'
+    || kind === 'knowledge-map'
+    || kind === 'knowledge-connector-show'
+    || kind === 'knowledge-connector-doctor'
+    || kind === 'knowledge-review-issue'
+    || kind === 'knowledge-consolidate'
+    || kind === 'knowledge-packet'
+    || kind === 'knowledge-explain';
+}
+
+export function createAgentWorkspaceKnowledgeCommandEditor(kind: AgentWorkspaceKnowledgeCommandEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'knowledge-get') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Agent Knowledge Item',
+      selectedFieldIndex: 0,
+      message: 'Show one source, node, or issue from the isolated Agent Knowledge segment.',
+      fields: [
+        { id: 'id', label: 'Item id', value: '', required: true, multiline: false, hint: 'Agent Knowledge source, node, or issue id.' },
+      ],
+    };
+  }
+  if (kind === 'knowledge-map') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Map Agent Knowledge',
+      selectedFieldIndex: 0,
+      message: 'Summarize the isolated Agent Knowledge graph map. Leave query blank for a bounded full map summary.',
+      fields: [
+        { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional map filter query.' },
+        { id: 'limit', label: 'Limit', value: '50', required: false, multiline: false, hint: 'Maximum map records to summarize.' },
+      ],
+    };
+  }
+  if (kind === 'knowledge-connector-show' || kind === 'knowledge-connector-doctor') {
+    const doctor = kind === 'knowledge-connector-doctor';
+    return {
+      kind,
+      mode: 'create',
+      title: doctor ? 'Doctor Agent Knowledge Connector' : 'Show Agent Knowledge Connector',
+      selectedFieldIndex: 0,
+      message: doctor
+        ? 'Run a read-only readiness doctor for one Agent Knowledge connector.'
+        : 'Show one Agent Knowledge connector from the isolated Agent Knowledge connector registry.',
+      fields: [
+        { id: 'connectorId', label: 'Connector id', value: '', required: true, multiline: false, hint: 'Connector id from the Agent Knowledge connector inventory.' },
+      ],
+    };
+  }
+  if (kind === 'knowledge-review-issue') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Review Agent Knowledge Issue',
+      selectedFieldIndex: 0,
+      message: 'Accept, reject, resolve, reopen, edit, or forget one Agent Knowledge issue. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'issueId', label: 'Issue id', value: '', required: true, multiline: false, hint: 'Issue id from the review queue.' },
+        { id: 'action', label: 'Action', value: 'resolve', required: true, multiline: false, hint: 'accept, reject, resolve, reopen, edit, or forget.' },
+        { id: 'reviewer', label: 'Reviewer', value: 'agent', required: false, multiline: false, hint: 'Reviewer label. Blank defaults to agent.' },
+        { id: 'value', label: 'Value JSON', value: '', required: false, multiline: true, hint: 'Optional JSON object for edit actions. Ctrl-J inserts a new line.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge review-issue with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'knowledge-consolidate') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Consolidate Agent Knowledge',
+      selectedFieldIndex: 0,
+      message: 'Run isolated Agent Knowledge consolidation. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'mode', label: 'Mode', value: 'light', required: true, multiline: false, hint: 'light or deep.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge consolidate with --yes.' },
+      ],
+    };
+  }
+  const explain = kind === 'knowledge-explain';
+  return {
+    kind,
+    mode: 'create',
+    title: explain ? 'Explain Memory Selection' : 'Build Prompt Packet',
+    selectedFieldIndex: 0,
+    message: explain
+      ? 'Explain which Agent Knowledge and memory context would be selected for a task.'
+      : 'Build a compact Agent Knowledge prompt packet for a task.',
+    fields: [
+      { id: 'task', label: 'Task', value: '', required: true, multiline: true, hint: 'Task or question. Ctrl-J inserts a new line.' },
+      { id: 'scopes', label: 'Scopes', value: '', required: false, multiline: false, hint: 'Optional comma-separated --scope values.' },
+    ],
+  };
+}

package/src/input/agent-workspace-knowledge-query-editor.ts

@@ -25,7 +25,7 @@ export function createAgentKnowledgeQueryEditor(mode: AgentKnowledgeQueryMode):
     title: mode === 'ask' ? 'Ask Agent Knowledge' : 'Search Agent Knowledge',
     selectedFieldIndex: 0,
     message: mode === 'ask'
-      ? 'Ask the isolated Agent Knowledge segment. If it has no answer, it fails closed instead of using another wiki.'
+      ? 'Ask the isolated Agent Knowledge segment. If it has no answer, it fails closed instead of using another knowledge segment.'
       : 'Search the isolated Agent Knowledge segment. Results come from Agent-owned sources only.',
     fields: [
       {

package/src/input/agent-workspace-learned-behavior.ts

@@ -0,0 +1,67 @@
+import type { ShellPathService } from '@/runtime/index.ts';
+import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import type { AgentWorkspaceLocalEditorKind } from './agent-workspace-types.ts';
+
+export interface AgentWorkspaceLearnedBehaviorInput {
+  readonly target: Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'note' | 'profile'>;
+  readonly name: string;
+  readonly description: string;
+  readonly notes: string;
+  readonly tags: readonly string[];
+  readonly triggers: readonly string[];
+  readonly enable: boolean;
+}
+
+export interface AgentWorkspaceLearnedBehaviorResult {
+  readonly kind: Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'note' | 'profile'>;
+  readonly id: string;
+  readonly name: string;
+}
+
+export function createAgentWorkspaceLearnedBehavior(
+  shellPaths: ShellPathService,
+  input: AgentWorkspaceLearnedBehaviorInput,
+): AgentWorkspaceLearnedBehaviorResult {
+  if (input.target === 'persona') {
+    const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+    const created = registry.create({
+      name: input.name,
+      description: input.description,
+      body: input.notes,
+      tags: input.tags,
+      triggers: input.triggers,
+      source: 'agent',
+      provenance: 'agent-workspace-learned-behavior',
+    });
+    if (input.enable) registry.setActive(created.id);
+    return { kind: 'persona', id: created.id, name: created.name };
+  }
+
+  if (input.target === 'skill') {
+    const created = AgentSkillRegistry.fromShellPaths(shellPaths).create({
+      name: input.name,
+      description: input.description,
+      procedure: input.notes,
+      tags: input.tags,
+      triggers: input.triggers,
+      enabled: input.enable,
+      source: 'agent',
+      provenance: 'agent-workspace-learned-behavior',
+    });
+    return { kind: 'skill', id: created.id, name: created.name };
+  }
+
+  const created = AgentRoutineRegistry.fromShellPaths(shellPaths).create({
+    name: input.name,
+    description: input.description,
+    steps: input.notes,
+    tags: input.tags,
+    triggers: input.triggers,
+    enabled: input.enable,
+    source: 'agent',
+    provenance: 'agent-workspace-learned-behavior',
+  });
+  return { kind: 'routine', id: created.id, name: created.name };
+}

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

@@ -0,0 +1,50 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceLibraryCommandEditorKind } from './agent-workspace-library-command-editors.ts';
+import { isAgentWorkspaceLibraryCommandEditorKind } from './agent-workspace-library-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceLibraryCommandEditorSubmission =
+  | {
+    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 isAgentWorkspaceLibraryCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceLibraryCommandEditorKind {
+  return isAgentWorkspaceLibraryCommandEditorKind(kind);
+}
+
+export function buildAgentWorkspaceLibraryCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceLibraryCommandEditorSubmission {
+  const target = editor.kind.startsWith('persona') ? 'persona' : editor.kind.startsWith('skill') ? 'skill' : 'routine';
+  const root = target === 'persona' ? '/personas' : target === 'skill' ? '/skills' : '/routines';
+  const search = editor.kind.endsWith('search');
+  const command = search
+    ? `${root} search ${quoteSlashCommandArg(readField('query'))}`
+    : `${root} show ${quoteSlashCommandArg(readField('id'))}`;
+  const label = target === 'persona' ? 'persona' : target === 'skill' ? 'skill' : 'routine';
+  const title = search ? `Opening ${label} search` : `Opening ${label} detail`;
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail: `The workspace handed read-only local ${label} ${search ? 'search' : 'detail inspection'} to the shell-owned command router.`,
+      command,
+      safety: 'read-only',
+    },
+  };
+}

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

@@ -0,0 +1,35 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceLibraryCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  'persona-search' | 'persona-show' | 'skill-search' | 'skill-show' | 'routine-search' | 'routine-show'
+>;
+
+export function isAgentWorkspaceLibraryCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceLibraryCommandEditorKind {
+  return kind === 'persona-search'
+    || kind === 'persona-show'
+    || kind === 'skill-search'
+    || kind === 'skill-show'
+    || kind === 'routine-search'
+    || kind === 'routine-show';
+}
+
+export function createAgentWorkspaceLibraryCommandEditor(kind: AgentWorkspaceLibraryCommandEditorKind): AgentWorkspaceLocalEditor {
+  const target = kind.startsWith('persona') ? 'persona' : kind.startsWith('skill') ? 'skill' : 'routine';
+  const search = kind.endsWith('search');
+  const label = target === 'persona' ? 'Persona' : target === 'skill' ? 'Skill' : 'Routine';
+  return {
+    kind,
+    mode: 'create',
+    title: search ? `Search ${label}s` : `Show ${label}`,
+    selectedFieldIndex: 0,
+    message: search
+      ? `Search Agent-local ${target}s by name, description, tags, triggers, or body.`
+      : `Show one Agent-local ${target} by id.`,
+    fields: [
+      search
+        ? { id: 'query', label: 'Search query', value: '', required: false, multiline: false, hint: `Optional text query. Blank lists every local ${target}.` }
+        : { id: 'id', label: `${label} id`, value: '', required: true, multiline: false, hint: `Existing local ${target} id.` },
+    ],
+  };
+}

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,
+    };
+  }
+}