vellum 0.2.1 → 0.2.7

package/src/config/vellum-skills/telegram-setup/SKILL.md

@@ -98,8 +98,4 @@ Summarize what was done:
 - Bot commands registered: /new
 - Credentials stored securely in the vault
 
-Remind the user that the gateway needs these environment variables set to match:
-- `TELEGRAM_BOT_TOKEN` — the bot token
-- `TELEGRAM_WEBHOOK_SECRET` — the generated secret
-
-The values are stored in the credential vault and can be retrieved for gateway configuration.
+The gateway automatically detects credentials from the vault and will begin accepting Telegram webhooks shortly. No manual environment variable configuration is needed.

package/src/contacts/contact-store.ts

@@ -70,7 +70,7 @@ export function upsertContact(params: {
   responseExpectation?: string | null;
   preferredTone?: string | null;
   channels?: Array<{ type: string; address: string; isPrimary?: boolean }>;
-}): ContactWithChannels {
+}): ContactWithChannels & { created: boolean } {
   const db = getDb();
   const now = Date.now();
 
@@ -96,7 +96,7 @@ export function upsertContact(params: {
         syncChannels(contactId, params.channels, now);
       }
 
-      return getContact(contactId)!;
+      return { ...getContact(contactId)!, created: false };
     }
   }
 
@@ -124,7 +124,7 @@ export function upsertContact(params: {
           .run();
 
         syncChannels(contactId, params.channels, now);
-        return getContact(contactId)!;
+        return { ...getContact(contactId)!, created: false };
       }
     }
   }
