@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/input/agent-workspace-calendar-connect-editor.ts

@@ -0,0 +1,116 @@
+/**
+ * Calendar connect card (W4-A5) — promotes the "Calendar workflows" workspace
+ * card from a dead guidance card into a real, dispatchable action.
+ *
+ * GROUNDED: unlike email, there is no external calendar account/CalDAV
+ * connector anywhere in this codebase (no config schema, no credential path,
+ * no service — /calendar is a purely local .ics-backed event store,
+ * src/agent/calendar-registry.ts + src/input/commands/calendar-runtime.ts).
+ * Building a credential-capturing "connect wizard" for a service that does
+ * not exist would repeat exactly the dogfood finding this brief fixes
+ * (advertising a capability that isn't dispatchable). The honest promotion
+ * is: a real stepped form that adds a LOCAL calendar event through the
+ * existing, already-safe /calendar add command — no credentials involved —
+ * with the card's own wording stating plainly that this is local-only.
+ *
+ * This follows the ordinary generic command-editor pattern (like
+ * agent-workspace-reminder-schedule-editor.ts): build one command string,
+ * dispatch it through the shell-owned command router. No secret ever touches
+ * this path, so the command-string leak class documented in
+ * agent-workspace-email-connect-editor.ts does not apply here.
+ */
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { isAffirmative } from './agent-workspace-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type FieldReader = (fieldId: string) => string;
+
+export type AgentCalendarConnectEditorSubmission =
+  | {
+    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 createCalendarConnectEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'calendar-connect',
+    mode: 'create',
+    title: 'Add Calendar Event',
+    selectedFieldIndex: 0,
+    message: 'No external calendar account is connected in this build (no CalDAV/Google/Outlook sync) — this adds an event to your local Agent calendar. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'title', label: 'Title', value: '', required: true, multiline: false, hint: 'Event title.' },
+      { id: 'start', label: 'Start', value: '', required: true, multiline: false, hint: 'ISO date or datetime, for example 2026-08-01T09:00:00-05:00.' },
+      { id: 'end', label: 'End', value: '', required: false, multiline: false, hint: 'Optional ISO end date or datetime.' },
+      { id: 'location', label: 'Location', value: '', required: false, multiline: false, hint: 'Optional location.' },
+      { id: 'notes', label: 'Notes', value: '', required: false, multiline: true, hint: 'Optional notes. Ctrl-J inserts a new line.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /calendar add with --yes.' },
+    ],
+  };
+}
+
+export function buildAgentWorkspaceCalendarConnectEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: FieldReader,
+  commandDispatchAvailable: boolean,
+): AgentCalendarConnectEditorSubmission {
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Type yes to confirm adding this calendar event.' },
+      status: 'Calendar event not confirmed.',
+    };
+  }
+  if (!commandDispatchAvailable) {
+    const detail = 'Command dispatch is unavailable; cannot add a calendar event from this workspace.';
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: detail },
+      status: detail,
+      actionResult: { kind: 'error', title: 'Command dispatch unavailable', detail, safety: 'safe' },
+    };
+  }
+
+  const title = readField('title').trim();
+  const start = readField('start').trim();
+  if (!title || !start) {
+    const detail = 'Title and start are required.';
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: detail },
+      status: detail,
+      actionResult: { kind: 'error', title: 'Calendar event incomplete', detail, safety: 'safe' },
+    };
+  }
+
+  const parts = ['/calendar', 'add', '--title', quoteSlashCommandArg(title), '--start', quoteSlashCommandArg(start)];
+  const end = readField('end').trim();
+  if (end.length > 0) parts.push('--end', quoteSlashCommandArg(end));
+  const location = readField('location').trim();
+  if (location.length > 0) parts.push('--location', quoteSlashCommandArg(location));
+  const notes = readField('notes').trim();
+  if (notes.length > 0) parts.push('--notes', quoteSlashCommandArg(notes));
+  parts.push('--yes');
+  const command = parts.join(' ');
+
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Adding calendar event.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Adding calendar event',
+      detail: 'The workspace handed a confirmed local calendar event command to the shell-owned command router. This is a local calendar only — no external account is connected.',
+      command,
+      safety: 'safe',
+    },
+  };
+}

