@pellux/goodvibes-agent 1.1.7 → 1.3.0

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

@@ -0,0 +1,141 @@
+import type { AgentWorkspaceCategory } from './agent-workspace-types.ts';
+import { settingAction } from './agent-workspace-category-actions.ts';
+
+export const AGENT_WORKSPACE_ONBOARDING_DETAIL_CATEGORIES: readonly AgentWorkspaceCategory[] = [
+  {
+    id: 'onboarding-channels',
+    group: 'ONBOARDING',
+    label: 'Messaging',
+    summary: 'Choose remote channels, then fill only the fields for enabled channels.',
+    detail: 'Enable the channels you actually want. Channel credentials and default targets are saved as Agent settings or secret refs.',
+    actions: [
+      settingAction({ id: 'channel-ntfy-enabled', label: 'Use ntfy', detail: 'Toggle ntfy notifications and chat routing.', key: 'surfaces.ntfy.enabled' }),
+      settingAction({ id: 'channel-ntfy-base-url', label: 'ntfy base URL', detail: 'Set the ntfy server URL.', key: 'surfaces.ntfy.baseUrl', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-chat-topic', label: 'ntfy chat topic', detail: 'Set the topic routed into active terminal chat.', key: 'surfaces.ntfy.chatTopic', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-agent-topic', label: 'ntfy agent topic', detail: 'Set the topic routed to Agent work.', key: 'surfaces.ntfy.agentTopic', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-default-topic', label: 'ntfy default topic', detail: 'Set the default outbound notification topic.', key: 'surfaces.ntfy.topic', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-remote-topic', label: 'ntfy remote topic', detail: 'Set the daemon-owned remote chat topic.', key: 'surfaces.ntfy.remoteTopic', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-token', label: 'ntfy token', detail: 'Store the ntfy access token or secret reference.', key: 'surfaces.ntfy.token', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-ntfy-priority', label: 'ntfy priority', detail: 'Set default ntfy priority from 1 to 5.', key: 'surfaces.ntfy.defaultPriority', visibleWhenKey: 'surfaces.ntfy.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-slack-enabled', label: 'Use Slack', detail: 'Toggle Slack adapter configuration.', key: 'surfaces.slack.enabled' }),
+      settingAction({ id: 'channel-slack-bot-token', label: 'Slack bot token', detail: 'Store the Slack bot token or secret reference.', key: 'surfaces.slack.botToken', visibleWhenKey: 'surfaces.slack.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-slack-app-token', label: 'Slack app token', detail: 'Store the Slack app token or secret reference.', key: 'surfaces.slack.appToken', visibleWhenKey: 'surfaces.slack.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-slack-signing-secret', label: 'Slack signing secret', detail: 'Store the Slack signing secret or secret reference.', key: 'surfaces.slack.signingSecret', visibleWhenKey: 'surfaces.slack.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-slack-default-channel', label: 'Slack default channel', detail: 'Set the default Slack channel for notifications and replies.', key: 'surfaces.slack.defaultChannel', visibleWhenKey: 'surfaces.slack.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-slack-workspace', label: 'Slack workspace ID', detail: 'Set the Slack workspace id for route binding.', key: 'surfaces.slack.workspaceId', visibleWhenKey: 'surfaces.slack.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-discord-enabled', label: 'Use Discord', detail: 'Toggle Discord adapter configuration.', key: 'surfaces.discord.enabled' }),
+      settingAction({ id: 'channel-discord-bot-token', label: 'Discord bot token', detail: 'Store the Discord bot token or secret reference.', key: 'surfaces.discord.botToken', visibleWhenKey: 'surfaces.discord.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-discord-application', label: 'Discord application ID', detail: 'Set the Discord application id.', key: 'surfaces.discord.applicationId', visibleWhenKey: 'surfaces.discord.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-discord-public-key', label: 'Discord public key', detail: 'Set the Discord application public key.', key: 'surfaces.discord.publicKey', visibleWhenKey: 'surfaces.discord.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-discord-guild', label: 'Discord guild ID', detail: 'Set the default Discord guild id.', key: 'surfaces.discord.guildId', visibleWhenKey: 'surfaces.discord.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-discord-default-channel', label: 'Discord default channel', detail: 'Set the default Discord channel id.', key: 'surfaces.discord.defaultChannelId', visibleWhenKey: 'surfaces.discord.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-webhook-enabled', label: 'Use webhooks', detail: 'Toggle generic webhook delivery.', key: 'surfaces.webhook.enabled' }),
+      settingAction({ id: 'channel-webhook-target', label: 'Webhook target URL', detail: 'Set the default outbound webhook target URL.', key: 'surfaces.webhook.defaultTarget', visibleWhenKey: 'surfaces.webhook.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-webhook-secret', label: 'Webhook secret', detail: 'Store the shared webhook secret or secret reference.', key: 'surfaces.webhook.secret', visibleWhenKey: 'surfaces.webhook.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-webhook-timeout', label: 'Webhook timeout', detail: 'Set outbound webhook timeout in milliseconds.', key: 'surfaces.webhook.timeoutMs', visibleWhenKey: 'surfaces.webhook.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-telegram-enabled', label: 'Use Telegram', detail: 'Toggle Telegram bot delivery.', key: 'surfaces.telegram.enabled' }),
+      settingAction({ id: 'channel-telegram-bot-token', label: 'Telegram bot token', detail: 'Store the Telegram bot token or secret reference.', key: 'surfaces.telegram.botToken', visibleWhenKey: 'surfaces.telegram.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-telegram-bot-username', label: 'Telegram bot username', detail: 'Set the Telegram bot username.', key: 'surfaces.telegram.botUsername', visibleWhenKey: 'surfaces.telegram.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-telegram-chat', label: 'Telegram chat ID', detail: 'Set the default Telegram chat, group, or channel id.', key: 'surfaces.telegram.defaultChatId', visibleWhenKey: 'surfaces.telegram.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-telegram-mode', label: 'Telegram mode', detail: 'Cycle webhook or polling ingress mode.', key: 'surfaces.telegram.mode', visibleWhenKey: 'surfaces.telegram.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-telegram-webhook-secret', label: 'Telegram webhook secret', detail: 'Store the Telegram webhook secret or secret reference.', key: 'surfaces.telegram.webhookSecret', visibleWhenKey: 'surfaces.telegram.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-googlechat-enabled', label: 'Use Google Chat', detail: 'Toggle Google Chat delivery.', key: 'surfaces.googleChat.enabled' }),
+      settingAction({ id: 'channel-googlechat-webhook', label: 'Google Chat webhook', detail: 'Set the Google Chat webhook or app callback URL.', key: 'surfaces.googleChat.webhookUrl', visibleWhenKey: 'surfaces.googleChat.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-googlechat-space', label: 'Google Chat space', detail: 'Set the default Google Chat space id.', key: 'surfaces.googleChat.spaceId', visibleWhenKey: 'surfaces.googleChat.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-googlechat-app-id', label: 'Google Chat app ID', detail: 'Set the Google Chat app id.', key: 'surfaces.googleChat.appId', visibleWhenKey: 'surfaces.googleChat.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-googlechat-verification', label: 'Google Chat verification', detail: 'Store the Google Chat verification token or secret reference.', key: 'surfaces.googleChat.verificationToken', visibleWhenKey: 'surfaces.googleChat.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-enabled', label: 'Use home automation', detail: 'Toggle home automation conversation and event delivery.', key: 'surfaces.homeassistant.enabled' }),
+      settingAction({ id: 'channel-homeassistant-url', label: 'Home automation URL', detail: 'Set the home automation instance URL.', key: 'surfaces.homeassistant.instanceUrl', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-token', label: 'Home automation token', detail: 'Store the home automation access token or secret reference.', key: 'surfaces.homeassistant.accessToken', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-webhook-secret', label: 'Home automation webhook secret', detail: 'Store the shared secret used to verify inbound callbacks.', key: 'surfaces.homeassistant.webhookSecret', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-conversation', label: 'Home automation conversation', detail: 'Set the default conversation id.', key: 'surfaces.homeassistant.defaultConversationId', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-device-id', label: 'Home automation device ID', detail: 'Set the stable device id exposed to the home automation surface.', key: 'surfaces.homeassistant.deviceId', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-device-name', label: 'Home automation device name', detail: 'Set the device display name exposed to the home automation surface.', key: 'surfaces.homeassistant.deviceName', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-event-type', label: 'Home automation event type', detail: 'Set the event type used for daemon-to-home automation delivery.', key: 'surfaces.homeassistant.eventType', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-homeassistant-session-ttl', label: 'Home automation session TTL', detail: 'Set the idle TTL for remote home automation conversation sessions.', key: 'surfaces.homeassistant.remoteSessionTtlMs', visibleWhenKey: 'surfaces.homeassistant.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-signal-enabled', label: 'Use Signal', detail: 'Toggle Signal bridge delivery.', key: 'surfaces.signal.enabled' }),
+      settingAction({ id: 'channel-signal-bridge', label: 'Signal bridge URL', detail: 'Set the Signal bridge base URL.', key: 'surfaces.signal.bridgeUrl', visibleWhenKey: 'surfaces.signal.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-signal-account', label: 'Signal account', detail: 'Set the Signal account id or phone number.', key: 'surfaces.signal.account', visibleWhenKey: 'surfaces.signal.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-signal-token', label: 'Signal token', detail: 'Store the Signal bridge token or secret reference.', key: 'surfaces.signal.token', visibleWhenKey: 'surfaces.signal.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-signal-recipient', label: 'Signal recipient', detail: 'Set the default Signal recipient or group.', key: 'surfaces.signal.defaultRecipient', visibleWhenKey: 'surfaces.signal.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-enabled', label: 'Use WhatsApp', detail: 'Toggle WhatsApp delivery.', key: 'surfaces.whatsapp.enabled' }),
+      settingAction({ id: 'channel-whatsapp-provider', label: 'WhatsApp provider', detail: 'Cycle Meta Cloud API or bridge provider mode.', key: 'surfaces.whatsapp.provider', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-token', label: 'WhatsApp access token', detail: 'Store the WhatsApp provider access token or secret reference.', key: 'surfaces.whatsapp.accessToken', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-phone-id', label: 'WhatsApp phone number ID', detail: 'Set the WhatsApp phone number id.', key: 'surfaces.whatsapp.phoneNumberId', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-business-id', label: 'WhatsApp business ID', detail: 'Set the WhatsApp business account id.', key: 'surfaces.whatsapp.businessAccountId', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-verify', label: 'WhatsApp verify token', detail: 'Store the WhatsApp verify token or secret reference.', key: 'surfaces.whatsapp.verifyToken', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-signing', label: 'WhatsApp signing secret', detail: 'Store the WhatsApp signing secret or secret reference.', key: 'surfaces.whatsapp.signingSecret', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-whatsapp-recipient', label: 'WhatsApp recipient', detail: 'Set the default WhatsApp recipient or chat id.', key: 'surfaces.whatsapp.defaultRecipient', visibleWhenKey: 'surfaces.whatsapp.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-imessage-enabled', label: 'Use iMessage', detail: 'Toggle iMessage bridge delivery.', key: 'surfaces.imessage.enabled' }),
+      settingAction({ id: 'channel-imessage-bridge', label: 'iMessage bridge URL', detail: 'Set the iMessage bridge base URL.', key: 'surfaces.imessage.bridgeUrl', visibleWhenKey: 'surfaces.imessage.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-imessage-account', label: 'iMessage account', detail: 'Set the iMessage account id.', key: 'surfaces.imessage.account', visibleWhenKey: 'surfaces.imessage.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-imessage-token', label: 'iMessage token', detail: 'Store the iMessage bridge token or secret reference.', key: 'surfaces.imessage.token', visibleWhenKey: 'surfaces.imessage.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'channel-imessage-chat', label: 'iMessage chat ID', detail: 'Set the default iMessage chat id.', key: 'surfaces.imessage.defaultChatId', visibleWhenKey: 'surfaces.imessage.enabled', visibleWhenValue: true }),
+    ],
+  },
+  {
+    id: 'onboarding-voice-media',
+    group: 'ONBOARDING',
+    label: 'Voice & Phone',
+    summary: 'Configure voice controls, spoken output, and SMS or phone-call delivery.',
+    detail: 'Use this page for saved voice/TTS settings and telephony credentials. Generating media is available later from Voice & Media.',
+    actions: [
+      settingAction({ id: 'voice-enabled', label: 'Use voice controls', detail: 'Toggle the optional local voice control surface.', key: 'ui.voiceEnabled' }),
+      settingAction({ id: 'voice-tts-provider', label: 'TTS provider', detail: 'Set the default text-to-speech provider id.', key: 'tts.provider' }),
+      settingAction({ id: 'voice-tts-voice', label: 'TTS voice', detail: 'Set the default text-to-speech voice id.', key: 'tts.voice' }),
+      settingAction({ id: 'telephony-enabled', label: 'Use telephony', detail: 'Toggle SMS, voice call, or telephony bridge delivery.', key: 'surfaces.telephony.enabled' }),
+      settingAction({ id: 'telephony-provider', label: 'Telephony provider', detail: 'Cycle direct provider or bridge mode.', key: 'surfaces.telephony.provider', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-mode', label: 'Telephony mode', detail: 'Cycle SMS, voice call, or bridge delivery mode.', key: 'surfaces.telephony.mode', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-bridge-url', label: 'Telephony bridge URL', detail: 'Set the telephony bridge base URL.', key: 'surfaces.telephony.bridgeUrl', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-token', label: 'Telephony bridge token', detail: 'Store the telephony bridge token or secret reference.', key: 'surfaces.telephony.token', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-account-sid', label: 'Twilio account SID', detail: 'Set the Twilio account SID for provider-direct delivery.', key: 'surfaces.telephony.accountSid', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-auth-token', label: 'Twilio auth token', detail: 'Store the Twilio auth token or secret reference.', key: 'surfaces.telephony.authToken', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-from', label: 'Sender phone number', detail: 'Set the default caller or sender phone number.', key: 'surfaces.telephony.fromNumber', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-recipient', label: 'Recipient phone number', detail: 'Set the default telephony recipient number.', key: 'surfaces.telephony.defaultRecipient', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-webhook-secret', label: 'Telephony webhook secret', detail: 'Store the shared telephony webhook secret or secret reference.', key: 'surfaces.telephony.webhookSecret', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'telephony-voice-language', label: 'Voice language', detail: 'Set the BCP-47 language code for voice-call text-to-speech.', key: 'surfaces.telephony.voiceLanguage', visibleWhenKey: 'surfaces.telephony.enabled', visibleWhenValue: true }),
+    ],
+  },
+  {
+    id: 'onboarding-context',
+    group: 'ONBOARDING',
+    label: 'Local Context',
+    summary: 'Create/import memory, personas, skills, routines, notes, and Knowledge.',
+    detail: 'Use this page to seed the assistant with durable local context. These forms create Agent-owned records or ingest reviewed sources.',
+    actions: [
+      { id: 'context-vibe-status', label: 'Inspect VIBE.md', detail: 'Show project/global VIBE.md personality files, blocked files, and init paths before relying on a custom assistant feel.', kind: 'guidance', safety: 'read-only' },
+      { id: 'context-project-files', label: 'Inspect project context', detail: 'List secret-scanned .hermes.md, HERMES.md, AGENTS.md, CLAUDE.md, SOUL.md, and Cursor context files with blocked/truncated status.', kind: 'guidance', safety: 'read-only' },
+      { id: 'context-project-file', label: 'Inspect one context file', detail: 'Inspect one loaded or blocked project context file by id, target, or query through the read-only context-file control.', kind: 'guidance', safety: 'read-only' },
+      { id: 'context-prompt-context', label: 'Prompt context', detail: 'Inspect the applied prompt context order, selected memory/persona/skill/routine records, suppressed context, and approximate token budget.', kind: 'guidance', safety: 'read-only' },
+      { id: 'context-profile-from-discovered', label: 'Profile from discovered files', detail: 'Create an isolated Agent profile from reviewed local persona, skill, and routine files.', editorKind: 'profile-from-discovered', kind: 'editor', safety: 'safe' },
+      { id: 'context-persona-discovery', label: 'Import persona files', detail: 'Import discovered persona files into the Agent persona registry.', editorKind: 'persona-discovery-import', kind: 'editor', safety: 'safe' },
+      { id: 'context-skill-discovery', label: 'Import skill files', detail: 'Import discovered skill files into the Agent skill registry.', editorKind: 'skill-discovery-import', kind: 'editor', safety: 'safe' },
+      { id: 'context-routine-discovery', label: 'Import routine files', detail: 'Import discovered routine files into the Agent routine registry.', editorKind: 'routine-discovery-import', kind: 'editor', safety: 'safe' },
+      { id: 'context-create-persona', label: 'Create persona', detail: 'Create and optionally activate an Agent-local persona.', editorKind: 'persona', kind: 'editor', safety: 'safe' },
+      { id: 'context-create-memory', label: 'Create starter memory', detail: 'Create one durable local memory record.', editorKind: 'memory', kind: 'editor', safety: 'safe' },
+      { id: 'context-create-skill', label: 'Create skill', detail: 'Create one reusable Agent-local skill.', editorKind: 'skill', kind: 'editor', safety: 'safe' },
+      { id: 'context-create-routine', label: 'Create routine', detail: 'Create one reusable Agent-local routine.', editorKind: 'routine', kind: 'editor', safety: 'safe' },
+      { id: 'context-create-note', label: 'Create note', detail: 'Create one Agent-local scratchpad note.', editorKind: 'note', kind: 'editor', safety: 'safe' },
+      { id: 'context-knowledge-url', label: 'Ingest URL', detail: 'Ingest a reviewed URL into isolated Agent Knowledge after confirmation.', editorKind: 'knowledge-url', kind: 'editor', safety: 'safe' },
+      { id: 'context-knowledge-file', label: 'Ingest file', detail: 'Ingest a local file into isolated Agent Knowledge after confirmation.', editorKind: 'knowledge-file', kind: 'editor', safety: 'safe' },
+      { id: 'context-knowledge-bookmarks', label: 'Import bookmarks', detail: 'Import a browser bookmark export into isolated Agent Knowledge.', editorKind: 'knowledge-bookmarks', kind: 'editor', safety: 'safe' },
+      { id: 'context-knowledge-browser-history', label: 'Import browser history', detail: 'Import local browser history or bookmarks into isolated Agent Knowledge.', editorKind: 'knowledge-browser-history', kind: 'editor', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'onboarding-automation',
+    group: 'ONBOARDING',
+    label: 'Automation Setup',
+    summary: 'Set scheduled work limits for reminders and routines.',
+    detail: 'Use this page to enable automation and set bounded run limits. Creating actual reminders and routines remains a separate confirmed action.',
+    actions: [
+      settingAction({ id: 'automation-enabled', label: 'Use automation', detail: 'Toggle the automation subsystem for reminders and scheduled routines.', key: 'automation.enabled' }),
+      settingAction({ id: 'automation-max-concurrent', label: 'Concurrent runs', detail: 'Set the maximum automation runs that can execute concurrently.', key: 'automation.maxConcurrentRuns', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'automation-history-limit', label: 'Run history limit', detail: 'Set the number of run history entries retained per automation job.', key: 'automation.runHistoryLimit', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'automation-default-timeout', label: 'Default timeout', detail: 'Set the default automation run timeout in milliseconds.', key: 'automation.defaultTimeoutMs', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'automation-catch-up', label: 'Catch-up window', detail: 'Set how long startup should catch up missed automation runs.', key: 'automation.catchUpWindowMinutes', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'automation-failure-cooldown', label: 'Failure cooldown', detail: 'Set the cooldown after a failed automation run.', key: 'automation.failureCooldownMs', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+      settingAction({ id: 'automation-delete-after-run', label: 'Delete one-shot jobs', detail: 'Toggle deleting one-shot automation jobs after their first successful run.', key: 'automation.deleteAfterRun', visibleWhenKey: 'automation.enabled', visibleWhenValue: true }),
+    ],
+  },
+];

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

@@ -20,6 +20,11 @@ function optionalRememberArgs(value: string): string {
   return isAffirmative(trimmed) ? ' --remember' : ' --no-remember';
 }
 
+function optionalCommandArg(flag: string, value: string): string {
+  const trimmed = value.trim();
+  return trimmed ? ` ${flag} ${quoteSlashCommandArg(trimmed)}` : '';
+}
+
 function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceOperationsCommandEditorSubmission {
   return {
     kind: 'editor',
@@ -162,6 +167,54 @@ export function buildAgentWorkspaceOperationsCommandEditorSubmission(
       },
     };
   }
+  if (editor.kind === 'schedule-edit') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Schedule edit not confirmed. Type yes, then press Enter.');
+    const scheduleKind = readField('scheduleKind').trim();
+    const scheduleValue = readField('scheduleValue').trim();
+    if ((scheduleKind && !scheduleValue) || (!scheduleKind && scheduleValue)) {
+      return unconfirmed(editor, 'Schedule type and schedule value must be set together.');
+    }
+    const hasChange = Boolean(
+      scheduleKind
+      || readField('timezone').trim()
+      || readField('scheduleName').trim()
+      || readField('task').trim()
+      || readField('successCriteria').trim()
+      || readField('prompt').trim(),
+    );
+    if (!hasChange) return unconfirmed(editor, 'Schedule edit needs at least one changed field.');
+    const task = readField('task').trim();
+    const successCriteria = readField('successCriteria').trim();
+    if ((task && !successCriteria) || (!task && successCriteria)) {
+      return unconfirmed(editor, 'Task and success criteria must be set together.');
+    }
+    if (readField('prompt').trim() && task) {
+      return unconfirmed(editor, 'Use either Exact prompt or Task, not both.');
+    }
+    const command = [
+      '/schedule edit',
+      quoteSlashCommandArg(readField('scheduleId')),
+      scheduleKind && scheduleValue ? `--${scheduleKind} ${quoteSlashCommandArg(scheduleValue)}` : '',
+      optionalCommandArg('--timezone', readField('timezone')).trim(),
+      optionalCommandArg('--name', readField('scheduleName')).trim(),
+      optionalCommandArg('--task', readField('task')).trim(),
+      optionalCommandArg('--success-criteria', readField('successCriteria')).trim(),
+      optionalCommandArg('--prompt', readField('prompt')).trim(),
+      '--yes',
+    ].filter(Boolean).join(' ');
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening confirmed schedule edit.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening confirmed schedule edit',
+        detail: 'The workspace handed an explicit connected-host schedule edit 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'))}`;

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

@@ -18,6 +18,7 @@ export type AgentWorkspaceOperationsCommandEditorKind = Extract<
   | 'automation-run-cancel'
   | 'automation-run-retry'
   | 'schedule-run'
+  | 'schedule-edit'
   | 'routine-receipt'
   | 'schedule-receipt'
 >;
@@ -39,6 +40,7 @@ export function isAgentWorkspaceOperationsCommandEditorKind(kind: AgentWorkspace
     || kind === 'automation-run-cancel'
     || kind === 'automation-run-retry'
     || kind === 'schedule-run'
+    || kind === 'schedule-edit'
     || kind === 'routine-receipt'
     || kind === 'schedule-receipt';
 }
@@ -131,6 +133,26 @@ export function createAgentWorkspaceOperationsCommandEditor(kind: AgentWorkspace
       ],
     };
   }
+  if (kind === 'schedule-edit') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Edit Schedule',
+      selectedFieldIndex: 0,
+      message: 'Edit one connected-host schedule name, cadence, or prompt. This requires typed confirmation and never creates a hidden local job.',
+      fields: [
+        { id: 'scheduleId', label: 'Schedule id', value: '', required: true, multiline: false, hint: 'Schedule id from List schedules or the autonomy queue.' },
+        { id: 'scheduleKind', label: 'Schedule type', value: '', required: false, multiline: false, hint: 'Optional. at, every, or cron. Leave blank to keep cadence.' },
+        { id: 'scheduleValue', label: 'Schedule value', value: '', required: false, multiline: false, hint: 'Required with Schedule type. Examples: 0 9 * * *, 7d, or an ISO timestamp.' },
+        { id: 'timezone', label: 'Timezone', value: '', required: false, multiline: false, hint: 'Optional IANA timezone for cron schedules, for example America/Chicago.' },
+        { id: 'scheduleName', label: 'Schedule name', value: '', required: false, multiline: false, hint: 'Optional replacement display name.' },
+        { id: 'task', label: 'Task', value: '', required: false, multiline: true, hint: 'Optional replacement autonomous task. Ctrl-J inserts a new line.' },
+        { id: 'successCriteria', label: 'Success criteria', value: '', required: false, multiline: true, hint: 'Required with Task so scheduled runs know what success means.' },
+        { id: 'prompt', label: 'Exact prompt', value: '', required: false, multiline: true, hint: 'Optional exact prompt replacement. Do not combine with Task.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /schedule edit with --yes.' },
+      ],
+    };
+  }
   if (kind === 'plan-approve') {
     return {
       kind,

package/src/input/agent-workspace-research-report-editor.ts

@@ -0,0 +1,212 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+const SECRETISH = /token|secret|password|authorization|credential|api[-_]?key/i;
+
+export interface AgentResearchReportWorkspaceToolArgs {
+  readonly title: string;
+  readonly question: string;
+  readonly summary?: string;
+  readonly reportMarkdown?: string;
+  readonly sources: readonly {
+    readonly title: string;
+    readonly url?: string;
+    readonly credibility?: string;
+    readonly note?: string;
+  }[];
+  readonly findings?: readonly string[];
+  readonly gaps?: readonly string[];
+  readonly recommendations?: readonly string[];
+  readonly methodology?: string;
+  readonly confidence?: string;
+  readonly requireCitationCoverage?: boolean;
+  readonly visualReport?: boolean;
+  readonly tags?: readonly string[];
+  readonly confirm: true;
+  readonly explicitUserRequest: string;
+}
+
+function splitList(value: string): readonly string[] {
+  return value
+    .split(/\n/)
+    .map((entry) => entry.replace(/^[-*]\s+/, '').trim())
+    .filter(Boolean);
+}
+
+function splitTags(value: string): readonly string[] {
+  return value.split(/[,\n]/).map((entry) => entry.trim()).filter(Boolean);
+}
+
+function isAffirmative(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'yes' || normalized === 'true';
+}
+
+function sanitizeSourceUrl(value: string): string {
+  try {
+    const url = new URL(value);
+    for (const key of [...url.searchParams.keys()]) {
+      if (SECRETISH.test(key)) url.searchParams.set(key, '<redacted>');
+    }
+    return url.toString();
+  } catch {
+    return value.replace(/([?&\s](?:token|secret|password|authorization|credential|api[-_]?key)=)[^\s&]+/gi, '$1<redacted>');
+  }
+}
+
+function parseSources(value: string): AgentResearchReportWorkspaceToolArgs['sources'] {
+  return splitList(value).map((line) => {
+    const parts = line.split('|').map((part) => part.trim()).filter(Boolean);
+    const urlIndex = parts.findIndex((part) => /^https?:\/\//i.test(part));
+    const url = urlIndex >= 0 ? parts[urlIndex] : '';
+    const detailStart = urlIndex >= 0 ? urlIndex + 1 : 1;
+    const nonUrlParts = parts.filter((_, index) => index !== urlIndex);
+    const title = urlIndex === 0 ? (nonUrlParts.length > 1 ? nonUrlParts[0] : url) : (parts[0] ?? url ?? line);
+    const noteParts = parts.slice(detailStart + 1);
+    return {
+      title: title || line,
+      ...(url ? { url: sanitizeSourceUrl(url) } : {}),
+      ...(parts[detailStart] ? { credibility: parts[detailStart] } : {}),
+      ...(noteParts.length > 0 ? { note: noteParts.join(' | ') } : {}),
+    };
+  });
+}
+
+export function createAgentResearchReportEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'research-report',
+    mode: 'create',
+    title: 'Save Research Report',
+    selectedFieldIndex: 0,
+    message: 'Save a reviewed source-grounded report artifact with citation coverage and a visual report packet. Sources are required; this does not ingest knowledge.',
+    fields: [
+      { id: 'title', label: 'Title', value: '', required: true, multiline: false, hint: 'Short report title.' },
+      { id: 'question', label: 'Question', value: '', required: true, multiline: true, hint: 'The research question this report answers.' },
+      { id: 'summary', label: 'Summary', value: '', required: false, multiline: true, hint: 'Optional executive summary.' },
+      { id: 'reportMarkdown', label: 'Report markdown', value: '', required: false, multiline: true, hint: 'Full reviewed report body. Use [S1], [S2], etc. for citations when possible.' },
+      { id: 'sources', label: 'Sources', value: '', required: true, multiline: true, hint: 'One per line: title | https://source | high/medium/low | note.' },
+      { id: 'findings', label: 'Findings', value: '', required: false, multiline: true, hint: 'Optional one finding per line.' },
+      { id: 'gaps', label: 'Gaps', value: '', required: false, multiline: true, hint: 'Optional caveats or unresolved questions, one per line.' },
+      { id: 'recommendations', label: 'Recommendations', value: '', required: false, multiline: true, hint: 'Optional next actions, one per line.' },
+      { id: 'methodology', label: 'Method', value: '', required: false, multiline: true, hint: 'How sources were found, filtered, and judged.' },
+      { id: 'confidence', label: 'Confidence', value: 'medium', required: false, multiline: false, hint: 'Overall confidence such as high, medium, low, or mixed.' },
+      { id: 'visualReport', label: 'Visual packet', value: 'yes', required: false, multiline: false, hint: 'Type yes to add at-a-glance, evidence matrix, findings board, dated sources, and handoff checklist sections.' },
+      { id: 'requireCitationCoverage', label: 'Require citations', value: '', required: false, multiline: false, hint: 'Type yes to require every listed source to be cited as [S1], [S2], etc. in the report body.' },
+      { id: 'tags', label: 'Tags', value: 'research', required: false, multiline: false, hint: 'Comma-separated optional artifact tags.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to save this report as an artifact.' },
+    ],
+  };
+}
+
+export function buildAgentResearchReportToolArgs(
+  readField: AgentWorkspaceFieldReader,
+  explicitUserRequest: string,
+): AgentResearchReportWorkspaceToolArgs {
+  const summary = readField('summary').trim();
+  const reportMarkdown = readField('reportMarkdown').trim();
+  const findings = splitList(readField('findings'));
+  const gaps = splitList(readField('gaps'));
+  const recommendations = splitList(readField('recommendations'));
+  const methodology = readField('methodology').trim();
+  const confidence = readField('confidence').trim();
+  const visualReport = isAffirmative(readField('visualReport'));
+  const requireCitationCoverage = isAffirmative(readField('requireCitationCoverage'));
+  const tags = splitTags(readField('tags'));
+  return {
+    title: readField('title').trim(),
+    question: readField('question').trim(),
+    ...(summary ? { summary } : {}),
+    ...(reportMarkdown ? { reportMarkdown } : {}),
+    sources: parseSources(readField('sources')),
+    ...(findings.length > 0 ? { findings } : {}),
+    ...(gaps.length > 0 ? { gaps } : {}),
+    ...(recommendations.length > 0 ? { recommendations } : {}),
+    ...(methodology ? { methodology } : {}),
+    ...(confidence ? { confidence } : {}),
+    ...(visualReport ? { visualReport } : {}),
+    ...(requireCitationCoverage ? { requireCitationCoverage } : {}),
+    ...(tags.length > 0 ? { tags } : {}),
+    confirm: true,
+    explicitUserRequest,
+  };
+}
+
+export function buildAgentResearchReportPromptSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  promptDispatchAvailable: boolean,
+): {
+  readonly kind: 'editor';
+  readonly editor: AgentWorkspaceLocalEditor;
+  readonly status: string;
+  readonly actionResult?: AgentWorkspaceActionResult;
+} | {
+  readonly kind: 'prompt';
+  readonly prompt: string;
+  readonly status: string;
+  readonly actionResult: AgentWorkspaceActionResult;
+} {
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Type yes to confirm saving this sourced report as an artifact.' },
+      status: 'Research report save not confirmed.',
+    };
+  }
+
+  if (!promptDispatchAvailable) {
+    return {
+      kind: 'editor',
+      editor: {
+        ...editor,
+        message: 'Prompt dispatch is unavailable in this runtime. Use agent_harness mode:"run_workspace_action" with this editor schema.',
+      },
+      status: 'Prompt dispatch unavailable.',
+      actionResult: {
+        kind: 'error',
+        title: 'Prompt dispatch unavailable',
+        detail: 'This runtime cannot submit research report saving from the workspace form.',
+        safety: 'safe',
+      },
+    };
+  }
+
+  const args = buildAgentResearchReportToolArgs(
+    readField,
+    'Save a reviewed source-grounded research report as an Agent artifact.',
+  );
+  const prompt = [
+    'Save this reviewed source-grounded research report as an Agent artifact.',
+    'Use the `research` tool with these arguments:',
+    'action: "report"',
+    `title: ${JSON.stringify(args.title)}`,
+    `question: ${JSON.stringify(args.question)}`,
+    args.summary ? `summary: ${JSON.stringify(args.summary)}` : 'summary: none',
+    args.reportMarkdown ? `reportMarkdown: ${JSON.stringify(args.reportMarkdown)}` : 'reportMarkdown: none',
+    `sources: ${JSON.stringify(args.sources)}`,
+    args.findings ? `findings: ${JSON.stringify(args.findings)}` : 'findings: none',
+    args.gaps ? `gaps: ${JSON.stringify(args.gaps)}` : 'gaps: none',
+    args.recommendations ? `recommendations: ${JSON.stringify(args.recommendations)}` : 'recommendations: none',
+    args.methodology ? `methodology: ${JSON.stringify(args.methodology)}` : 'methodology: none',
+    args.confidence ? `confidence: ${JSON.stringify(args.confidence)}` : 'confidence: none',
+    args.visualReport ? 'visualReport: true' : 'visualReport: false',
+    args.requireCitationCoverage ? 'requireCitationCoverage: true' : 'requireCitationCoverage: false',
+    args.tags ? `tags: ${JSON.stringify(args.tags)}` : 'tags: none',
+    'confirm: true',
+    `explicitUserRequest: ${JSON.stringify(args.explicitUserRequest)}`,
+    'Policy: save a sourced report artifact with optional visual packet only; do not ingest knowledge or send external messages.',
+  ].join('\n');
+
+  return {
+    kind: 'prompt',
+    prompt,
+    status: 'Submitting research report artifact request.',
+    actionResult: {
+      kind: 'guidance',
+      title: 'Research report artifact',
+      detail: 'Submitted a confirmed request to save a reviewed source-grounded report artifact with visual packet.',
+      safety: 'safe',
+    },
+  };
+}

package/src/input/agent-workspace-research-run-editor.ts

@@ -0,0 +1,144 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export interface AgentResearchRunWorkspaceToolArgs {
+  readonly mode: 'create';
+  readonly title: string;
+  readonly question: string;
+  readonly goal?: string;
+  readonly plan?: readonly string[];
+  readonly nextSteps?: readonly string[];
+  readonly sourceIds?: readonly string[];
+  readonly note?: string;
+  readonly confirm: true;
+  readonly explicitUserRequest: string;
+}
+
+function splitList(value: string): readonly string[] {
+  return value
+    .split(/[\n,]/)
+    .map((entry) => entry.replace(/^[-*]\s+/, '').trim())
+    .filter(Boolean);
+}
+
+function isAffirmative(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'yes' || normalized === 'true';
+}
+
+export function createAgentResearchRunEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'research-run',
+    mode: 'create',
+    title: 'Start Research Run',
+    selectedFieldIndex: 0,
+    message: 'Create a visible checkpointable research run. This records local run state only; web research, source review, reports, and Knowledge ingest stay separate.',
+    fields: [
+      { id: 'title', label: 'Title', value: '', required: true, multiline: false, hint: 'Short name for this research run.' },
+      { id: 'question', label: 'Question', value: '', required: true, multiline: true, hint: 'Research question the run should answer.' },
+      { id: 'goal', label: 'Goal', value: '', required: false, multiline: true, hint: 'User-visible outcome. Defaults to the question.' },
+      { id: 'plan', label: 'Plan', value: '', required: false, multiline: true, hint: 'One research step per line. Ctrl-J inserts a new line.' },
+      { id: 'nextSteps', label: 'Next steps', value: '', required: false, multiline: true, hint: 'Immediate next actions to keep the run resumable.' },
+      { id: 'sourceIds', label: 'Source ids', value: '', required: false, multiline: false, hint: 'Optional comma-separated local source ids already known.' },
+      { id: 'note', label: 'Note', value: '', required: false, multiline: true, hint: 'Optional context, caveat, or initial checkpoint note.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to create the visible local run.' },
+    ],
+  };
+}
+
+export function buildAgentResearchRunToolArgs(
+  readField: AgentWorkspaceFieldReader,
+  explicitUserRequest: string,
+): AgentResearchRunWorkspaceToolArgs {
+  const goal = readField('goal').trim();
+  const plan = splitList(readField('plan'));
+  const nextSteps = splitList(readField('nextSteps'));
+  const sourceIds = splitList(readField('sourceIds'));
+  const note = readField('note').trim();
+  return {
+    mode: 'create',
+    title: readField('title').trim(),
+    question: readField('question').trim(),
+    ...(goal ? { goal } : {}),
+    ...(plan.length > 0 ? { plan } : {}),
+    ...(nextSteps.length > 0 ? { nextSteps } : {}),
+    ...(sourceIds.length > 0 ? { sourceIds } : {}),
+    ...(note ? { note } : {}),
+    confirm: true,
+    explicitUserRequest,
+  };
+}
+
+export function buildAgentResearchRunPromptSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  promptDispatchAvailable: boolean,
+): {
+  readonly kind: 'editor';
+  readonly editor: AgentWorkspaceLocalEditor;
+  readonly status: string;
+  readonly actionResult?: AgentWorkspaceActionResult;
+} | {
+  readonly kind: 'prompt';
+  readonly prompt: string;
+  readonly status: string;
+  readonly actionResult: AgentWorkspaceActionResult;
+} {
+  if (!isAffirmative(readField('confirm'))) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Type yes to create this visible local research run.' },
+      status: 'Research run creation not confirmed.',
+    };
+  }
+
+  if (!promptDispatchAvailable) {
+    return {
+      kind: 'editor',
+      editor: {
+        ...editor,
+        message: 'Prompt dispatch is unavailable in this runtime. Use research action:"create_run" with these fields.',
+      },
+      status: 'Prompt dispatch unavailable.',
+      actionResult: {
+        kind: 'error',
+        title: 'Prompt dispatch unavailable',
+        detail: 'This runtime cannot submit research run creation from the workspace form.',
+        safety: 'safe',
+      },
+    };
+  }
+
+  const args = buildAgentResearchRunToolArgs(
+    readField,
+    'Create one visible checkpointable local research run.',
+  );
+  const prompt = [
+    'Create this visible checkpointable local research run.',
+    'Use the `research` tool with these arguments:',
+    'action: "create_run"',
+    `title: ${JSON.stringify(args.title)}`,
+    `question: ${JSON.stringify(args.question)}`,
+    args.goal ? `goal: ${JSON.stringify(args.goal)}` : 'goal: none',
+    args.plan ? `plan: ${JSON.stringify(args.plan)}` : 'plan: none',
+    args.nextSteps ? `nextSteps: ${JSON.stringify(args.nextSteps)}` : 'nextSteps: none',
+    args.sourceIds ? `sourceIds: ${JSON.stringify(args.sourceIds)}` : 'sourceIds: none',
+    args.note ? `note: ${JSON.stringify(args.note)}` : 'note: none',
+    'confirm: true',
+    `explicitUserRequest: ${JSON.stringify(args.explicitUserRequest)}`,
+    'Policy: local visible run state only; do not perform web research, save a report, ingest Knowledge, or send external messages.',
+  ].join('\n');
+
+  return {
+    kind: 'prompt',
+    prompt,
+    status: 'Submitting research run creation request.',
+    actionResult: {
+      kind: 'guidance',
+      title: 'Research run',
+      detail: 'Submitted a request to create a visible checkpointable local research run.',
+      safety: 'safe',
+    },
+  };
+}