@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

@@ -34,7 +34,7 @@ export async function submitAgentWorkspaceMemoryEditor(
       detail: detail.length > 0 ? detail : undefined,
       tags,
     });
-    if (!updated) throw new Error(`Unknown Agent memory: ${editor.recordId}`);
+    if (!updated) throw new Error(`Unknown Agent memory ${editor.recordId}`);
     return { record: updated, verb: 'Updated' };
   }
 
@@ -67,7 +67,7 @@ export function deleteAgentWorkspaceMemoryEditor(
   const expectedId = editor.recordId ?? '';
   if (!expectedId || confirmedId !== expectedId) return null;
   const removed = memory.delete(expectedId);
-  if (!removed) throw new Error(`Unknown Agent memory: ${expectedId}`);
+  if (!removed) throw new Error(`Unknown Agent memory ${expectedId}`);
   return { id: expectedId, name: expectedId };
 }
 

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

@@ -0,0 +1,81 @@
+import type { AgentWorkspaceAction, AgentWorkspaceCategory, AgentWorkspaceCategoryId, AgentWorkspaceFocusPane } from './agent-workspace-types.ts';
+
+interface AgentWorkspaceNavigationHost {
+  readonly categories: readonly AgentWorkspaceCategory[];
+  readonly actions: readonly AgentWorkspaceAction[];
+  focusPane: AgentWorkspaceFocusPane;
+  selectedCategoryIndex: number;
+  selectedActionIndex: number;
+  clampSelection(): void;
+}
+
+const AGENT_WORKSPACE_CATEGORY_ALIASES = {
+  connected: 'host',
+  'connected-host': 'host',
+  host: 'host',
+  mcp: 'tools',
+  tool: 'tools',
+  channel: 'channels',
+  voice: 'voice-media',
+  media: 'voice-media',
+  profile: 'profiles',
+  persona: 'personas',
+  skill: 'skills',
+  routine: 'routines',
+  schedule: 'automation',
+  schedules: 'automation',
+  plan: 'work',
+  planning: 'work',
+  task: 'host',
+  tasks: 'host',
+  note: 'notes',
+  scratchpad: 'notes',
+  kb: 'knowledge',
+} as const satisfies Readonly<Record<string, AgentWorkspaceCategoryId>>;
+
+type AgentWorkspaceCategoryAlias = keyof typeof AGENT_WORKSPACE_CATEGORY_ALIASES;
+
+function isAgentWorkspaceCategoryAlias(categoryIdOrLabel: string): categoryIdOrLabel is AgentWorkspaceCategoryAlias {
+  return Object.prototype.hasOwnProperty.call(AGENT_WORKSPACE_CATEGORY_ALIASES, categoryIdOrLabel);
+}
+
+function normalizeAgentWorkspaceCategoryRequest(categoryIdOrLabel: string): string {
+  const normalized = categoryIdOrLabel.trim().toLowerCase();
+  if (!normalized) return '';
+  return isAgentWorkspaceCategoryAlias(normalized) ? AGENT_WORKSPACE_CATEGORY_ALIASES[normalized] : normalized;
+}
+
+export function moveAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost, delta: -1 | 1): void {
+  if (host.focusPane === 'categories') {
+    host.selectedCategoryIndex = Math.max(0, Math.min(host.categories.length - 1, host.selectedCategoryIndex + delta));
+    host.selectedActionIndex = 0;
+  } else {
+    host.selectedActionIndex = Math.max(0, Math.min(host.actions.length - 1, host.selectedActionIndex + delta));
+  }
+  host.clampSelection();
+}
+
+export function jumpAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost, target: 'home' | 'end'): void {
+  if (host.focusPane === 'categories') {
+    host.selectedCategoryIndex = target === 'home' ? 0 : host.categories.length - 1;
+  } else {
+    host.selectedActionIndex = target === 'home' ? 0 : host.actions.length - 1;
+  }
+  host.clampSelection();
+}
+
+export function selectAgentWorkspaceCategory(host: AgentWorkspaceNavigationHost, categoryIdOrLabel: string): boolean {
+  const normalized = normalizeAgentWorkspaceCategoryRequest(categoryIdOrLabel);
+  if (!normalized) return false;
+  const categoryIndex = host.categories.findIndex((category) =>
+    category.id.toLowerCase() === normalized
+    || category.label.toLowerCase() === normalized
+    || category.label.toLowerCase().replace(/[^a-z0-9]+/g, '-') === normalized
+  );
+  if (categoryIndex < 0) return false;
+  host.selectedCategoryIndex = categoryIndex;
+  host.selectedActionIndex = 0;
+  host.focusPane = 'actions';
+  host.clampSelection();
+  return true;
+}

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