@@ -148,7 +148,7 @@ export function upsertContact(params: {
     syncChannels(contactId, params.channels, now);
   }
 
-  return getContact(contactId)!;
+  return { ...getContact(contactId)!, created: true };
 }
 
 /**

package/src/daemon/assistant-attachments.ts

@@ -313,6 +313,16 @@ export function drainDirectiveDisplayBuffer(buffer: string): DirectiveDisplayDra
 
     if (!isValidDirective) {
       emitText += tag;
+    } else {
+      // Only trim the trailing newline when the directive occupied its own
+      // line (preceded by \n and followed by \n or \r\n). We intentionally
+      // do NOT trim when nextChar is undefined (end-of-buffer) because in
+      // streaming mode more data may arrive in the next chunk — eagerly
+      // trimming would merge words across the directive boundary.
+      const nextChar = buffer[end + 2];
+      if (emitText.endsWith('\n') && (nextChar === '\n' || nextChar === '\r')) {
+        emitText = emitText.slice(0, -1);
+      }
     }
 
     cursor = end + 2;

package/src/daemon/classifier.ts

@@ -4,6 +4,8 @@ import { getLogger } from '../util/logger.js';
 
 const log = getLogger('classifier');
 
+const CLASSIFICATION_TIMEOUT_MS = 5000;
+
 export type InteractionType = 'computer_use' | 'text_qa';
 
 /**
@@ -53,7 +55,7 @@ export async function classifyInteraction(task: string, source?: 'voice' | 'text
         messages: [{ role: 'user' as const, content: task }],
       }),
       new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error('Classification timeout')), 5000),
+        setTimeout(() => reject(new Error('Classification timeout')), CLASSIFICATION_TIMEOUT_MS),
       ),
     ]);
 

package/src/daemon/computer-use-session.ts

@@ -21,7 +21,7 @@ import { registerSkillTools } from '../tools/registry.js';
 import { buildComputerUseSystemPrompt } from '../config/computer-use-prompt.js';
 import { getSandboxWorkingDir } from '../util/platform.js';
 import { getConfig } from '../config/loader.js';
-import { projectSkillTools, resetSkillToolProjection } from './session-skill-tools.js';
+import { projectSkillTools, resetSkillToolProjection, type SkillProjectionCache } from './session-skill-tools.js';
 import { getLogger } from '../util/logger.js';
 
 const log = getLogger('computer-use-session');
@@ -60,6 +60,7 @@ export class ComputerUseSession {
   private readonly onTerminal?: (sessionId: string) => void;
   private readonly preactivatedSkillIds: string[];
   private readonly skillProjectionState = new Map<string, string>();
+  private readonly skillProjectionCache: SkillProjectionCache = {};
 
   private state: SessionState = 'idle';
   private stepCount = 0;
@@ -235,6 +236,7 @@ export class ComputerUseSession {
       const projection = projectSkillTools([], {
         preactivatedSkillIds: this.preactivatedSkillIds,
         previouslyActiveSkillIds: this.skillProjectionState,
+        cache: this.skillProjectionCache,
       });
 
       if (projection.toolDefinitions.length === 0) {

package/src/daemon/date-context.ts

@@ -0,0 +1,136 @@
+/**
+ * Temporal context formatter for future weekday/weekend grounding.
+ *
+ * Produces a compact, deterministic payload describing the current date,
+ * upcoming weekend/work-week windows, and a short horizon of labelled
+ * future dates.  Intended for runtime injection into the model context.
+ */
+
+export interface TemporalContextOptions {
+  /** Override current time (epoch ms) for deterministic tests. */
+  nowMs?: number;
+  /** IANA timezone (e.g. "America/New_York"). Defaults to host timezone. */
+  timeZone?: string;
+  /** Number of future days to list (default 14, hard-capped at 14). */
+  horizonDays?: number;
+}
+
+const MAX_OUTPUT_CHARS = 1500;
+const MAX_HORIZON_ENTRIES = 14;
+
+const WEEKDAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] as const;
+
+/**
+ * Get the local date parts for a given instant in the specified timezone.
+ */
+function localDateParts(date: Date, timeZone: string): { year: number; month: number; day: number; weekday: number } {
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    weekday: 'short',
+  });
+  const parts = fmt.formatToParts(date);
+  const get = (t: string) => parts.find((p) => p.type === t)?.value ?? '';
+  // Weekday as 0-6 (Sun-Sat)
+  const weekdayShort = get('weekday');
+  const weekdayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+  return {
+    year: parseInt(get('year'), 10),
+    month: parseInt(get('month'), 10),
+    day: parseInt(get('day'), 10),
+    weekday: weekdayMap[weekdayShort] ?? 0,
+  };
+}
+
+/**
+ * Format a Date as YYYY-MM-DD in the given timezone.
+ */
+function formatLocalDate(date: Date, timeZone: string): string {
+  const p = localDateParts(date, timeZone);
+  return `${p.year}-${String(p.month).padStart(2, '0')}-${String(p.day).padStart(2, '0')}`;
+}
+
+/**
+ * Advance a date by `days` calendar days in the given timezone.
+ *
+ * Computes the local date, adds days to the day component, then anchors
+ * the result at noon local time to avoid DST-transition edge cases.
+ */
+function addDays(date: Date, days: number, timeZone: string): Date {
+  const parts = localDateParts(date, timeZone);
+  // Use Date.UTC for calendar overflow (e.g. Jan 32 → Feb 1).
+  const ref = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days));
+  const tY = ref.getUTCFullYear();
+  const tM = ref.getUTCMonth() + 1;
+  const tD = ref.getUTCDate();
+  // Noon UTC covers UTC-12 through ~UTC+11.  For far-east timezones
+  // (UTC+12/+13/+14) noon UTC is already the next local day, so fall
+  // back to midnight UTC which resolves correctly there.
+  const noonUTC = new Date(Date.UTC(tY, tM - 1, tD, 12, 0, 0));
+  const r = localDateParts(noonUTC, timeZone);
+  if (r.year === tY && r.month === tM && r.day === tD) {
+    return noonUTC;
+  }
+  return new Date(Date.UTC(tY, tM - 1, tD, 0, 0, 0));
+}
+
+/**
+ * Build a compact temporal context string for model injection.
+ *
+ * Output is hard-capped at {@link MAX_OUTPUT_CHARS} characters and
+ * {@link MAX_HORIZON_ENTRIES} horizon entries.
+ */
+export function buildTemporalContext(options: TemporalContextOptions = {}): string {
+  const now = new Date(options.nowMs ?? Date.now());
+  const timeZone = options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const horizonDays = Math.min(options.horizonDays ?? MAX_HORIZON_ENTRIES, MAX_HORIZON_ENTRIES);
+
+  const todayParts = localDateParts(now, timeZone);
+  const todayStr = formatLocalDate(now, timeZone);
+  const todayWeekday = WEEKDAY_NAMES[todayParts.weekday];
+
+  // ── Next weekend (Saturday-Sunday) ──
+  const daysUntilSaturday = (6 - todayParts.weekday + 7) % 7 || 7;
+  const nextSaturday = addDays(now, daysUntilSaturday, timeZone);
+  const nextSunday = addDays(now, daysUntilSaturday + 1, timeZone);
+
+  // ── Next work week (Monday-Friday) ──
+  const daysUntilMonday = (1 - todayParts.weekday + 7) % 7 || 7;
+  const nextMonday = addDays(now, daysUntilMonday, timeZone);
+  const nextFriday = addDays(now, daysUntilMonday + 4, timeZone);
+
+  // ── Horizon list ──
+  const horizonLines: string[] = [];
+  for (let i = 1; i <= horizonDays; i++) {
+    const futureDate = addDays(now, i, timeZone);
+    const futureParts = localDateParts(futureDate, timeZone);
+    const label = WEEKDAY_NAMES[futureParts.weekday];
+    horizonLines.push(`  ${formatLocalDate(futureDate, timeZone)} ${label}`);
+  }
+
+  const lines = [
+    `<temporal_context>`,
+    `Today: ${todayStr} (${todayWeekday})`,
+    `Timezone: ${timeZone}`,
+    ``,
+    `Week definitions: work week = Monday–Friday, weekend = Saturday–Sunday`,
+    ``,
+    `Next weekend: ${formatLocalDate(nextSaturday, timeZone)} – ${formatLocalDate(nextSunday, timeZone)}`,
+    `Next work week: ${formatLocalDate(nextMonday, timeZone)} – ${formatLocalDate(nextFriday, timeZone)}`,
+    ``,
+    `Upcoming dates:`,
+    ...horizonLines,
+    `</temporal_context>`,
+  ];
+
+  let output = lines.join('\n');
+
+  // Hard cap: truncate if somehow over budget (shouldn't happen with 14 entries).
+  if (output.length > MAX_OUTPUT_CHARS) {
+    output = output.slice(0, MAX_OUTPUT_CHARS - 25) + '\n</temporal_context>';
+  }
+
+  return output;
+}