package/src/input/agent-workspace-calendar-oauth-editor.ts

@@ -0,0 +1,152 @@
+/**
+ * Calendar OAuth advanced-credentials wizard (W4-A10).
+ *
+ * The DEFAULT connect experience needs no card at all: `/calendar connect google`
+ * (or `outlook`) uses the bundled project client id + PKCE and opens the browser.
+ * This card is the ADVANCED override for power users who register their own app: it
+ * captures a client id and (optionally) a client secret, stores them the same way
+ * every other Agent credential is stored (id in config, secret through the secret
+ * manager, never in plain config, never in a command string), then directs the user
+ * to run the connect command to authorize.
+ *
+ * Security: like the email connect wizard, this is a DIRECT host action, not a slash
+ * command — the client secret never travels through the command-dispatch pipeline
+ * that echoes the command string into the rendered result. The OAuth network dance
+ * (auth URL / device code) lives in the /calendar connect command, which can print
+ * the URL/code immediately; this card only persists credentials.
+ */
+import type { CommandContext } from './command-registry.ts';
+import { isAffirmative } from './agent-workspace-editors.ts';
+import { requireSecretsManager } from './commands/runtime-services.ts';
+import { persistSecretBackedConfigValue } from '../config/secret-config.ts';
+import type { ConfigKey } from '../config/index.ts';
+import {
+  CALENDAR_OAUTH_CLIENT_ID_KEYS,
+  CALENDAR_OAUTH_CLIENT_SECRET_KEYS,
+  ensureCalendarConfigDefaults,
+} from '../agent/calendar/calendar-oauth-service.ts';
+import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+type FieldReader = (id: string) => string;
+type Provider = 'google' | 'microsoft';
+
+export interface AgentWorkspaceCalendarOAuthEditorHost {
+  localEditor: AgentWorkspaceLocalEditor | null;
+  status: string;
+  lastActionResult: AgentWorkspaceActionResult | null;
+}
+
+/** Honest, no-I/O calendar-OAuth build state per provider — true once a client id override is stored (F1c). */
+export interface AgentWorkspaceCalendarOAuthConfigStatus {
+  readonly google: boolean;
+  readonly microsoft: boolean;
+}
+
+const PROVIDER_LABEL: Record<Provider, string> = { google: 'Google Calendar', microsoft: 'Microsoft Outlook' };
+const CONNECT_HINT: Record<Provider, string> = { google: '/calendar connect google', microsoft: '/calendar connect outlook' };
+
+/**
+ * Build-state-aware card message (F1c): while the build still ships only the
+ * bundled SDK placeholder client id, /calendar connect always fails at the
+ * config stage, so the old "most people can skip this" wording was a dead
+ * end. Once a client id has been stored (through this same card), the
+ * original skip-this-if-you-don't-need-it wording applies again.
+ */
+function cardMessage(label: string, isConfigured: boolean): string {
+  if (!isConfigured) {
+    return (
+      `This build needs a client id to connect ${label} — it ships no project default yet. ` +
+      'Enter your own below, or follow these steps: register a free OAuth app with the provider ' +
+      '(Google Cloud Console, or the Azure portal for Microsoft), copy the client id it gives you ' +
+      '(no client secret needed for the desktop/public-client flow), then paste it in here. ' +
+      'A client secret (only for a confidential-client registration) is stored through the Agent ' +
+      'secret manager and never shown again.'
+    );
+  }
+  return (
+    `Advanced: use your OWN registered ${label} app instead of the bundled default. ` +
+    'Most people can skip this and just run the connect command. The client id is not a ' +
+    'secret; a client secret (only for a confidential-client registration) is stored through ' +
+    'the Agent secret manager and never shown again.'
+  );
+}
+
+/** The advanced-credentials wizard for one provider. */
+export function createCalendarOAuthEditor(provider: Provider, isConfigured = false): AgentWorkspaceLocalEditor {
+  const label = PROVIDER_LABEL[provider];
+  const kind: AgentWorkspaceEditorKind = provider === 'google' ? 'calendar-oauth-google' : 'calendar-oauth-outlook';
+  return {
+    kind,
+    mode: 'create',
+    title: `Connect ${label} (advanced)`,
+    selectedFieldIndex: 0,
+    message: cardMessage(label, isConfigured),
+    fields: [
+      { id: 'clientId', label: 'Client ID', value: '', required: true, multiline: false, hint: `Your ${label} OAuth client id (Desktop/public client needs no secret).` },
+      { id: 'clientSecret', label: 'Client secret (optional)', value: '', required: false, multiline: false, hint: 'Only for a confidential-client app. Stored through the secret manager, masked here.', redact: true },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: `Type yes to store these credentials, then run ${CONNECT_HINT[provider]} to authorize.` },
+    ],
+  };
+}
+
+export async function submitAgentWorkspaceCalendarOAuthEditor(
+  host: AgentWorkspaceCalendarOAuthEditorHost,
+  editor: AgentWorkspaceLocalEditor,
+  context: CommandContext | null,
+  readField: FieldReader,
+): Promise<void> {
+  const provider: Provider = editor.kind === 'calendar-oauth-outlook' ? 'microsoft' : 'google';
+  const label = PROVIDER_LABEL[provider];
+
+  if (!isAffirmative(readField('confirm'))) {
+    host.localEditor = { ...editor, message: 'Credentials not confirmed. Type yes, then press Enter.' };
+    host.status = 'Calendar credentials not confirmed.';
+    return;
+  }
+  if (!context) {
+    host.localEditor = { ...editor, message: 'This runtime has no command context; cannot store credentials.' };
+    host.status = 'Calendar connect unavailable.';
+    host.lastActionResult = { kind: 'error', title: 'Calendar connect unavailable', detail: 'No command context is available in this runtime.', safety: 'safe' };
+    return;
+  }
+
+  const clientId = readField('clientId').trim();
+  if (!clientId) {
+    host.localEditor = { ...editor, message: 'A client id is required for the advanced path.' };
+    host.status = 'Client id is required.';
+    return;
+  }
+
+  try {
+    const secretsManager = requireSecretsManager(context);
+    ensureCalendarConfigDefaults(context.platform.configManager);
+    const cm = context.platform.configManager as unknown as {
+      get: (key: ConfigKey) => unknown;
+      setDynamic: (key: ConfigKey, value: unknown) => void;
+      save: () => void;
+    };
+    // Client id is not a secret — a plain config value.
+    cm.setDynamic(CALENDAR_OAUTH_CLIENT_ID_KEYS[provider] as unknown as ConfigKey, clientId);
+    // Client secret (if any) goes through the secret-backed path: a ref in config,
+    // the raw value only in the secret manager.
+    const secret = readField('clientSecret');
+    if (secret.trim().length > 0) {
+      await persistSecretBackedConfigValue(cm, secretsManager, CALENDAR_OAUTH_CLIENT_SECRET_KEYS[provider] as unknown as ConfigKey, secret);
+    }
+    cm.save();
+
+    host.localEditor = null;
+    host.status = `${label} credentials stored.`;
+    host.lastActionResult = {
+      kind: 'refreshed',
+      title: `${label} credentials stored`,
+      detail: `Your ${label} client id was saved${secret.trim() ? ' (and the client secret through the secret manager)' : ''}. Run ${CONNECT_HINT[provider]} to open the browser and authorize.`,
+      safety: 'safe',
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    host.localEditor = { ...editor, message: detail };
+    host.status = detail;
+    host.lastActionResult = { kind: 'error', title: 'Calendar credentials not stored', detail, safety: 'safe' };
+  }
+}

package/src/input/agent-workspace-calendar-subscribe-editor.ts

@@ -0,0 +1,128 @@
+/**
+ * Calendar subscribe wizard (W4-A9) — the "Calendar workflows" card's real
+ * connect flow. Subscribes to an external calendar by its iCalendar feed URL
+ * (Google "secret address", Outlook published .ics, or any .ics URL), READ-ONLY.
+ *
+ * Security: the feed URL is secrets-adjacent — a Google secret address grants
+ * read access to the whole calendar — so this follows the email-connect wizard's
+ * pattern EXACTLY: it is a DIRECT host action (not a slash-command string), so the
+ * URL never flows through the generic dispatch pipeline that echoes command text
+ * back into the workspace UI (which would render the secret). The URL is persisted
+ * ONLY through the secret manager (CalendarSubscriptionRegistry stores it under a
+ * per-subscription secret key; the on-disk store holds the key, never the URL) and
+ * the field is masked (`redact: true`). Validation fetches the feed BEFORE saving
+ * and names the failing stage honestly (fetch vs parse); the URL/name are kept so
+ * nothing is retyped.
+ */
+import type { CommandContext } from './command-registry.ts';
+import { isAffirmative } from './agent-workspace-editors.ts';
+import { subscriptionRegistryForWrite } from './commands/calendar-subscription-runtime.ts';
+import type { CalendarSubscriptionRegistry } from '../agent/calendar-subscription-registry.ts';
+import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
+
+type FieldReader = (id: string) => string;
+
+export interface AgentWorkspaceCalendarSubscribeEditorHost {
+  localEditor: AgentWorkspaceLocalEditor | null;
+  runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null;
+  status: string;
+  lastActionResult: AgentWorkspaceActionResult | null;
+}
+
+/** Fields in wizard-step order. The URL is masked and secrets-adjacent. */
+export function createCalendarSubscribeWizardEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'calendar-subscribe-wizard',
+    mode: 'create',
+    title: 'Subscribe to a Calendar',
+    selectedFieldIndex: 0,
+    message: [
+      'Subscribe to an external calendar by its iCalendar (.ics) feed URL — read-only, merged into /calendar.',
+      'Google: Settings → your calendar → "Secret address in iCal format" — copy that URL.',
+      'Outlook: Settings → Calendar → Shared calendars → Publish → copy the ICS link.',
+      'Any .ics URL works too. The URL is stored through the Agent secret manager (a secret address grants read access), and validated by fetching before it is saved.',
+    ].join('\n'),
+    fields: [
+      { id: 'url', label: 'Feed URL', value: '', required: true, multiline: false, hint: 'The .ics feed URL. Stored as a secret; masked here and never rendered in results.', redact: true },
+      { id: 'name', label: 'Name', value: '', required: false, multiline: false, hint: 'Optional. Left blank, the calendar\'s own name is used.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to validate the feed and subscribe.' },
+    ],
+  };
+}
+
+/** Injectable for tests — production callers omit it and get the real registry (real HTTP fetch). */
+export type CalendarSubscribeRegistryBuilder = (context: CommandContext) => CalendarSubscriptionRegistry | null;
+
+const defaultRegistryBuilder: CalendarSubscribeRegistryBuilder = (context) => subscriptionRegistryForWrite(context);
+
+export async function submitAgentWorkspaceCalendarSubscribeWizardEditor(
+  host: AgentWorkspaceCalendarSubscribeEditorHost,
+  editor: AgentWorkspaceLocalEditor,
+  context: CommandContext | null,
+  readField: FieldReader,
+  buildRegistry: CalendarSubscribeRegistryBuilder = defaultRegistryBuilder,
+): Promise<void> {
+  if (!isAffirmative(readField('confirm'))) {
+    host.localEditor = { ...editor, message: 'Calendar subscription not confirmed. Type yes, then press Enter.' };
+    host.status = 'Calendar subscription not confirmed.';
+    return;
+  }
+  if (!context) {
+    const detail = 'This runtime has no command context; cannot subscribe to a calendar.';
+    host.localEditor = { ...editor, message: detail };
+    host.status = 'Calendar subscribe unavailable.';
+    host.lastActionResult = { kind: 'error', title: 'Calendar subscribe unavailable', detail, safety: 'safe' };
+    return;
+  }
+
+  const url = readField('url').trim();
+  if (!url) {
+    const detail = 'A feed URL is required.';
+    host.localEditor = { ...editor, message: detail };
+    host.status = detail;
+    host.lastActionResult = { kind: 'error', title: 'Calendar subscribe incomplete', detail, safety: 'safe' };
+    return;
+  }
+  const requestedName = readField('name').trim() || undefined;
+
+  try {
+    const registry = buildRegistry(context);
+    if (!registry) {
+      const detail = 'No secret manager is available in this runtime, and a feed URL is stored only as a secret. Cannot subscribe.';
+      host.localEditor = { ...editor, message: detail };
+      host.status = 'Calendar subscribe unavailable.';
+      host.lastActionResult = { kind: 'error', title: 'Calendar subscribe unavailable', detail, safety: 'safe' };
+      return;
+    }
+
+    const result = await registry.subscribe(url, requestedName);
+    if (!result.ok) {
+      // Settings kept so the URL/name are not retyped; the stage is named honestly.
+      host.localEditor = { ...editor, message: `Could not subscribe (${result.stage} stage): ${result.detail}` };
+      host.status = `Calendar subscription failed (${result.stage}).`;
+      host.lastActionResult = {
+        kind: 'error',
+        title: 'Calendar subscription failed',
+        detail: `Could not subscribe at the ${result.stage} stage: ${result.detail}. The URL was not saved — fix it above and try again.`,
+        safety: 'safe',
+      };
+      return;
+    }
+
+    host.localEditor = null;
+    host.status = `Subscribed to ${result.name}.`;
+    host.lastActionResult = {
+      kind: 'refreshed',
+      title: 'Calendar subscribed',
+      detail: `Subscribed to '${result.name}' (${result.eventCount} events, refresh every ${Math.round(result.refreshIntervalMs / 60000)} min). These events are read-only and appear source-labeled in /calendar.`,
+      safety: 'safe',
+    };
+    host.runtimeSnapshot = buildAgentWorkspaceRuntimeSnapshot(context);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    host.localEditor = { ...editor, message: detail };
+    host.status = detail;
+    host.lastActionResult = { kind: 'error', title: 'Calendar subscribe failed', detail, safety: 'safe' };
+  }
+}

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

