@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

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

package/src/input/agent-workspace-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',
+    },
+  };
+}

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

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

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

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

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

@@ -0,0 +1,232 @@
+import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceMemoryCommandEditorKind } from './agent-workspace-memory-command-editors.ts';
+import { isAgentWorkspaceMemoryCommandEditorKind } from './agent-workspace-memory-command-editors.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceMemoryCommandEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+type MemoryDispatchSafety = AgentWorkspaceAction['safety'];
+
+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, label: string): AgentWorkspaceMemoryCommandEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message: `${label} not confirmed. Type yes, then press Enter.` },
+    status: `${label} not confirmed.`,
+  };
+}
+
+function dispatch(
+  command: string,
+  title: string,
+  status: string,
+  detail: string,
+  safety: MemoryDispatchSafety,
+): AgentWorkspaceMemoryCommandEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail,
+      command,
+      safety,
+    },
+  };
+}
+
+function appendOptional(parts: string[], flag: string, value: string): void {
+  if (value.trim().length > 0) {
+    parts.push(flag, quoteSlashCommandArg(value));
+  }
+}
+
+function requireConfirmation(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  label: string,
+): AgentWorkspaceMemoryCommandEditorSubmission | null {
+  return isAffirmative(readField('confirm')) ? null : unconfirmed(editor, label);
+}
+
+export function isAgentWorkspaceMemoryCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMemoryCommandEditorKind {
+  return isAgentWorkspaceMemoryCommandEditorKind(kind);
+}
+
+export function buildAgentWorkspaceMemoryCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceMemoryCommandEditorSubmission {
+  if (editor.kind === 'memory-search') {
+    const parts = ['/memory', 'search'];
+    const query = readField('query');
+    if (query.length > 0) parts.push(quoteSlashCommandArg(query));
+    appendOptional(parts, '--scope', readField('scope'));
+    appendOptional(parts, '--cls', readField('class'));
+    appendOptional(parts, '--limit', readField('limit'));
+    if (isAffirmative(readField('semantic'))) parts.push('--semantic');
+    const command = parts.join(' ');
+    return dispatch(
+      command,
+      'Opening Agent memory search',
+      'Opening Agent memory search.',
+      'The workspace handed an Agent-local memory search command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+
+  if (editor.kind === 'memory-get') {
+    const command = `/memory get ${quoteSlashCommandArg(readField('id'))}`;
+    return dispatch(
+      command,
+      'Opening Agent memory record',
+      'Opening Agent memory record.',
+      'The workspace handed an Agent-local memory lookup command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+
+  if (editor.kind === 'memory-explain') {
+    const parts = ['/memory', 'explain', quoteSlashCommandArg(readField('task'))];
+    const scopes = splitCommaList(readField('scopes'));
+    if (scopes.length > 0) {
+      parts.push('--scope');
+      for (const scope of scopes) parts.push(quoteSlashCommandArg(scope));
+    }
+    const command = parts.join(' ');
+    return dispatch(
+      command,
+      'Opening Agent memory explanation',
+      'Opening Agent memory explanation.',
+      'The workspace handed an Agent-local memory explanation command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+
+  if (editor.kind === 'memory-promote') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory promotion');
+    if (confirmation) return confirmation;
+    const command = `/memory promote ${quoteSlashCommandArg(readField('id'))} ${quoteSlashCommandArg(readField('scope'))} --yes`;
+    return dispatch(
+      command,
+      'Opening Agent memory promotion',
+      'Opening Agent memory promotion.',
+      'The workspace handed a confirmed Agent-local memory promotion command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'memory-link') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory link');
+    if (confirmation) return confirmation;
+    const command = `/memory link ${quoteSlashCommandArg(readField('fromId'))} ${quoteSlashCommandArg(readField('toId'))} ${quoteSlashCommandArg(readField('relation'))} --yes`;
+    return dispatch(
+      command,
+      'Opening Agent memory link',
+      'Opening Agent memory link.',
+      'The workspace handed a confirmed Agent-local memory link command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'memory-export') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory bundle export');
+    if (confirmation) return confirmation;
+    const parts = ['/memory', 'export', quoteSlashCommandArg(readField('path'))];
+    appendOptional(parts, '--scope', readField('scope'));
+    appendOptional(parts, '--cls', readField('class'));
+    parts.push('--yes');
+    return dispatch(
+      parts.join(' '),
+      'Opening Agent memory bundle export',
+      'Opening Agent memory bundle export.',
+      'The workspace handed a confirmed Agent-local memory export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'memory-import') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory bundle import');
+    if (confirmation) return confirmation;
+    const command = `/memory import ${quoteSlashCommandArg(readField('path'))} --yes`;
+    return dispatch(
+      command,
+      'Opening Agent memory bundle import',
+      'Opening Agent memory bundle import.',
+      'The workspace handed a confirmed Agent-local memory import command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'memory-handoff-export') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory handoff export');
+    if (confirmation) return confirmation;
+    const parts = ['/memory', 'handoff-export', quoteSlashCommandArg(readField('path'))];
+    appendOptional(parts, '--scope', readField('scope'));
+    parts.push('--yes');
+    return dispatch(
+      parts.join(' '),
+      'Opening Agent memory handoff export',
+      'Opening Agent memory handoff export.',
+      'The workspace handed a confirmed Agent-local memory handoff export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'memory-handoff-inspect') {
+    const command = `/memory handoff-inspect ${quoteSlashCommandArg(readField('path'))}`;
+    return dispatch(
+      command,
+      'Opening Agent memory handoff inspection',
+      'Opening Agent memory handoff inspection.',
+      'The workspace handed an Agent-local memory handoff inspection command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+
+  if (editor.kind === 'memory-handoff-import') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory handoff import');
+    if (confirmation) return confirmation;
+    const command = `/memory handoff-import ${quoteSlashCommandArg(readField('path'))} --yes`;
+    return dispatch(
+      command,
+      'Opening Agent memory handoff import',
+      'Opening Agent memory handoff import.',
+      'The workspace handed a confirmed Agent-local memory handoff import command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  const confirmation = requireConfirmation(editor, readField, 'Memory vector rebuild');
+  if (confirmation) return confirmation;
+  return dispatch(
+    '/memory vector rebuild',
+    'Opening Agent memory vector rebuild',
+    'Opening Agent memory vector rebuild.',
+    'The workspace handed a confirmed Agent-local memory vector rebuild command to the shell-owned command router.',
+    'safe',
+  );
+}

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

@@ -0,0 +1,180 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceMemoryCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'memory-search'
+  | 'memory-get'
+  | 'memory-explain'
+  | 'memory-promote'
+  | 'memory-link'
+  | 'memory-export'
+  | 'memory-import'
+  | 'memory-handoff-export'
+  | 'memory-handoff-inspect'
+  | 'memory-handoff-import'
+  | 'memory-vector-rebuild'
+>;
+
+export function isAgentWorkspaceMemoryCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMemoryCommandEditorKind {
+  return kind === 'memory-search'
+    || kind === 'memory-get'
+    || kind === 'memory-explain'
+    || kind === 'memory-promote'
+    || kind === 'memory-link'
+    || kind === 'memory-export'
+    || kind === 'memory-import'
+    || kind === 'memory-handoff-export'
+    || kind === 'memory-handoff-inspect'
+    || kind === 'memory-handoff-import'
+    || kind === 'memory-vector-rebuild';
+}
+
+export function createAgentWorkspaceMemoryCommandEditor(kind: AgentWorkspaceMemoryCommandEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'memory-search') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Search Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Search Agent-local memory only. This does not query default knowledge or other product routes.',
+      fields: [
+        { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional text query. Blank searches by filters.' },
+        { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional session, project, or team.' },
+        { id: 'class', label: 'Class', value: '', required: false, multiline: false, hint: 'Optional fact, constraint, pattern, runbook, risk, etc.' },
+        { id: 'limit', label: 'Limit', value: '', required: false, multiline: false, hint: 'Optional result limit.' },
+        { id: 'semantic', label: 'Semantic', value: 'no', required: false, multiline: false, hint: 'yes/no. Uses the local vector index when available.' },
+      ],
+    };
+  }
+  if (kind === 'memory-get') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Show one Agent-local memory record with provenance and links.',
+      fields: [
+        { id: 'id', label: 'Memory id', value: '', required: true, multiline: false, hint: 'Existing Agent memory id.' },
+      ],
+    };
+  }
+  if (kind === 'memory-explain') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Explain Memory Selection',
+      selectedFieldIndex: 0,
+      message: 'Preview which reviewed Agent-local memory records would be selected for a task.',
+      fields: [
+        { id: 'task', label: 'Task', value: '', required: true, multiline: true, hint: 'Task description. Ctrl-J inserts a new line.' },
+        { id: 'scopes', label: 'Scopes', value: '', required: false, multiline: false, hint: 'Optional comma-separated write scopes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-promote') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Promote Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Promote one Agent-local memory record to another scope. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'id', label: 'Memory id', value: '', required: true, multiline: false, hint: 'Existing Agent memory id.' },
+        { id: 'scope', label: 'Scope', value: '', required: true, multiline: false, hint: 'session, project, or team.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory promote with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-link') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Link Agent Memories',
+      selectedFieldIndex: 0,
+      message: 'Create one directed relation between two Agent-local memory records. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'fromId', label: 'From memory id', value: '', required: true, multiline: false, hint: 'Source memory id.' },
+        { id: 'toId', label: 'To memory id', value: '', required: true, multiline: false, hint: 'Target memory id.' },
+        { id: 'relation', label: 'Relation', value: '', required: true, multiline: false, hint: 'Short relation label, such as supports, supersedes, or contradicts.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory link with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-export') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Export Agent Memory Bundle',
+      selectedFieldIndex: 0,
+      message: 'Export Agent-local memory records and links to a reviewable JSON bundle. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Output path', value: 'agent-memory-bundle.json', required: true, multiline: false, hint: 'Workspace-relative JSON path to write.' },
+        { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional session, project, or team.' },
+        { id: 'class', label: 'Class', value: '', required: false, multiline: false, hint: 'Optional fact, constraint, pattern, runbook, risk, etc.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory export with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-import') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Import Agent Memory Bundle',
+      selectedFieldIndex: 0,
+      message: 'Import a reviewed Agent memory bundle into the Agent-local memory registry. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-bundle.json', required: true, multiline: false, hint: 'Workspace-relative JSON bundle path.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory import with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-export') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Export Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Export a scoped Agent memory handoff bundle for review. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Output path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON path to write.' },
+        { id: 'scope', label: 'Scope', value: 'team', required: false, multiline: false, hint: 'session, project, or team. Blank defaults to team.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory handoff-export with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-inspect') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Inspect Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Inspect a memory handoff bundle before importing it.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON handoff bundle path.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-import') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Import Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Import a reviewed memory handoff bundle into Agent-local memory. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON handoff bundle path.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory handoff-import with --yes.' },
+      ],
+    };
+  }
+  return {
+    kind,
+    mode: 'update',
+    title: 'Rebuild Memory Vector Index',
+    selectedFieldIndex: 0,
+    message: 'Rebuild the Agent-local memory vector index. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory vector rebuild.' },
+    ],
+  };
+}