package/src/daemon/handlers/apps.ts

@@ -18,7 +18,7 @@ import type {
   AppUpdatePreviewRequest,
   UiSurfaceShow,
 } from '../ipc-protocol.js';
-import { log, compareSemver, createSigningCallback, type HandlerContext } from './shared.js';
+import { log, compareSemver, createSigningCallback, defineHandlers, type HandlerContext } from './shared.js';
 
 export function handleAppDataRequest(
   msg: AppDataRequest,
@@ -444,3 +444,18 @@ export function handleGalleryInstall(
     });
   }
 }
+
+export const appHandlers = defineHandlers({
+  app_data_request: handleAppDataRequest,
+  app_open_request: handleAppOpenRequest,
+  app_update_preview: handleAppUpdatePreview,
+  app_preview_request: handleAppPreview,
+  apps_list: (_msg, socket, ctx) => handleAppsList(socket, ctx),
+  shared_apps_list: (_msg, socket, ctx) => handleSharedAppsList(socket, ctx),
+  shared_app_delete: handleSharedAppDelete,
+  fork_shared_app: handleForkSharedApp,
+  share_app_cloud: handleShareAppCloud,
+  bundle_app: handleBundleApp,
+  gallery_list: (_msg, socket, ctx) => handleGalleryList(socket, ctx),
+  gallery_install: handleGalleryInstall,
+});

package/src/daemon/handlers/browser.ts