@@ -2,6 +2,7 @@ import type { AgentWorkspaceCategory } from './agent-workspace-types.ts';
 import { settingAction } from './agent-workspace-category-actions.ts';
 import { AGENT_WORKSPACE_HOST_CATEGORY } from './agent-workspace-host-category.ts';
 import { AGENT_WORKSPACE_ONBOARDING_DETAIL_CATEGORIES } from './agent-workspace-onboarding-categories.ts';
+import { THEME_MODE_CONFIG_KEY } from '../renderer/theme-mode-config.ts';
 
 export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
   {
@@ -134,6 +135,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       settingAction({ id: 'display-stream', label: 'Stream tokens', detail: 'Toggle streaming assistant tokens as they arrive.', key: 'display.stream' }),
       settingAction({ id: 'display-theme', label: 'Theme', detail: 'Set the color theme name.', key: 'display.theme' }),
+      settingAction({ id: 'display-theme-mode', label: 'Theme mode', detail: 'Cycle auto, dark, or light for the terminal background. Forced dark/light apply immediately; switching to auto takes effect on the next launch, when it re-probes the terminal.', key: THEME_MODE_CONFIG_KEY }),
       settingAction({ id: 'display-line-numbers', label: 'Line numbers', detail: 'Cycle all, code-only, or off for assistant output line numbers.', key: 'display.lineNumbers' }),
       settingAction({ id: 'display-collapse-threshold', label: 'Collapse threshold', detail: 'Set the line count threshold for collapsed tool output.', key: 'display.collapseThreshold' }),
       settingAction({ id: 'display-token-speed', label: 'Token speed counter', detail: 'Toggle tokens-per-second while generating.', key: 'display.showTokenSpeed' }),
@@ -156,8 +158,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'personal-ops-queue', label: 'Review queue', detail: 'List saved inbox thread and calendar event review items, refreshable provider-read routes, and follow-up confirmation boundaries with personal_ops action:"queue".', kind: 'guidance', safety: 'read-only' },
       { id: 'personal-ops-intake', label: 'Request planner', detail: 'Use personal_ops action:"intake" query:"..." to turn an inbox, agenda, task, reminder, note, routine, or delivery request into the safest visible route.', kind: 'guidance', safety: 'read-only' },
       { id: 'personal-ops-autonomy-queue', label: 'Autonomy queue', detail: 'Inspect visible ongoing work, owners, status, and cancel or recovery routes before creating more background work.', kind: 'guidance', safety: 'read-only' },
