@pellux/goodvibes-agent 1.0.1 → 1.0.2

package/src/config/agent-settings-policy.ts

@@ -0,0 +1,44 @@
+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));
+}

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

@@ -9,12 +9,14 @@ import type {
   AgentWorkspaceActionResult,
   AgentWorkspaceCategory,
   AgentWorkspaceCommandDispatcher,
+  AgentWorkspaceEditorKind,
   AgentWorkspaceFocusPane,
   AgentWorkspaceLocalEditor,
   AgentWorkspaceLocalEditorKind,
   AgentWorkspaceLocalLibraryItem,
   AgentWorkspaceLocalOperation,
   AgentWorkspaceRuntimeSnapshot,
+  AgentWorkspaceRuntimeStarterTemplateItem,
 } from './agent-workspace-types.ts';
 
 interface AgentWorkspaceActivationHost {
@@ -55,7 +57,10 @@ export function activateAgentWorkspaceSelection(
   const action = workspace.selectedAction;
   if (!action) return;
   if (action.kind === 'editor' && action.editorKind) {
-    const editor = createWorkspaceEditor(workspace, action.editorKind);
+    const editor = createAgentWorkspaceEditor(action.editorKind, {
+      runtimeStarterTemplates: workspace.runtimeSnapshot?.runtimeStarterTemplates ?? [],
+      selectedRoutine: workspace.selectedLocalLibraryItem('routine'),
+    });
     if (!editor) {
       workspace.status = `Editor unavailable: ${action.editorKind}.`;
       workspace.lastActionResult = {
@@ -143,11 +148,14 @@ export function activateAgentWorkspaceSelection(
   workspace.dispatchWorkspaceCommand(action.command);
 }
 
-function createWorkspaceEditor(
-  workspace: AgentWorkspaceActivationHost,
-  editorKind: NonNullable<AgentWorkspaceCategory['actions'][number]['editorKind']>,
+export function createAgentWorkspaceEditor(
+  editorKind: AgentWorkspaceEditorKind,
+  options: {
+    readonly runtimeStarterTemplates?: readonly AgentWorkspaceRuntimeStarterTemplateItem[];
+    readonly selectedRoutine?: AgentWorkspaceLocalLibraryItem | null;
+  } = {},
 ): AgentWorkspaceLocalEditor | null {
-  if (editorKind === 'profile') return createProfileEditor(workspace.runtimeSnapshot?.runtimeStarterTemplates ?? []);
+  if (editorKind === 'profile') return createProfileEditor(options.runtimeStarterTemplates ?? []);
   if (editorKind === 'learned-behavior') return createLearnedBehaviorEditor();
   if (editorKind === 'web-research') return createAgentWorkspaceWebResearchEditor('research');
   if (editorKind === 'web-fetch') return createAgentWorkspaceWebResearchEditor('fetch');
@@ -155,7 +163,7 @@ function createWorkspaceEditor(
   if (editorKind === 'knowledge-ask') return createAgentKnowledgeQueryEditor('ask');
   if (editorKind === 'knowledge-search') return createAgentKnowledgeQueryEditor('search');
   if (editorKind === 'reminder-schedule') return createReminderScheduleEditor();
-  if (editorKind === 'routine-schedule') return createRoutineScheduleEditor(workspace.selectedLocalLibraryItem('routine'));
+  if (editorKind === 'routine-schedule') return createRoutineScheduleEditor(options.selectedRoutine ?? null);
   if (
     editorKind === 'memory'
     || editorKind === 'note'

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

@@ -2,14 +2,150 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import {
+  formatHarnessError,
+  formatHarnessMutation,
+  formatHarnessSetting,
+  formatHarnessSettingList,
+  getHarnessSetting,
+  listHarnessSettings,
+  resetHarnessSetting,
+  setHarnessSetting,
+} from '../../agent/harness-control.ts';
+
+function readValuedFlag(args: readonly string[], flag: string): string | undefined {
+  const assignmentPrefix = `${flag}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === flag) {
+      const value = args[index + 1];
+      return value && !value.startsWith('--') ? value : undefined;
+    }
+    if (arg?.startsWith(assignmentPrefix)) return arg.slice(assignmentPrefix.length);
+  }
+  return undefined;
+}
+
+function stripValuedFlag(args: readonly string[], flag: string): readonly string[] {
+  const next: string[] = [];
+  const assignmentPrefix = `${flag}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === flag) {
+      const value = args[index + 1];
+      if (value && !value.startsWith('--')) index += 1;
+      continue;
+    }
+    if (arg?.startsWith(assignmentPrefix)) {
+      continue;
+    }
+    next.push(arg!);
+  }
+  return next;
+}
+
+function parseSettingListArgs(args: readonly string[]): {
+  readonly category?: string;
+  readonly prefix?: string;
+  readonly query?: string;
+  readonly includeHidden: boolean;
+  readonly limit?: number;
+} {
+  const category = readValuedFlag(args, '--category');
+  const prefix = readValuedFlag(args, '--prefix');
+  const limitText = readValuedFlag(args, '--limit');
+  const remaining = stripValuedFlag(stripValuedFlag(stripValuedFlag(args, '--category'), '--prefix'), '--limit')
+    .filter((arg) => arg !== '--include-hidden');
+  const query = remaining.join(' ').trim();
+  return {
+    ...(category ? { category } : {}),
+    ...(prefix ? { prefix } : {}),
+    ...(query ? { query } : {}),
+    includeHidden: args.includes('--include-hidden'),
+    ...(limitText ? { limit: Number(limitText) } : {}),
+  };
+}
 
 export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'settings',
     aliases: ['cfg-ui'],
-    description: 'Open the fullscreen configuration workspace',
-    handler(_args, ctx) {
-      if (ctx.openSettingsModal) ctx.openSettingsModal();
+    description: 'Open, inspect, or update Agent settings',
+    usage: '[category|key|list|get <key>|set <key> <value> --yes|reset <key> --yes]',
+    argsHint: '[list|get|set|reset]',
+    async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = commandArgs[0];
+
+      if (!sub) {
+        if (ctx.openSettingsModal) ctx.openSettingsModal();
+        else ctx.print('Configuration workspace is not available in this runtime.');
+        return;
+      }
+
+      if (sub === 'list' || sub === 'schema') {
+        ctx.print(formatHarnessSettingList(listHarnessSettings(ctx.platform.configManager, parseSettingListArgs(commandArgs.slice(1)))));
+        return;
+      }
+
+      if (sub === 'get' || sub === 'show') {
+        const key = commandArgs[1];
+        if (!key) {
+          ctx.print('Usage: /settings get <key>');
+          return;
+        }
+        ctx.print(formatHarnessSetting(getHarnessSetting(ctx.platform.configManager, key)));
+        return;
+      }
+
+      if (sub === 'set') {
+        const key = commandArgs[1];
+        const rawValue = commandArgs.slice(2).join(' ');
+        if (!key || rawValue.length === 0) {
+          ctx.print('Usage: /settings set <key> <value> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `set setting ${key}`, '/settings set <key> <value> --yes');
+          return;
+        }
+        try {
+          const result = await setHarnessSetting(ctx.platform.configManager, ctx.platform.secretsManager, key, rawValue);
+          ctx.print(formatHarnessMutation(result));
+          ctx.renderRequest();
+        } catch (error) {
+          ctx.print(formatHarnessError(error));
+        }
+        return;
+      }
+
+      if (sub === 'reset') {
+        const key = commandArgs[1];
+        if (!key) {
+          ctx.print('Usage: /settings reset <key> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `reset setting ${key}`, '/settings reset <key> --yes');
+          return;
+        }
+        try {
+          const result = await resetHarnessSetting(ctx.platform.configManager, ctx.platform.secretsManager, key);
+          ctx.print(formatHarnessMutation(result));
+          ctx.renderRequest();
+        } catch (error) {
+          ctx.print(formatHarnessError(error));
+        }
+        return;
+      }
+
+      if (sub.includes('.')) {
+        ctx.print(formatHarnessSetting(getHarnessSetting(ctx.platform.configManager, sub)));
+        return;
+      }
+
+      if (ctx.openSettingsModal) ctx.openSettingsModal(sub);
       else ctx.print('Configuration workspace is not available in this runtime.');
     },
   });

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