@@ -0,0 +1,54 @@
+import { browserManager } from '../../tools/browser/browser-manager.js';
+import { log, defineHandlers } from './shared.js';
+
+export const browserHandlers = defineHandlers({
+  browser_cdp_response: (msg) => {
+    browserManager.resolveCDPResponse(msg.sessionId, msg.success, msg.declined);
+  },
+
+  browser_user_click: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      const viewport = await page.evaluate('(() => ({ vw: window.innerWidth, vh: window.innerHeight }))()') as { vw: number; vh: number };
+      const scale = Math.min(1280 / viewport.vw, 960 / viewport.vh);
+      const pageX = msg.x / scale;
+      const pageY = msg.y / scale;
+      const options: Record<string, unknown> = {};
+      if (msg.button === 'right') options.button = 'right';
+      if (msg.doubleClick) options.clickCount = 2;
+      await page.mouse.click(pageX, pageY, options);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user click');
+    }
+  },
+
+  browser_user_scroll: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      await page.mouse.wheel(msg.deltaX, msg.deltaY);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user scroll');
+    }
+  },
+
+  browser_user_keypress: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      const combo = msg.modifiers?.length ? [...msg.modifiers, msg.key].join('+') : msg.key;
+      await page.keyboard.press(combo);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user keypress');
+    }
+  },
+
+  browser_interactive_mode: (msg, socket, ctx) => {
+    log.info({ sessionId: msg.sessionId, enabled: msg.enabled }, 'Interactive mode toggled');
+    browserManager.setInteractiveMode(msg.sessionId, msg.enabled);
+    ctx.send(socket, {
+      type: 'browser_interactive_mode_changed',
+      sessionId: msg.sessionId,
+      surfaceId: msg.surfaceId,
+      enabled: msg.enabled,
+    });
+  },
+});

package/src/daemon/handlers/computer-use.ts

@@ -10,7 +10,7 @@ import type {
   CuObservation,
   ServerMessage,
 } from '../ipc-protocol.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
 
 const cuObservationSequenceBySession = new Map<string, number>();
 
@@ -179,3 +179,9 @@ export async function handleCuObservation(
     log.error({ err, sessionId: msg.sessionId }, 'Error handling CU observation');
   });
 }
+
+export const computerUseHandlers = defineHandlers({
+  cu_session_create: handleCuSessionCreate,
+  cu_session_abort: handleCuSessionAbort,
+  cu_observation: handleCuObservation,
+});

package/src/daemon/handlers/config.ts

@@ -5,7 +5,7 @@ import { addRule, removeRule, updateRule, getAllRules, acceptStarterBundle } fro
 import { listSchedules, updateSchedule, deleteSchedule, describeCronExpression } from '../../schedule/schedule-store.js';
 import { listReminders, cancelReminder } from '../../tools/reminder/reminder-store.js';
 import { getSecureKey, setSecureKey, deleteSecureKey } from '../../security/secure-keys.js';
-import { upsertCredentialMetadata, deleteCredentialMetadata } from '../../tools/credentials/metadata-store.js';
+import { upsertCredentialMetadata, deleteCredentialMetadata, getCredentialMetadata } from '../../tools/credentials/metadata-store.js';
 import { postToSlackWebhook } from '../../slack/slack-webhook.js';
 import { getApp } from '../../memory/app-store.js';
 import type {
@@ -19,9 +19,11 @@ import type {
   ReminderCancel,
   ShareToSlackRequest,
   SlackWebhookConfigRequest,
+  TwilioWebhookConfigRequest,
   VercelApiConfigRequest,
+  TwitterIntegrationConfigRequest,
 } from '../ipc-protocol.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, CONFIG_RELOAD_DEBOUNCE_MS, defineHandlers, type HandlerContext } from './shared.js';
 import { MODEL_TO_PROVIDER } from '../session-slash.js';
 
 export function handleModelGet(socket: net.Socket, ctx: HandlerContext): void {
@@ -96,7 +98,7 @@ export function handleModelSet(
     }
     const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
     if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
-    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, 300);
+    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
     ctx.debounceTimers.set('__suppress_reset__', resetTimer);
 
     // Re-initialize provider with the new model so LLM calls use it
@@ -145,7 +147,7 @@ export function handleImageGenModelSet(
     }
     const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
     if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
-    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, 300);
+    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
     ctx.debounceTimers.set('__suppress_reset__', resetTimer);
 
     ctx.updateConfigFingerprint();
@@ -237,13 +239,15 @@ export function handleSchedulesList(socket: net.Socket, ctx: HandlerContext): vo
       id: j.id,
       name: j.name,
       enabled: j.enabled,
+      syntax: j.syntax,
+      expression: j.expression,
       cronExpression: j.cronExpression,
       timezone: j.timezone,
       message: j.message,
       nextRunAt: j.nextRunAt,
       lastRunAt: j.lastRunAt,
       lastStatus: j.lastStatus,
-      description: describeCronExpression(j.cronExpression),
+      description: j.syntax === 'cron' ? describeCronExpression(j.cronExpression) : j.expression,
     })),
   });
 }