-      { id: 'personal-ops-inbox', label: 'Inbox workflows', detail: 'Email inbox triage and draft review use workflow cards with reviewed connector routes and explicit send boundaries.', kind: 'guidance', safety: 'safe' },
-      { id: 'personal-ops-calendar', label: 'Calendar workflows', detail: 'Calendar agenda and conflict checks use workflow cards with reviewed connector routes; reminders stay on confirmed schedules.', kind: 'guidance', safety: 'safe' },
+      { id: 'personal-ops-inbox', label: 'Inbox workflows', detail: 'Connect your inbox (IMAP/SMTP) to enable email triage and draft review. Opens a stepped connect wizard; credentials are stored through the Agent secret manager.', editorKind: 'email-connect-wizard', kind: 'editor', safety: 'safe' },
+      { id: 'personal-ops-calendar', label: 'Subscribe to a calendar', detail: 'Subscribe to an external calendar by its iCalendar (.ics) feed URL — Google "Secret address in iCal format", an Outlook published ICS link, or any .ics URL. Read-only, validated by fetching, merged into /calendar. The URL is stored through the Agent secret manager.', editorKind: 'calendar-subscribe-wizard', kind: 'editor', safety: 'safe' },
+      { id: 'personal-ops-calendar-add', label: 'Add calendar event', detail: 'Add an event to the local Agent calendar with a stepped form (no external account required).', editorKind: 'calendar-connect', kind: 'editor', safety: 'safe' },
+      { id: 'personal-ops-calendar-google', label: 'Connect Google Calendar (advanced)', detail: 'Full two-way sync via OAuth. Default path: just run /calendar connect google (bundled app + PKCE). This card is the advanced override to use your OWN Google OAuth client id; a client secret is stored through the Agent secret manager.', editorKind: 'calendar-oauth-google', kind: 'editor', safety: 'safe' },
+      { id: 'personal-ops-calendar-outlook', label: 'Connect Microsoft Outlook (advanced)', detail: 'Full two-way sync via OAuth. Default path: just run /calendar connect outlook (bundled app + PKCE). This card is the advanced override to use your OWN Microsoft app registration; a client secret is stored through the Agent secret manager.', editorKind: 'calendar-oauth-outlook', kind: 'editor', safety: 'safe' },
       { id: 'personal-ops-notes', label: 'Scratchpad notes', detail: 'Open Agent-local notes for source triage, decisions, and handoff context.', targetCategoryId: 'notes', kind: 'workspace', safety: 'safe' },
       { id: 'personal-ops-note-create', label: 'Create note', detail: 'Capture temporary context as an Agent-local scratchpad note.', editorKind: 'note', kind: 'editor', safety: 'safe' },
       { id: 'personal-ops-reminder', label: 'Create reminder', detail: 'Create one connected reminder schedule with real timing, optional delivery target, and explicit confirmation.', editorKind: 'reminder-schedule', kind: 'editor', safety: 'safe' },

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