@@ -0,0 +1,121 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceNotifyEditorKind = 'notify-webhook' | 'notify-webhook-remove' | 'notify-webhook-clear' | 'notify-webhook-test' | 'notify-send';
+
+export type AgentWorkspaceNotifyEditorSubmission =
+  | {
+    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 isAgentWorkspaceNotifyEditorKind(kind: string): kind is AgentWorkspaceNotifyEditorKind {
+  return kind === 'notify-webhook'
+    || kind === 'notify-webhook-remove'
+    || kind === 'notify-webhook-clear'
+    || kind === 'notify-webhook-test'
+    || kind === 'notify-send';
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string, status: string): AgentWorkspaceNotifyEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status,
+  };
+}
+
+function dispatch(command: string, title: string, status: string, detail: string): AgentWorkspaceNotifyEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail,
+      command,
+      safety: 'safe',
+    },
+  };
+}
+
+export function buildAgentWorkspaceNotifyEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceNotifyEditorSubmission {
+  if (editor.kind === 'notify-webhook') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook add not confirmed. Type yes, then press Enter.', 'Notification webhook add not confirmed.');
+    }
+    const command = `/notify add ${quoteSlashCommandArg(readField('url'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification webhook add',
+      'Opening notification webhook add.',
+      'The workspace handed a confirmed notification target command to the shell-owned command router.',
+    );
+  }
+
+  if (editor.kind === 'notify-webhook-remove') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook remove not confirmed. Type yes, then press Enter.', 'Notification webhook remove not confirmed.');
+    }
+    const command = `/notify remove ${quoteSlashCommandArg(readField('url'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification webhook remove',
+      'Opening notification webhook remove.',
+      'The workspace handed a confirmed notification target remove command to the shell-owned command router.',
+    );
+  }
+
+  if (editor.kind === 'notify-webhook-clear') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook clear not confirmed. Type yes, then press Enter.', 'Notification webhook clear not confirmed.');
+    }
+    return dispatch(
+      '/notify clear --yes',
+      'Opening notification webhook clear',
+      'Opening notification webhook clear.',
+      'The workspace handed a confirmed notification target cleanup command to the shell-owned command router.',
+    );
+  }
+
+  if (editor.kind === 'notify-send') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification send not confirmed. Type yes, then press Enter.', 'Notification send not confirmed.');
+    }
+    const command = `/notify send ${quoteSlashCommandArg(readField('message'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification send',
+      'Opening notification send.',
+      'The workspace handed a confirmed notification send command to the shell-owned command router.',
+    );
+  }
+
+  if (!isAffirmative(readField('confirm'))) {
+    return unconfirmed(editor, 'Notification webhook test not confirmed. Type yes, then press Enter.', 'Notification webhook test not confirmed.');
+  }
+  return dispatch(
+    '/notify test --yes',
+    'Opening notification webhook test',
+    'Opening notification webhook test.',
+    'The workspace handed a confirmed notification test command to the shell-owned command router.',
+  );
+}

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

@@ -0,0 +1,208 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceOperationsCommandEditorKind } from './agent-workspace-operations-command-editors.ts';
+import { isAgentWorkspaceOperationsCommandEditorKind } from './agent-workspace-operations-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function optionalNoteArgs(value: string): string {
+  const trimmed = value.trim();
+  return trimmed ? ` --note ${quoteSlashCommandArg(trimmed)}` : '';
+}
+
+function optionalRememberArgs(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+  return isAffirmative(trimmed) ? ' --remember' : ' --no-remember';
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceOperationsCommandEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status: message,
+  };
+}
+
+export type AgentWorkspaceOperationsCommandEditorSubmission =
+  | {
+    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 isAgentWorkspaceOperationsCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceOperationsCommandEditorKind {
+  return isAgentWorkspaceOperationsCommandEditorKind(kind);
+}
+
+export function buildAgentWorkspaceOperationsCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceOperationsCommandEditorSubmission {
+  if (editor.kind === 'plan-seed') {
+    const command = `/plan ${quoteSlashCommandArg(readField('goal'))}`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening planning goal seeding.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening planning goal seeding',
+        detail: 'The workspace handed a concrete planning goal to the shell-owned command router without creating coding-role Agent jobs.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'plan-approve') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Planning approval not confirmed. Type yes, then press Enter.');
+    return {
+      kind: 'dispatch',
+      command: '/plan approve --yes',
+      status: 'Opening planning approval.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening planning approval',
+        detail: 'The workspace handed confirmed planning approval to the shell-owned command router.',
+        command: '/plan approve --yes',
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'plan-override') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Planning strategy override not confirmed. Type yes, then press Enter.');
+    const command = `/plan override ${quoteSlashCommandArg(readField('strategy'))} --yes`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening planning strategy override.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening planning strategy override',
+        detail: 'The workspace handed a confirmed planning strategy override to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'plan-clear') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Planning clear not confirmed. Type yes, then press Enter.');
+    return {
+      kind: 'dispatch',
+      command: '/plan clear --yes',
+      status: 'Opening planning clear.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening planning clear',
+        detail: 'The workspace handed confirmed planning-state clearing to the shell-owned command router.',
+        command: '/plan clear --yes',
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'approval-approve' || editor.kind === 'approval-deny' || editor.kind === 'approval-cancel') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Approval action not confirmed. Type yes, then press Enter.');
+    const verb = editor.kind.replace('approval-', '');
+    const command = `/approval ${verb} ${quoteSlashCommandArg(readField('approvalId'))}${optionalNoteArgs(readField('note'))}${optionalRememberArgs(readField('remember'))} --yes`;
+    const title = `${verb[0]?.toUpperCase() ?? ''}${verb.slice(1)} approval`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: `${title}.`,
+      actionResult: {
+        kind: 'dispatched',
+        title,
+        detail: 'The workspace handed an explicit confirmed approval action to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (
+    editor.kind === 'automation-job-run'
+    || editor.kind === 'automation-job-pause'
+    || editor.kind === 'automation-job-resume'
+    || editor.kind === 'automation-run-cancel'
+    || editor.kind === 'automation-run-retry'
+    || editor.kind === 'schedule-run'
+  ) {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Automation action not confirmed. Type yes, then press Enter.');
+    const command = editor.kind === 'automation-job-run'
+      ? `/automation job run ${quoteSlashCommandArg(readField('jobId'))} --yes`
+      : editor.kind === 'automation-job-pause'
+        ? `/automation job pause ${quoteSlashCommandArg(readField('jobId'))} --yes`
+        : editor.kind === 'automation-job-resume'
+          ? `/automation job resume ${quoteSlashCommandArg(readField('jobId'))} --yes`
+          : editor.kind === 'automation-run-cancel'
+            ? `/automation run cancel ${quoteSlashCommandArg(readField('runId'))} --yes`
+            : editor.kind === 'automation-run-retry'
+              ? `/automation run retry ${quoteSlashCommandArg(readField('runId'))} --yes`
+              : `/automation schedule run ${quoteSlashCommandArg(readField('scheduleId'))} --yes`;
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening confirmed automation action.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening confirmed automation action',
+        detail: 'The workspace handed an explicit connected-host automation action to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'routine-receipt' || editor.kind === 'schedule-receipt') {
+    const routine = editor.kind === 'routine-receipt';
+    const command = `/${routine ? 'routines' : 'schedule'} receipt ${quoteSlashCommandArg(readField('receiptId'))}`;
+    const title = routine ? 'Opening routine receipt' : 'Opening schedule receipt';
+    return {
+      kind: 'dispatch',
+      command,
+      status: `${title}.`,
+      actionResult: {
+        kind: 'dispatched',
+        title,
+        detail: routine
+          ? 'The workspace handed read-only routine receipt inspection to the shell-owned command router.'
+          : 'The workspace handed read-only schedule receipt inspection to the shell-owned command router.',
+        command,
+        safety: 'read-only',
+      },
+    };
+  }
+  const plan = editor.kind === 'plan-show';
+  const approval = editor.kind === 'approval-review';
+  const command = plan
+    ? `/plan show ${quoteSlashCommandArg(readField('planId'))}`
+    : approval
+      ? `/approval review ${quoteSlashCommandArg(readField('kind'))}`
+      : `/health repair ${quoteSlashCommandArg(readField('domain'))}`;
+  const title = plan ? 'Opening saved plan' : approval ? 'Opening approval review' : 'Opening health repair guidance';
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail: plan
+        ? 'The workspace handed read-only saved-plan inspection to the shell-owned command router.'
+        : approval
+          ? 'The workspace handed read-only approval class review to the shell-owned command router.'
+          : 'The workspace handed read-only health repair guidance to the shell-owned command router.',
+      command,
+      safety: 'read-only',
+    },
+  };
+}

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

@@ -0,0 +1,196 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceOperationsCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'plan-seed'
+  | 'plan-show'
+  | 'plan-approve'
+  | 'plan-override'
+  | 'plan-clear'
+  | 'health-repair'
+  | 'approval-review'
+  | 'approval-approve'
+  | 'approval-deny'
+  | 'approval-cancel'
+  | 'automation-job-run'
+  | 'automation-job-pause'
+  | 'automation-job-resume'
+  | 'automation-run-cancel'
+  | 'automation-run-retry'
+  | 'schedule-run'
+  | 'routine-receipt'
+  | 'schedule-receipt'
+>;
+
+export function isAgentWorkspaceOperationsCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceOperationsCommandEditorKind {
+  return kind === 'plan-seed'
+    || kind === 'plan-show'
+    || kind === 'plan-approve'
+    || kind === 'plan-override'
+    || kind === 'plan-clear'
+    || kind === 'health-repair'
+    || kind === 'approval-review'
+    || kind === 'approval-approve'
+    || kind === 'approval-deny'
+    || kind === 'approval-cancel'
+    || kind === 'automation-job-run'
+    || kind === 'automation-job-pause'
+    || kind === 'automation-job-resume'
+    || kind === 'automation-run-cancel'
+    || kind === 'automation-run-retry'
+    || kind === 'schedule-run'
+    || kind === 'routine-receipt'
+    || kind === 'schedule-receipt';
+}
+
+export function createAgentWorkspaceOperationsCommandEditor(kind: AgentWorkspaceOperationsCommandEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'plan-seed') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Seed Planning Goal',
+      selectedFieldIndex: 0,
+      message: 'Seed Agent planning state from a concrete goal. This stays in the main Agent planning flow and does not create coding-role Agent jobs.',
+      fields: [
+        { id: 'goal', label: 'Planning goal', value: '', required: true, multiline: true, hint: 'Describe the goal or operating plan to evaluate. Ctrl-J inserts a new line.' },
+      ],
+    };
+  }
+  if (kind === 'health-repair') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Health Repair Guidance',
+      selectedFieldIndex: 0,
+      message: 'Show health repair guidance for one domain. Agent does not manage connected-host hosting or mutate connected-host lifecycle.',
+      fields: [
+        { id: 'domain', label: 'Domain', value: 'settings', required: true, multiline: false, hint: 'settings, auth, accounts, host, remote, mcp, continuity, or maintenance.' },
+      ],
+    };
+  }
+  if (kind === 'approval-review') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Review Approval Class',
+      selectedFieldIndex: 0,
+      message: 'Review one approval class without approving, denying, or mutating pending requests.',
+      fields: [
+        { id: 'kind', label: 'Approval kind', value: 'shell', required: true, multiline: false, hint: 'shell, file, network, delegate, mcp, remote, hook, or plugin.' },
+      ],
+    };
+  }
+  if (kind === 'approval-approve' || kind === 'approval-deny' || kind === 'approval-cancel') {
+    const verb = kind === 'approval-approve' ? 'Approve' : kind === 'approval-deny' ? 'Deny' : 'Cancel';
+    return {
+      kind,
+      mode: 'update',
+      title: `${verb} Approval`,
+      selectedFieldIndex: 0,
+      message: `${verb} one pending connected-host approval request. This is an explicit operator action and requires typed confirmation.`,
+      fields: [
+        { id: 'approvalId', label: 'Approval id', value: '', required: true, multiline: false, hint: 'Approval request id from the approval list.' },
+        { id: 'note', label: 'Note', value: '', required: false, multiline: true, hint: 'Optional approval note. Ctrl-J inserts a new line.' },
+        { id: 'remember', label: 'Remember', value: '', required: false, multiline: false, hint: 'yes/no when you explicitly want to set the connected-host remember flag; blank leaves it unset.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: `Type yes to run /approval ${kind.replace('approval-', '')} with --yes.` },
+      ],
+    };
+  }
+  if (
+    kind === 'automation-job-run'
+    || kind === 'automation-job-pause'
+    || kind === 'automation-job-resume'
+    || kind === 'automation-run-cancel'
+    || kind === 'automation-run-retry'
+    || kind === 'schedule-run'
+  ) {
+    const job = kind.startsWith('automation-job-');
+    const run = kind.startsWith('automation-run-');
+    const label = job ? 'Job id' : run ? 'Run id' : 'Schedule id';
+    const field = job ? 'jobId' : run ? 'runId' : 'scheduleId';
+    const action = kind === 'automation-job-run'
+      ? 'Run Automation Job'
+      : kind === 'automation-job-pause'
+        ? 'Pause Automation Job'
+        : kind === 'automation-job-resume'
+          ? 'Resume Automation Job'
+          : kind === 'automation-run-cancel'
+            ? 'Cancel Automation Run'
+            : kind === 'automation-run-retry'
+              ? 'Retry Automation Run'
+              : 'Run Schedule';
+    return {
+      kind,
+      mode: 'update',
+      title: action,
+      selectedFieldIndex: 0,
+      message: `${action} through the connected host. This is never automatic and requires typed confirmation.`,
+      fields: [
+        { id: field, label, value: '', required: true, multiline: false, hint: `${label} from the Automation workspace list.` },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run the confirmed connected-host action with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'plan-approve') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Approve Planning State',
+      selectedFieldIndex: 0,
+      message: 'Approve the current Agent planning state for execution. This changes planning state and requires typed confirmation.',
+      fields: [
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /plan approve with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'plan-override') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Override Planning Strategy',
+      selectedFieldIndex: 0,
+      message: 'Override the planner strategy through the runtime bridge. This changes planner state and requires typed confirmation.',
+      fields: [
+        { id: 'strategy', label: 'Strategy', value: 'serial', required: true, multiline: false, hint: 'Planner strategy, such as serial.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /plan override with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'plan-clear') {
+    return {
+      kind,
+      mode: 'delete',
+      title: 'Clear Planning State',
+      selectedFieldIndex: 0,
+      message: 'Clear planner state. This is destructive and requires typed confirmation.',
+      fields: [
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /plan clear with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'routine-receipt' || kind === 'schedule-receipt') {
+    const routine = kind === 'routine-receipt';
+    return {
+      kind,
+      mode: 'create',
+      title: routine ? 'Show Routine Promotion Receipt' : 'Show Schedule Receipt',
+      selectedFieldIndex: 0,
+      message: routine
+        ? 'Show one local routine schedule-promotion receipt without reconciling or mutating connected schedules.'
+        : 'Show one local schedule receipt without reconciling or mutating connected schedules.',
+      fields: [
+        { id: 'receiptId', label: 'Receipt id', value: '', required: true, multiline: false, hint: 'Receipt id from Promotion receipts.' },
+      ],
+    };
+  }
+  return {
+    kind,
+    mode: 'create',
+    title: 'Show Saved Plan',
+    selectedFieldIndex: 0,
+    message: 'Show one saved execution plan by id or prefix without approving or starting execution.',
+    fields: [
+      { id: 'planId', label: 'Plan id', value: '', required: true, multiline: false, hint: 'Plan id or unique prefix from Saved plans.' },
+    ],
+  };
+}

package/src/input/agent-workspace-panel-route.ts

@@ -0,0 +1,43 @@
+import type { AgentWorkspaceCategoryId } from './agent-workspace-types.ts';
+
+const PANEL_CATEGORY_ROUTES = {
+  knowledge: 'knowledge',
+  memory: 'memory',
+  'work-plan': 'work',
+  'project-planning': 'work',
+  plan: 'work',
+  approval: 'work',
+  tasks: 'work',
+  'provider-health': 'setup',
+  automation: 'automation',
+  schedule: 'automation',
+  providers: 'setup',
+  accounts: 'setup',
+  subscription: 'setup',
+  cost: 'setup',
+  tokens: 'setup',
+  security: 'tools',
+  policy: 'tools',
+  tools: 'tools',
+  'qr-code': 'channels',
+  sessions: 'conversation',
+  context: 'conversation',
+  thinking: 'conversation',
+  'system-messages': 'conversation',
+  docs: 'home',
+  'panel-list': 'home',
+} as const satisfies Readonly<Record<string, AgentWorkspaceCategoryId>>;
+
+type AgentWorkspacePanelRouteId = keyof typeof PANEL_CATEGORY_ROUTES;
+
+function hasPanelCategoryRoute(panelId: string): panelId is AgentWorkspacePanelRouteId {
+  return Object.prototype.hasOwnProperty.call(PANEL_CATEGORY_ROUTES, panelId);
+}
+
+export function agentWorkspaceCategoryForPanel(panelId: string): AgentWorkspaceCategoryId {
+  return hasPanelCategoryRoute(panelId) ? PANEL_CATEGORY_ROUTES[panelId] : 'home';
+}
+
+export function agentWorkspaceCommandForPanel(panelId: string): string {
+  return `/agent ${agentWorkspaceCategoryForPanel(panelId)}`;
+}