@@ -393,6 +397,41 @@ export function handleSlackWebhookConfig(
   }
 }
 
+export function handleTwilioWebhookConfig(
+  msg: TwilioWebhookConfigRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    if (msg.action === 'get') {
+      const raw = loadRawConfig();
+      const webhookBaseUrl = (raw?.calls as Record<string, unknown>)?.webhookBaseUrl as string ?? '';
+      ctx.send(socket, { type: 'twilio_webhook_config_response', webhookBaseUrl, success: true });
+    } else if (msg.action === 'set') {
+      const value = (msg.webhookBaseUrl ?? '').trim().replace(/\/+$/, '');
+      const raw = loadRawConfig();
+      const calls = (raw?.calls ?? {}) as Record<string, unknown>;
+      calls.webhookBaseUrl = value || undefined;
+      const wasSuppressed = ctx.suppressConfigReload;
+      ctx.setSuppressConfigReload(true);
+      try {
+        saveRawConfig({ ...raw, calls });
+      } catch (err) {
+        ctx.setSuppressConfigReload(wasSuppressed);
+        throw err;
+      }
+      const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
+      if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
+      const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+      ctx.debounceTimers.set('__suppress_reset__', resetTimer);
+      ctx.send(socket, { type: 'twilio_webhook_config_response', webhookBaseUrl: value, success: true });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    ctx.send(socket, { type: 'twilio_webhook_config_response', webhookBaseUrl: '', success: false, error: message });
+  }
+}
+
 export function handleVercelApiConfig(
   msg: VercelApiConfigRequest,
   socket: net.Socket,
@@ -455,6 +494,145 @@ export function handleVercelApiConfig(
   }
 }
 
+export function handleTwitterIntegrationConfig(
+  msg: TwitterIntegrationConfigRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    if (msg.action === 'get') {
+      const raw = loadRawConfig();
+      const mode = (raw.twitterIntegrationMode as 'local_byo' | 'managed' | undefined) ?? 'local_byo';
+      const localClientConfigured = !!getSecureKey('credential:integration:twitter:oauth_client_id');
+      const connected = !!getSecureKey('credential:integration:twitter:access_token');
+      const meta = getCredentialMetadata('integration:twitter', 'access_token');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        mode,
+        managedAvailable: false,
+        localClientConfigured,
+        connected,
+        accountInfo: meta?.accountInfo ?? undefined,
+      });
+    } else if (msg.action === 'set_mode') {
+      const raw = loadRawConfig();
+      raw.twitterIntegrationMode = msg.mode ?? 'local_byo';
+      saveRawConfig(raw);
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        mode: msg.mode ?? 'local_byo',
+        managedAvailable: false,
+        localClientConfigured: !!getSecureKey('credential:integration:twitter:oauth_client_id'),
+        connected: !!getSecureKey('credential:integration:twitter:access_token'),
+      });
+    } else if (msg.action === 'set_local_client') {
+      if (!msg.clientId) {
+        ctx.send(socket, {
+          type: 'twitter_integration_config_response',
+          success: false,
+          managedAvailable: false,
+          localClientConfigured: false,
+          connected: false,
+          error: 'clientId is required for set_local_client action',
+        });
+        return;
+      }
+      const previousClientId = getSecureKey('credential:integration:twitter:oauth_client_id');
+      const storedId = setSecureKey('credential:integration:twitter:oauth_client_id', msg.clientId);
+      if (!storedId) {
+        ctx.send(socket, {
+          type: 'twitter_integration_config_response',
+          success: false,
+          managedAvailable: false,
+          localClientConfigured: false,
+          connected: false,
+          error: 'Failed to store client ID in secure storage',
+        });
+        return;
+      }
+      if (msg.clientSecret) {
+        const storedSecret = setSecureKey('credential:integration:twitter:oauth_client_secret', msg.clientSecret);
+        if (!storedSecret) {
+          // Roll back the client ID to its previous value to avoid inconsistent OAuth state
+          if (previousClientId) {
+            setSecureKey('credential:integration:twitter:oauth_client_id', previousClientId);
+          } else {
+            deleteSecureKey('credential:integration:twitter:oauth_client_id');
+          }
+          ctx.send(socket, {
+            type: 'twitter_integration_config_response',
+            success: false,
+            managedAvailable: false,
+            localClientConfigured: false,
+            connected: false,
+            error: 'Failed to store client secret in secure storage',
+          });
+          return;
+        }
+      } else {
+        // Clear any stale secret when updating client without a secret (e.g. switching to PKCE)
+        deleteSecureKey('credential:integration:twitter:oauth_client_secret');
+      }
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: true,
+        connected: !!getSecureKey('credential:integration:twitter:access_token'),
+      });
+    } else if (msg.action === 'clear_local_client') {
+      // If connected, disconnect first
+      if (getSecureKey('credential:integration:twitter:access_token')) {
+        deleteSecureKey('credential:integration:twitter:access_token');
+        deleteSecureKey('credential:integration:twitter:refresh_token');
+        deleteCredentialMetadata('integration:twitter', 'access_token');
+      }
+      deleteSecureKey('credential:integration:twitter:oauth_client_id');
+      deleteSecureKey('credential:integration:twitter:oauth_client_secret');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: false,
+        connected: false,
+      });
+    } else if (msg.action === 'disconnect') {
+      deleteSecureKey('credential:integration:twitter:access_token');
+      deleteSecureKey('credential:integration:twitter:refresh_token');
+      deleteCredentialMetadata('integration:twitter', 'access_token');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: !!getSecureKey('credential:integration:twitter:oauth_client_id'),
+        connected: false,
+      });
+    } else {
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: false,
+        managedAvailable: false,
+        localClientConfigured: false,
+        connected: false,
+        error: `Unknown action: ${String((msg as unknown as Record<string, unknown>).action)}`,
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Failed to handle Twitter integration config');
+    ctx.send(socket, {
+      type: 'twitter_integration_config_response',
+      success: false,
+      managedAvailable: false,
+      localClientConfigured: false,
+      connected: false,
+      error: message,
+    });
+  }
+}
+
 export function handleEnvVarsRequest(socket: net.Socket, ctx: HandlerContext): void {
   const vars: Record<string, string> = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -462,3 +640,25 @@ export function handleEnvVarsRequest(socket: net.Socket, ctx: HandlerContext): v
   }
   ctx.send(socket, { type: 'env_vars_response', vars });
 }