@@ -1,39 +1,20 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import type { AgentWorkspaceChannelCommandEditorKind } from './agent-workspace-channel-command-editors.ts';
 import { isAgentWorkspaceChannelCommandEditorKind } from './agent-workspace-channel-command-editors.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceCommandSubmissionHandler, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { buildCommandEditorSubmissionFromTable, dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceChannelCommandEditorSubmission =
-  | {
-    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 type AgentWorkspaceChannelCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceChannelCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceChannelCommandEditorKind {
   return isAgentWorkspaceChannelCommandEditorKind(kind);
 }
 
-export function buildAgentWorkspaceChannelCommandEditorSubmission(
-  editor: AgentWorkspaceLocalEditor,
-  readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceChannelCommandEditorSubmission {
-  if (editor.kind === 'channel-send') {
-    if (!/^(y|yes|true)$/i.test(readField('confirm').trim())) {
-      return {
-        kind: 'editor',
-        editor: { ...editor, message: 'Channel delivery not confirmed. Type yes, then press Enter.' },
-        status: 'Channel delivery not confirmed.',
-      };
+const CHANNEL_COMMAND_SUBMISSION_HANDLERS: Readonly<Record<AgentWorkspaceChannelCommandEditorKind, AgentWorkspaceCommandSubmissionHandler>> = {
+  'channel-send': (editor, readField) => {
+    if (!isAffirmative(readField('confirm'))) {
+      return editorMessageSubmission(editor, 'Channel delivery not confirmed. Type yes, then press Enter.', 'Channel delivery not confirmed.');
     }
     const parts = ['/channels', 'send'];
     const title = readField('title');
@@ -47,20 +28,19 @@ export function buildAgentWorkspaceChannelCommandEditorSubmission(
     if (webhook) parts.push('--webhook', quoteSlashCommandArg(webhook));
     if (link) parts.push('--link', quoteSlashCommandArg(link));
     parts.push('--message', quoteSlashCommandArg(readField('message')), '--yes');
-    const command = parts.join(' ');
-    return {
-      kind: 'dispatch',
-      command,
-      status: 'Opening channel delivery.',
-      actionResult: {
-        kind: 'dispatched',
-        title: 'Opening channel delivery',
-        detail: 'The workspace handed a confirmed channel delivery command to the shell-owned command router.',
-        command,
-        safety: 'safe',
-      },
-    };
-  }
+    return dispatchCommandEditorSubmission(
+      parts.join(' '),
+      'Opening channel delivery',
+      'The workspace handed a confirmed channel delivery command to the shell-owned command router.',
+      'safe',
+    );
+  },
+  'channel-doctor': (editor, readField) => channelInspection(editor, readField),
+  'channel-setup': (editor, readField) => channelInspection(editor, readField),
+  'channel-show': (editor, readField) => channelInspection(editor, readField),
+};
+
+function channelInspection(editor: AgentWorkspaceLocalEditor, readField: AgentWorkspaceFieldReader): AgentWorkspaceCommandEditorSubmission {
   const subcommand = editor.kind === 'channel-doctor' ? 'doctor' : editor.kind === 'channel-setup' ? 'setup' : 'show';
   const command = `/channels ${subcommand} ${quoteSlashCommandArg(readField('channel'))}`;
   const title = editor.kind === 'channel-doctor'
@@ -68,16 +48,22 @@ export function buildAgentWorkspaceChannelCommandEditorSubmission(
     : editor.kind === 'channel-setup'
       ? 'Opening channel setup guidance'
       : 'Opening channel detail';
-  return {
-    kind: 'dispatch',
+  return dispatchCommandEditorSubmission(
     command,
-    status: `${title}.`,
-    actionResult: {
-      kind: 'dispatched',
-      title,
-      detail: 'The workspace handed read-only channel inspection to the shell-owned command router.',
-      command,
-      safety: 'read-only',
-    },
-  };
+    title,
+    'The workspace handed read-only channel inspection to the shell-owned command router.',
+    'read-only',
+  );
+}
+
+export function buildAgentWorkspaceChannelCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceCommandEditorSubmission {
+  return buildCommandEditorSubmissionFromTable(
+    editor.kind as AgentWorkspaceChannelCommandEditorKind,
+    editor,
+    readField,
+    CHANNEL_COMMAND_SUBMISSION_HANDLERS,
+  );
 }