@pellux/goodvibes-agent 0.1.114 → 0.1.117

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

@@ -0,0 +1,55 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceDelegationEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+export function isAgentWorkspaceDelegationEditorKind(kind: string): kind is 'delegate-task' {
+  return kind === 'delegate-task';
+}
+
+export function buildAgentWorkspaceDelegationEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceDelegationEditorSubmission {
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Build delegation not confirmed. Type yes, then press Enter.' },
+      status: 'Build delegation not confirmed.',
+    };
+  }
+  const parts = ['/delegate'];
+  if (isAffirmative(readField('wrfc'))) parts.push('--wrfc');
+  parts.push(quoteSlashCommandArg(readField('task')));
+  const command = parts.join(' ');
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Opening explicit build delegation.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Opening explicit build delegation',
+      detail: 'The workspace handed a confirmed build/fix/review task to the shell-owned command router.',
+      command,
+      safety: 'delegates',
+    },
+  };
+}

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

@@ -30,6 +30,25 @@ export function createProfileEditor(templates: readonly AgentWorkspaceRuntimeSta
   };
 }
 
+export function createLearnedBehaviorEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'learned-behavior',
+    mode: 'create',
+    title: 'Capture Learned Behavior',
+    selectedFieldIndex: 0,
+    message: 'Turn a reviewed workflow or lesson into local Agent behavior. This writes only to local personas, skills, or routines.',
+    fields: [
+      { id: 'target', label: 'Behavior type', value: 'skill', required: true, multiline: false, hint: 'skill, routine, or persona.' },
+      { id: 'name', label: 'Name', value: '', required: true, multiline: false, hint: 'Short name for the learned behavior.' },
+      { id: 'description', label: 'Description', value: '', required: true, multiline: false, hint: 'One-line summary of when to use it.' },
+      { id: 'notes', label: 'Lesson or workflow', value: '', required: true, multiline: true, hint: 'Paste the procedure, persona guidance, or repeatable workflow. Ctrl-J inserts a new line.' },
+      { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this behavior.' },
+      { id: 'tags', label: 'Tags', value: 'learned', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'enable', label: 'Enable or activate', value: 'yes', required: false, multiline: false, hint: 'yes/no. Skills and routines enable; personas activate.' },
+    ],
+  };
+}
+
 export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind | 'knowledge-url'): AgentWorkspaceLocalEditor {
   if (kind === 'profile') return createProfileEditor([]);
   if (kind === 'knowledge-url') {
@@ -94,6 +113,8 @@ export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind | 'knowled
         { id: 'procedure', label: 'Procedure', value: '', required: true, multiline: true, hint: 'Reusable steps. Ctrl-J inserts a new line.' },
         { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this skill.' },
         { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+        { id: 'requiresEnv', label: 'Required env vars', value: '', required: false, multiline: false, hint: 'Comma-separated env var names. Values are never stored.' },
+        { id: 'requiresCommands', label: 'Required commands', value: '', required: false, multiline: false, hint: 'Comma-separated binaries that must be on PATH.' },
         { id: 'enabled', label: 'Enable now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
       ],
     };
@@ -110,6 +131,8 @@ export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind | 'knowled
       { id: 'steps', label: 'Steps', value: '', required: true, multiline: true, hint: 'Workflow steps. Ctrl-J inserts a new line.' },
       { id: 'triggers', label: 'Triggers', value: '', required: false, multiline: false, hint: 'Comma-separated words that suggest this routine.' },
       { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'requiresEnv', label: 'Required env vars', value: '', required: false, multiline: false, hint: 'Comma-separated env var names. Values are never stored.' },
+      { id: 'requiresCommands', label: 'Required commands', value: '', required: false, multiline: false, hint: 'Comma-separated binaries that must be on PATH.' },
       { id: 'enabled', label: 'Enable now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
     ],
   };
@@ -165,6 +188,8 @@ export function createSkillUpdateEditor(record: AgentSkillRecord): AgentWorkspac
       { id: 'procedure', label: 'Procedure', value: record.procedure, required: true, multiline: true, hint: 'Reusable steps. Ctrl-J inserts a new line.' },
       { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this skill.' },
       { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'requiresEnv', label: 'Required env vars', value: record.requirements.filter((requirement) => requirement.kind === 'env').map((requirement) => requirement.name).join(', '), required: false, multiline: false, hint: 'Comma-separated env var names. Values are never stored.' },
+      { id: 'requiresCommands', label: 'Required commands', value: record.requirements.filter((requirement) => requirement.kind === 'command').map((requirement) => requirement.name).join(', '), required: false, multiline: false, hint: 'Comma-separated binaries that must be on PATH.' },
       { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
     ],
   };
@@ -184,6 +209,8 @@ export function createRoutineUpdateEditor(record: AgentRoutineRecord): AgentWork
       { id: 'steps', label: 'Steps', value: record.steps, required: true, multiline: true, hint: 'Workflow steps. Ctrl-J inserts a new line.' },
       { id: 'triggers', label: 'Triggers', value: record.triggers.join(', '), required: false, multiline: false, hint: 'Comma-separated words that suggest this routine.' },
       { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+      { id: 'requiresEnv', label: 'Required env vars', value: record.requirements.filter((requirement) => requirement.kind === 'env').map((requirement) => requirement.name).join(', '), required: false, multiline: false, hint: 'Comma-separated env var names. Values are never stored.' },
+      { id: 'requiresCommands', label: 'Required commands', value: record.requirements.filter((requirement) => requirement.kind === 'command').map((requirement) => requirement.name).join(', '), required: false, multiline: false, hint: 'Comma-separated binaries that must be on PATH.' },
       { id: 'enabled', label: 'Enabled', value: record.enabled ? 'yes' : 'no', required: false, multiline: false, hint: 'yes/no.' },
     ],
   };

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-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' | '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' | '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' ? '/agent-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 local Agent ${target}s by name, description, tags, triggers, or body.`
+      : `Show one local Agent ${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-mcp-command-editor-submission.ts

@@ -0,0 +1,95 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg, tokenizeSlashCommand } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceMcpCommandEditorKind = Extract<AgentWorkspaceEditorKind, 'mcp-server' | 'mcp-tools-server' | 'mcp-repair'>;
+
+export type AgentWorkspaceMcpCommandEditorSubmission =
+  | {
+    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 isAgentWorkspaceMcpCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMcpCommandEditorKind {
+  return kind === 'mcp-server' || kind === 'mcp-tools-server' || kind === 'mcp-repair';
+}
+
+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);
+}
+
+export function buildAgentWorkspaceMcpCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceMcpCommandEditorSubmission {
+  if (editor.kind === 'mcp-tools-server' || editor.kind === 'mcp-repair') {
+    const server = quoteSlashCommandArg(readField('server'));
+    const tools = editor.kind === 'mcp-tools-server';
+    const command = tools ? `/mcp tools ${server}` : `/mcp repair ${server}`;
+    const title = tools ? 'Opening MCP server tools' : 'Opening MCP repair guidance';
+    return {
+      kind: 'dispatch',
+      command,
+      status: `${title}.`,
+      actionResult: {
+        kind: 'dispatched',
+        title,
+        detail: tools
+          ? 'The workspace handed read-only MCP server tool inspection to the shell-owned command router.'
+          : 'The workspace handed read-only MCP repair guidance to the shell-owned command router.',
+        command,
+        safety: 'read-only',
+      },
+    };
+  }
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'MCP server add/update not confirmed. Type yes, then press Enter.' },
+      status: 'MCP server add/update not confirmed.',
+    };
+  }
+  const parts = [
+    '/mcp',
+    'add',
+    quoteSlashCommandArg(readField('name')),
+    quoteSlashCommandArg(readField('command')),
+    ...tokenizeSlashCommand(readField('args')).map(quoteSlashCommandArg),
+  ];
+  const scope = readField('scope');
+  const role = readField('role');
+  const trust = readField('trust');
+  if (scope.length > 0) parts.push('--scope', quoteSlashCommandArg(scope));
+  if (role.length > 0) parts.push('--role', quoteSlashCommandArg(role));
+  if (trust.length > 0) parts.push('--trust', quoteSlashCommandArg(trust));
+  for (const env of splitCommaList(readField('env'))) parts.push('--env', quoteSlashCommandArg(env));
+  for (const path of splitCommaList(readField('paths'))) parts.push('--path', quoteSlashCommandArg(path));
+  for (const host of splitCommaList(readField('hosts'))) parts.push('--host', quoteSlashCommandArg(host));
+  parts.push('--yes');
+  const command = parts.join(' ');
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Opening MCP server add/update.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Opening MCP server add/update',
+      detail: 'The workspace handed a confirmed MCP server add/update command to the shell-owned command router.',
+      command,
+      safety: 'safe',
+    },
+  };
+}