+
+export const configHandlers = defineHandlers({
+  model_get: (_msg, socket, ctx) => handleModelGet(socket, ctx),
+  model_set: handleModelSet,
+  image_gen_model_set: handleImageGenModelSet,
+  add_trust_rule: handleAddTrustRule,
+  trust_rules_list: (_msg, socket, ctx) => handleTrustRulesList(socket, ctx),
+  remove_trust_rule: handleRemoveTrustRule,
+  update_trust_rule: handleUpdateTrustRule,
+  accept_starter_bundle: (_msg, socket, ctx) => handleAcceptStarterBundle(socket, ctx),
+  schedules_list: (_msg, socket, ctx) => handleSchedulesList(socket, ctx),
+  schedule_toggle: handleScheduleToggle,
+  schedule_remove: handleScheduleRemove,
+  reminders_list: (_msg, socket, ctx) => handleRemindersList(socket, ctx),
+  reminder_cancel: handleReminderCancel,
+  share_to_slack: handleShareToSlack,
+  slack_webhook_config: handleSlackWebhookConfig,
+  twilio_webhook_config: handleTwilioWebhookConfig,
+  vercel_api_config: handleVercelApiConfig,
+  twitter_integration_config: handleTwitterIntegrationConfig,
+  env_vars_request: (_msg, socket, ctx) => handleEnvVarsRequest(socket, ctx),
+});

package/src/daemon/handlers/diagnostics.ts

@@ -9,7 +9,7 @@ import archiver from 'archiver';
 import { getDb } from '../../memory/db.js';
 import { messages, toolInvocations, llmUsageEvents, llmRequestLogs } from '../../memory/schema.js';
 import type { DiagnosticsExportRequest } from '../ipc-protocol.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
 
 const MAX_CONTENT_LENGTH = 500;
 
@@ -332,3 +332,7 @@ export async function handleDiagnosticsExport(
     });
   }
 }
+
+export const diagnosticsHandlers = defineHandlers({
+  diagnostics_export_request: handleDiagnosticsExport,
+});