@pellux/goodvibes-agent 1.0.0 → 1.0.2

package/src/input/commands/personas-runtime.ts

@@ -2,38 +2,13 @@ import { discoverPersonas, type DiscoveredPersonaRecord } from '../../agent/pers
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../../agent/persona-registry.ts';
 import { formatAgentRecordOrigin, formatAgentRecordReviewState } from '../../agent/record-labels.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { parseAgentLocalLibraryArgs, type ParsedAgentLocalLibraryArgs } from './agent-local-library-args.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
-interface ParsedPersonaArgs {
-  readonly rest: readonly string[];
-  readonly flags: ReadonlyMap<string, string>;
-  readonly yes: boolean;
-}
+const PERSONA_VALUE_FLAGS = ['name', 'description', 'body', 'tags', 'triggers'] as const;
 
-function parsePersonaArgs(args: readonly string[]): ParsedPersonaArgs {
-  const flags = new Map<string, string>();
-  const rest: string[] = [];
-  let yes = false;
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index] ?? '';
-    if (token === '--yes') {
-      yes = true;
-      continue;
-    }
-    if (token.startsWith('--')) {
-      const key = token.slice(2);
-      const next = args[index + 1];
-      if (next !== undefined && !next.startsWith('--')) {
-        flags.set(key, next);
-        index += 1;
-      } else {
-        flags.set(key, 'true');
-      }
-      continue;
-    }
-    rest.push(token);
-  }
-  return { rest, flags, yes };
+function parsePersonaArgs(args: readonly string[]): ParsedAgentLocalLibraryArgs {
+  return parseAgentLocalLibraryArgs(args, { valueFlags: PERSONA_VALUE_FLAGS });
 }
 
 function splitList(value: string | undefined): readonly string[] {

package/src/input/commands/routines-runtime.ts

@@ -21,38 +21,13 @@ import {
   RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-receipts.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { parseAgentLocalLibraryArgs, type ParsedAgentLocalLibraryArgs } from './agent-local-library-args.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
-interface ParsedRoutineArgs {
-  readonly rest: readonly string[];
-  readonly flags: ReadonlyMap<string, string>;
-  readonly yes: boolean;
-}
+const ROUTINE_VALUE_FLAGS = ['name', 'description', 'steps', 'tags', 'triggers', 'requires-env', 'requires-command', 'requires-commands'] as const;
 
-function parseRoutineArgs(args: readonly string[]): ParsedRoutineArgs {
-  const flags = new Map<string, string>();
-  const rest: string[] = [];
-  let yes = false;
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index] ?? '';
-    if (token === '--yes') {
-      yes = true;
-      continue;
-    }
-    if (token.startsWith('--')) {
-      const key = token.slice(2);
-      const next = args[index + 1];
-      if (next !== undefined && !next.startsWith('--')) {
-        flags.set(key, next);
-        index += 1;
-      } else {
-        flags.set(key, 'true');
-      }
-      continue;
-    }
-    rest.push(token);
-  }
-  return { rest, flags, yes };
+function parseRoutineArgs(args: readonly string[]): ParsedAgentLocalLibraryArgs {
+  return parseAgentLocalLibraryArgs(args, { valueFlags: ROUTINE_VALUE_FLAGS });
 }
 
 function splitList(value: string | undefined): readonly string[] {

package/src/input/session-picker-modal.ts

@@ -9,20 +9,21 @@ import type { SessionInfo, SessionManager } from '@pellux/goodvibes-sdk/platform
 import type { ConversationManager } from '../core/conversation';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { readConversationMessageSnapshots } from '../core/conversation-message-snapshot.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
 
 function sessionLoadedMessage(name: string, messageCount: number): string {
   return `Loaded session ${name} (${messageCount} messages)`;
 }
 
 function sessionDeletionCommandRequiredMessage(name: string): string {
-  return `Deletion requires an explicit command: /session delete ${name} --yes`;
+  return `Deletion requires an explicit command: /session delete ${quoteSlashCommandArg(name)} --yes`;
 }
 
 export function renderSessionPickerStatePackageText(): string {
   return [
     'Loaded session <session> (<count> messages)',
     'Error',
-    sessionDeletionCommandRequiredMessage('<session>'),
+    'Deletion requires an explicit command: /session delete <session> --yes',
   ].join('\n');
 }
 

package/src/input/settings-modal-agent-policy.ts

@@ -1,44 +1,5 @@
-export const AGENT_EXTERNAL_HOST_SETTING_LOCK_REASON = 'GoodVibes Agent uses a connected GoodVibes host. Change host lifecycle and bind posture from the owning host; Agent settings are read-only for those controls.';
-
-const AGENT_HIDDEN_SETTING_PREFIXES = [
-  ['cloud', 'flare.'].join(''),
-  ['surfaces.', 'home', 'assistant.'].join(''),
-  'batch.',
-  'controlPlane.',
-  'danger.',
-  'httpListener.',
-  'network.',
-  'orchestration.',
-  'runtime.',
-  'service.',
-  'sandbox.',
-  'web.',
-  'watchers.',
-  'wrfc.',
-] as const;
-
-const AGENT_HIDDEN_SETTING_KEYS = new Set<string>([
-  'ui.wrfcMessages',
-]);
-
-const EXTERNAL_HOST_SETTING_PREFIXES = [
-  'service.',
-  'controlPlane.',
-  'httpListener.',
-  'web.',
-] as const;
-
-const EXTERNAL_HOST_SETTING_KEYS = new Set<string>([
-  'danger.daemon',
-  'danger.httpListener',
-]);
-
-export function isExternalHostOwnedSettingKey(key: string): boolean {
-  return EXTERNAL_HOST_SETTING_KEYS.has(key)
-    || EXTERNAL_HOST_SETTING_PREFIXES.some((prefix) => key.startsWith(prefix));
-}
-
-export function isAgentHiddenSettingKey(key: string): boolean {
-  return AGENT_HIDDEN_SETTING_KEYS.has(key)
-    || AGENT_HIDDEN_SETTING_PREFIXES.some((prefix) => key.startsWith(prefix));
-}
+export {
+  AGENT_EXTERNAL_HOST_SETTING_LOCK_REASON,
+  isAgentHiddenSettingKey,
+  isExternalHostOwnedSettingKey,
+} from '../config/agent-settings-policy.ts';

package/src/runtime/bootstrap.ts

@@ -42,6 +42,7 @@ import { buildActivePersonaPrompt } from '../agent/persona-registry.ts';
 import { buildEnabledSkillsPrompt } from '../agent/skill-registry.ts';
 import { buildEnabledRoutinesPrompt } from '../agent/routine-registry.ts';
 import { buildReviewedMemoryPrompt } from '../agent/memory-prompt.ts';
+import { registerAgentHarnessTool } from '../tools/agent-harness-tool.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
@@ -50,6 +51,7 @@ const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '- Use the `agent_operator_briefing` tool for read-only main-conversation summaries of connected work plan, approvals, automation, schedules, and scheduler capacity. This tool must not call mutation routes, connected-host lifecycle routes, default knowledge, non-Agent knowledge spaces, separate Agent job creation, or GoodVibes TUI delegation.',
   '- When the user explicitly asks Agent to approve, deny, or cancel a specific approval, run/pause/resume a specific automation job, cancel/retry a specific automation run, or run a specific schedule, use the `agent_operator_action` tool with confirm:true and the original user request. It can call only its allowlisted public operator routes and must not create, edit, delete, or discover automation definitions.',
   '- Use the `agent_work_plan` tool to keep the visible Agent-local work plan current while working in the main conversation. Create, inspect, and update local work items proactively when useful. Removing items or clearing completed items requires an explicit user request and confirm:true.',
+  '- Use the `agent_harness` tool to inspect and operate the harness surface itself: Agent workspace action catalog, slash command catalog, model tool catalog, connected-host posture, and Agent settings. Use it to change Agent settings, invoke workspace action mirrors, or invoke slash-command mirrors only when the user explicitly asks; preserve confirm:true and explicitUserRequest for mutations, keep secret-backed settings in the secret manager, and keep connected-host lifecycle/posture externally owned.',
   '- Use the `agent_knowledge` tool for Agent Knowledge status, ask, and search from the main conversation. It must use only /api/goodvibes-agent/knowledge/* and must fail closed instead of falling back to default knowledge or non-Agent knowledge spaces.',
   '- When the user explicitly asks Agent to add, import, remember, or ingest a URL, URL-list file, local file, bookmarks file, browser history, or connector input into Agent Knowledge, use the `agent_knowledge_ingest` tool with confirm:true and the original user request. It must write only to /api/goodvibes-agent/knowledge/* ingest routes and never to default knowledge or non-Agent knowledge spaces.',
   '- Use the `agent_local_registry` tool when a scratchpad note, durable memory, reusable persona, skill, skill bundle, or routine would improve later work. Keep those records Agent-local, non-secret, source/provenance tagged, and reviewable. Notes are for temporary/source-triage context; promote them explicitly into memory, skills, personas, routines, or Agent Knowledge only when that is the correct durable home. Review memory with a confidence score when it should shape later turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
@@ -285,6 +287,7 @@ export async function bootstrapRuntime(
   const commandRegistry = shell.commandRegistry;
   const commandContext = shell.commandContext;
   const inputHistory = shell.inputHistory;
+  registerAgentHarnessTool(toolRegistry, commandRegistry, commandContext);
   const pluginCommandRegistry = {
     register(command: {
       readonly name: string;

package/src/tools/agent-harness-local-operations.ts

@@ -0,0 +1,233 @@
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+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 type { CommandContext } from '../input/command-registry.ts';
+import {
+  createKnowledgeUrlEditorFromNote,
+  createMemoryEditorFromNote,
+  createMemoryUpdateEditor,
+  createNoteUpdateEditor,
+  createPersonaEditorFromNote,
+  createPersonaUpdateEditor,
+  createRoutineEditorFromNote,
+  createRoutineUpdateEditor,
+  createSkillEditorFromNote,
+  createSkillUpdateEditor,
+  isAffirmative,
+  splitList,
+} from '../input/agent-workspace-editors.ts';
+import type { AgentWorkspaceAction, AgentWorkspaceLocalEditor, AgentWorkspaceLocalOperation } from '../input/agent-workspace-types.ts';
+
+export interface AgentHarnessLocalOperationArgs {
+  readonly fields?: unknown;
+  readonly recordId?: unknown;
+  readonly id?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+export interface AgentHarnessLocalOperationDeps {
+  readonly commandContext: CommandContext;
+  readonly toolRegistry: ToolRegistry;
+}
+
+type HarnessResult =
+  | { readonly success: true; readonly output: string }
+  | { readonly success: false; readonly error: string };
+
+type RegistryDomain = 'memory' | 'note' | 'persona' | 'skill' | 'routine';
+type RegistryAction = 'update' | 'review' | 'stale' | 'delete' | 'use' | 'clear_active' | 'enable' | 'disable' | 'start';
+
+interface RegistryTarget {
+  readonly domain: RegistryDomain;
+  readonly action: RegistryAction;
+  readonly requiresRecordId: boolean;
+}
+
+function output(value: unknown): HarnessResult {
+  return { success: true, output: typeof value === 'string' ? value : JSON.stringify(value, null, 2) };
+}
+
+function error(message: string): HarnessResult {
+  return { success: false, error: message };
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readFieldMap(value: unknown): Readonly<Record<string, string>> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, typeof entry === 'string' ? entry : String(entry)]));
+}
+
+function describeEditor(editor: AgentWorkspaceLocalEditor): Record<string, unknown> {
+  return {
+    kind: editor.kind,
+    mode: editor.mode,
+    recordId: editor.recordId,
+    title: editor.title,
+    message: editor.message,
+    fields: editor.fields.map((field) => ({
+      id: field.id,
+      label: field.label,
+      required: field.required,
+      multiline: field.multiline,
+      hint: field.hint,
+      default: field.redact ? '<redacted>' : field.value,
+    })),
+  };
+}
+
+function readRecordId(args: AgentHarnessLocalOperationArgs): string {
+  const fields = readFieldMap(args.fields);
+  return readString(args.recordId ?? args.id ?? fields.recordId ?? fields.id);
+}
+
+function requireConfirmed(args: AgentHarnessLocalOperationArgs, label: string): string | null {
+  if (!readString(args.explicitUserRequest)) return `${label} requires explicitUserRequest with the user's exact request or a short faithful summary.`;
+  if (args.confirm !== true) return `${label} requires confirm:true after an explicit user request.`;
+  return null;
+}
+
+function fieldReader(editor: AgentWorkspaceLocalEditor, fields: Readonly<Record<string, string>>): (id: string) => string {
+  return (id: string) => fields[id] ?? editor.fields.find((field) => field.id === id)?.value ?? '';
+}
+
+function hasExecutionFields(args: AgentHarnessLocalOperationArgs): boolean {
+  return Object.keys(readFieldMap(args.fields)).some((key) => key !== 'id' && key !== 'recordId');
+}
+
+function missingRequiredFields(editor: AgentWorkspaceLocalEditor, fields: Readonly<Record<string, string>>): readonly string[] {
+  const read = fieldReader(editor, fields);
+  return editor.fields.filter((field) => field.required && !read(field.id).trim()).map((field) => field.id);
+}
+
+function registryTarget(operation: AgentWorkspaceLocalOperation): RegistryTarget | null {
+  if (operation === 'memory-edit') return { domain: 'memory', action: 'update', requiresRecordId: true };
+  if (operation === 'memory-review') return { domain: 'memory', action: 'review', requiresRecordId: true };
+  if (operation === 'memory-stale') return { domain: 'memory', action: 'stale', requiresRecordId: true };
+  if (operation === 'memory-delete') return { domain: 'memory', action: 'delete', requiresRecordId: true };
+  if (operation === 'note-edit') return { domain: 'note', action: 'update', requiresRecordId: true };
+  if (operation === 'note-review') return { domain: 'note', action: 'review', requiresRecordId: true };
+  if (operation === 'note-stale') return { domain: 'note', action: 'stale', requiresRecordId: true };
+  if (operation === 'note-delete') return { domain: 'note', action: 'delete', requiresRecordId: true };
+  if (operation === 'persona-edit') return { domain: 'persona', action: 'update', requiresRecordId: true };
+  if (operation === 'persona-use') return { domain: 'persona', action: 'use', requiresRecordId: true };
+  if (operation === 'persona-review') return { domain: 'persona', action: 'review', requiresRecordId: true };
+  if (operation === 'persona-clear') return { domain: 'persona', action: 'clear_active', requiresRecordId: false };
+  if (operation === 'persona-delete') return { domain: 'persona', action: 'delete', requiresRecordId: true };
+  if (operation === 'skill-edit') return { domain: 'skill', action: 'update', requiresRecordId: true };
+  if (operation === 'skill-enable') return { domain: 'skill', action: 'enable', requiresRecordId: true };
+  if (operation === 'skill-disable') return { domain: 'skill', action: 'disable', requiresRecordId: true };
+  if (operation === 'skill-review') return { domain: 'skill', action: 'review', requiresRecordId: true };
+  if (operation === 'skill-delete') return { domain: 'skill', action: 'delete', requiresRecordId: true };
+  if (operation === 'routine-edit') return { domain: 'routine', action: 'update', requiresRecordId: true };
+  if (operation === 'routine-start') return { domain: 'routine', action: 'start', requiresRecordId: true };
+  if (operation === 'routine-enable') return { domain: 'routine', action: 'enable', requiresRecordId: true };
+  if (operation === 'routine-disable') return { domain: 'routine', action: 'disable', requiresRecordId: true };
+  if (operation === 'routine-review') return { domain: 'routine', action: 'review', requiresRecordId: true };
+  if (operation === 'routine-delete') return { domain: 'routine', action: 'delete', requiresRecordId: true };
+  return null;
+}
+
+function editorForOperation(context: CommandContext, operation: AgentWorkspaceLocalOperation, recordId: string): AgentWorkspaceLocalEditor | null {
+  const shellPaths = context.workspace.shellPaths;
+  if (operation === 'memory-edit') {
+    const record = context.clients?.agentKnowledgeApi?.memory?.get(recordId);
+    return record ? createMemoryUpdateEditor(record) : null;
+  }
+  if (!shellPaths) return null;
+  if (operation === 'note-edit') {
+    const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(recordId);
+    return note ? createNoteUpdateEditor(note) : null;
+  }
+  if (operation === 'note-promote-memory' || operation === 'note-promote-persona' || operation === 'note-promote-skill' || operation === 'note-promote-routine' || operation === 'note-promote-knowledge-url') {
+    const note = AgentNoteRegistry.fromShellPaths(shellPaths).get(recordId);
+    if (!note) return null;
+    if (operation === 'note-promote-memory') return createMemoryEditorFromNote(note);
+    if (operation === 'note-promote-persona') return createPersonaEditorFromNote(note);
+    if (operation === 'note-promote-skill') return createSkillEditorFromNote(note);
+    if (operation === 'note-promote-routine') return createRoutineEditorFromNote(note);
+    return note.sourceUrl ? createKnowledgeUrlEditorFromNote(note) : null;
+  }
+  if (operation === 'persona-edit') {
+    const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+    const persona = registry.get(recordId);
+    return persona ? createPersonaUpdateEditor(persona, registry.snapshot().activePersonaId === persona.id) : null;
+  }
+  if (operation === 'skill-edit') {
+    const skill = AgentSkillRegistry.fromShellPaths(shellPaths).get(recordId);
+    return skill ? createSkillUpdateEditor(skill) : null;
+  }
+  if (operation === 'routine-edit') {
+    const routine = AgentRoutineRegistry.fromShellPaths(shellPaths).get(recordId);
+    return routine ? createRoutineUpdateEditor(routine) : null;
+  }
+  return null;
+}
+
+function localRegistryArgsFromEditor(editor: AgentWorkspaceLocalEditor, fields: Readonly<Record<string, string>>, id?: string): Record<string, unknown> {
+  const read = fieldReader(editor, fields);
+  if (editor.kind === 'memory') return { domain: 'memory', action: editor.mode === 'update' ? 'update' : 'create', id, cls: read('cls'), scope: read('scope'), summary: read('summary'), detail: read('detail'), tags: splitList(read('tags')), confidence: read('confidence'), provenance: editor.recordId ? 'agent-harness-local-operation' : 'agent-harness-note-promotion' };
+  if (editor.kind === 'note') return { domain: 'note', action: 'update', id, title: read('title'), body: read('body'), sourceUrl: read('sourceUrl'), tags: splitList(read('tags')), provenance: 'agent-harness-local-operation' };
+  if (editor.kind === 'persona') return { domain: 'persona', action: editor.mode === 'update' ? 'update' : 'create', id, name: read('name'), description: read('description'), body: read('body'), tags: splitList(read('tags')), triggers: splitList(read('triggers')), activate: read('activate'), provenance: editor.recordId ? 'agent-harness-local-operation' : 'agent-harness-note-promotion' };
+  if (editor.kind === 'skill') return { domain: 'skill', action: editor.mode === 'update' ? 'update' : 'create', id, name: read('name'), description: read('description'), procedure: read('procedure'), tags: splitList(read('tags')), triggers: splitList(read('triggers')), requiresEnv: splitList(read('requiresEnv')), requiresCommands: splitList(read('requiresCommands')), enabled: isAffirmative(read('enabled')), provenance: editor.recordId ? 'agent-harness-local-operation' : 'agent-harness-note-promotion' };
+  return { domain: 'routine', action: editor.mode === 'update' ? 'update' : 'create', id, name: read('name'), description: read('description'), steps: read('steps'), tags: splitList(read('tags')), triggers: splitList(read('triggers')), requiresEnv: splitList(read('requiresEnv')), requiresCommands: splitList(read('requiresCommands')), enabled: isAffirmative(read('enabled')), provenance: editor.recordId ? 'agent-harness-local-operation' : 'agent-harness-note-promotion' };
+}
+
+function localRegistryArgsForTarget(target: RegistryTarget, args: AgentHarnessLocalOperationArgs, recordId: string): Record<string, unknown> {
+  const fields = readFieldMap(args.fields);
+  const base = { domain: target.domain, action: target.action, ...(recordId ? { id: recordId } : {}) };
+  const edit = target.action === 'update' ? localRegistryArgsFromEditor({ kind: target.domain, mode: 'update', recordId, title: '', selectedFieldIndex: 0, message: '', fields: [] } as AgentWorkspaceLocalEditor, fields, recordId) : {};
+  return {
+    ...base,
+    ...edit,
+    ...(target.action === 'stale' && fields.reason ? { reason: fields.reason } : {}),
+    ...(target.action === 'delete' ? { confirm: args.confirm, explicitUserRequest: readString(args.explicitUserRequest) } : {}),
+  };
+}
+
+async function executeTool(toolRegistry: ToolRegistry, name: string, toolArgs: Record<string, unknown>): Promise<HarnessResult> {
+  if (!toolRegistry.has(name)) return output({ status: 'model_tool_required', modelExecution: { tool: name, args: toolArgs } });
+  const result = await toolRegistry.execute(`agent-harness-${name}-${Date.now()}`, name, toolArgs) as { readonly success: boolean; readonly output?: string; readonly error?: string };
+  if (!result.success) return error(result.error ?? `${name} failed.`);
+  return output({ status: 'executed_model_tool', tool: name, output: result.output ?? '' });
+}
+
+export function describeLocalWorkspaceModelExecution(action: AgentWorkspaceAction): Record<string, unknown> | null {
+  if (action.kind === 'local-selection') return { tool: 'agent_local_registry', domain: action.localKind, actions: ['list', 'search', 'get'], note: 'TUI selection maps to recordId for model-run local-operation actions.' };
+  if (!action.localOperation) return null;
+  const target = registryTarget(action.localOperation);
+  if (target) return { tool: 'agent_local_registry', domain: target.domain, action: target.action, requiresRecordId: target.requiresRecordId };
+  if (action.localOperation === 'note-promote-knowledge-url') return { tool: 'agent_knowledge_ingest', sourceKind: 'url', requiresRecordId: true, selectedRecordDomain: 'note' };
+  return { tool: 'agent_local_registry', selectedRecordDomain: 'note', action: 'create', requiresRecordId: true };
+}
+
+export async function runLocalWorkspaceAction(
+  deps: AgentHarnessLocalOperationDeps,
+  action: AgentWorkspaceAction,
+  args: AgentHarnessLocalOperationArgs,
+): Promise<HarnessResult> {
+  if (action.kind === 'local-selection') return output({ status: 'local_selection', action: action.id, modelExecution: describeLocalWorkspaceModelExecution(action) });
+  const operation = action.localOperation;
+  if (!operation) return output({ status: 'local_registry_action', action: action.id, modelExecution: describeLocalWorkspaceModelExecution(action) });
+  const target = registryTarget(operation);
+  const recordId = readRecordId(args);
+  if (target?.requiresRecordId && !recordId) return output({ status: 'needs_record_id', action: action.id, modelExecution: describeLocalWorkspaceModelExecution(action) });
+  const editor = recordId ? editorForOperation(deps.commandContext, operation, recordId) : null;
+  if (editor && !hasExecutionFields(args) && args.confirm !== true) return output({ status: 'editor', action: action.id, editor: describeEditor(editor), modelExecution: describeLocalWorkspaceModelExecution(action) });
+  const confirmationError = requireConfirmed(args, 'Workspace local registry action');
+  if (confirmationError) return error(confirmationError);
+  if (editor) {
+    const fields = readFieldMap(args.fields);
+    const missing = missingRequiredFields(editor, fields);
+    if (missing.length > 0) return output({ status: 'missing_required_fields', missing, action: action.id, editor: describeEditor(editor) });
+    if (editor.kind === 'knowledge-url') return executeTool(deps.toolRegistry, 'agent_knowledge_ingest', { sourceKind: 'url', url: fieldReader(editor, fields)('url'), tags: splitList(fieldReader(editor, fields)('tags')), folderPath: fieldReader(editor, fields)('folder'), confirm: args.confirm, explicitUserRequest: readString(args.explicitUserRequest) });
+    return executeTool(deps.toolRegistry, 'agent_local_registry', localRegistryArgsFromEditor(editor, fields, recordId));
+  }
+  if (!target) return output({ status: 'local_registry_action', action: action.id, modelExecution: describeLocalWorkspaceModelExecution(action) });
+  return executeTool(deps.toolRegistry, 'agent_local_registry', localRegistryArgsForTarget(target, args, recordId));
+}