vellum 0.2.0 → 0.2.2

package/src/config/system-prompt.ts

@@ -200,30 +200,75 @@ function buildTaskScheduleReminderRoutingSection(): string {
     '',
     'These three systems serve different purposes. Choose the right one based on user intent:',
     '',
-    '### Task Queue (task_list_add / task_list_show)',
+    '### Task Queue (task_list_add / task_list_show / task_list_update / task_list_remove)',
     'For tracking things the user wants to do or remember. Use when the user says:',
     '- "Add to my tasks", "add to my queue", "put this on my task list"',
     '- "Track this", "I need to do X", "queue this up"',
     '- Any request to add a one-off item to their personal to-do list',
     '',
+    'To modify an existing task, use `task_list_update`:',
+    '- "Bump the priority on X", "make X high priority", "move this up"',
+    '- "Change the status of X", "mark X as done"',
+    '- "Update the notes on X"',
+    'Do NOT use `task_list_add` for updates — it will detect duplicates and suggest using `task_list_update` instead.',
+    '',
+    'To remove a task from the queue, use `task_list_remove`:',
+    '- "Remove X from my tasks", "delete that task", "clean up the duplicate"',
+    '- "Take this off the list", "drop this task"',
+    '',
     'You can create ad-hoc work items by providing just a `title` to `task_list_add` — no existing task template is needed. A lightweight template is auto-created behind the scenes. For reusable task definitions with templates and input schemas, use `task_save` first.',
     '',
+    '**IMPORTANT:** When you call `task_list_show`, the Tasks window opens automatically on the client. Do NOT also create a separate surface/UI (via `ui_show` or `app_create`) to display the task queue. Doing so causes duplicate Task Queue windows. Just call `task_list_show` and let the native window handle the presentation.',
+    '',
     '### Schedules (schedule_create / schedule_list / schedule_update / schedule_delete)',
-    'For recurring automated jobs that run on a cron schedule. Use ONLY when the user explicitly wants:',
+    'For recurring automated jobs that run on a recurrence schedule (cron or RRULE). Use ONLY when the user explicitly wants:',
     '- Recurring automation: "every day at 9am", "weekly on Mondays", "every hour"',
+    '- Complex recurrence patterns: "every other Tuesday", "last weekday of the month" (use RRULE)',
+    '- Bounded recurrence: "every day for 30 days", "weekly until March" (RRULE with COUNT or UNTIL)',
     '- Periodic background tasks: "check my email every morning", "run this report weekly"',
     '',
-    '### Reminders (reminder)',
+    '#### RRULE Set Constructs',
+    'When building RRULE expressions, these set lines are supported:',
+    '- **RRULE** — one or more recurrence rules (multiple RRULE lines form a union of occurrences)',
+    '- **RDATE** — add one-off dates that are not covered by the RRULE pattern',
+    '- **EXDATE** — exclude specific dates from the recurrence set',
+    '- **EXRULE** — exclude an entire series of dates defined by a recurrence pattern',
+    '',
+    'Exclusions (EXDATE, EXRULE) take precedence over inclusions (RRULE, RDATE). All RRULE expressions must include a DTSTART line and at least one RRULE or RDATE inclusion.',
+    '',
+    '### Reminders (reminder_create / reminder_list / reminder_cancel)',
     'For one-time time-triggered notifications. Use ONLY when the user wants:',
     '- A notification at a specific future time: "remind me at 3pm", "remind me in 2 hours"',
     '- A timed alert, not a tracked task',
     '',
     '### Common mistakes to avoid',
-    '- "Add this to my tasks" → task_list_add (NOT schedule_create or reminder)',
+    '- "Add this to my tasks" → task_list_add (NOT schedule_create or reminder_create)',
     '- "What\'s on my task list?" → task_list_show (NOT schedule_list)',
     '- "Remind me to buy groceries" without a time → task_list_add (it\'s a task, not a timed reminder)',
-    '- "Remind me at 5pm to buy groceries" → reminder (explicit time trigger)',
-    '- "Check my inbox every morning at 8am" → schedule_create (recurring automation)',
+    '- "Remind me at 5pm to buy groceries" → reminder_create (explicit time trigger)',
+    '- "Check my inbox every morning at 8am" → schedule_create (recurring automation, cron)',
+    '- "Every other Tuesday at 10am" → schedule_create (recurring automation, RRULE)',
+    '- "Every weekday except holidays" → schedule_create (RRULE with EXDATE for exclusions)',
+    '- "Daily for the next 30 days" → schedule_create (RRULE with COUNT=30)',
+    '- "Bump priority on X" → task_list_update (NOT task_list_add)',
+    '- "Move this up" / "change this task priority" → task_list_update (NOT task_list_add)',
+    '- "Mark X as done" → task_list_update (NOT task_list_add)',
+    '- "Remove X from my tasks" → task_list_remove (NOT task_list_update)',
+    '- "Delete that task" / "clean up the duplicate" → task_list_remove',
+    '',
+    '### Entity type routing: work items vs task templates',
+    '',
+    'There are two entity types with separate ID spaces:',
+    '- **Work items** (the user\'s task queue) — managed by task_list_add, task_list_show, task_list_update, task_list_remove',
+    '- **Task templates** (reusable definitions) — managed by task_save, task_list, task_run, task_delete',
+    '',
+    'Do NOT pass a work item ID to a task template tool or vice versa:',
+    '- Deleting a work item from the queue → task_list_remove (NOT task_delete)',
+    '- Deleting a task template → task_delete (NOT task_list_remove)',
+    '- Running a task template → task_run with task_id (NOT a work item ID)',
+    '- Updating a work item → task_list_update with work_item_id (NOT a task template ID)',
+    '',
+    'If an error says "entity mismatch", read the corrective action and selector fields it provides to pick the right tool.',
   ].join('\n');
 }
 
@@ -277,6 +322,7 @@ function buildDynamicUiSection(): string {
     '- **Tool auto-emissions** (e.g. `get_weather`): handled automatically — do nothing extra',
     '- **Predefined domain data** (flights, stocks): `ui_show` with `surface_type: "dynamic_page"` and domain component classes',
     '- **Simple structured data** (key-value, table, list): `ui_show` with `card`/`table`/`list`/`form` surface_type',
+    '- **Multi-step tasks** (ordering food, booking, purchasing, multi-phase workflows): `ui_show` with `card` surface_type + `data.template: "task_progress"` (see below)',
     '- **Interactive apps only**: `app_create` (calculators, dashboards, tools - NOT text content)',
     '',
     '### Loading app tools',
@@ -379,6 +425,51 @@ function buildDynamicUiSection(): string {
     '- **Data review/selection**: Use a `table` surface with selectable rows',
     '',
     'Interactive surfaces provide a better user experience than asking your user to type their choice. Only fall back to plain text when the interaction is conversational or doesn\'t fit a structured format.',
+    '',
+    '### Task progress for multi-step workflows',
+    'When executing a multi-step task (booking a flight, purchasing, research with multiple phases), show live progress using the `task_progress` card template. Note: DoorDash ordering auto-emits a task_progress card on the first `vellum doordash` command (surface ID `doordash-progress`), so you only need `ui_update` for DoorDash flows.',
+    '',
+    '1. **Before starting**, call `ui_show` with `surface_type: "card"` and put `template: "task_progress"` inside `data`:',
+    '   ```json',
+    '   {',
+    '     "surface_type": "card",',
+    '     "data": {',
+    '       "title": "Booking Flight",',
+    '       "body": "",',
+    '       "template": "task_progress",',
+    '       "templateData": {',
+    '         "title": "Booking Flight",',
+    '         "status": "in_progress",',
+    '         "steps": [',
+    '           { "label": "Search flights", "status": "in_progress" },',
+    '           { "label": "Compare options", "status": "pending" },',
+    '           { "label": "Select flight", "status": "pending" },',
+    '           { "label": "Complete booking", "status": "pending" }',
+    '         ]',
+    '       }',
+    '     }',
+    '   }',
+    '   ```',
+    '2. **As each step completes**, call `ui_update` with the same surface ID and patch `data.templateData` (not top-level `status`/`steps`):',
+    '   ```json',
+    '   {',
+    '     "surface_id": "<surface-id>",',
+    '     "data": {',
+    '       "templateData": {',
+    '         "status": "in_progress",',
+    '         "steps": [',
+    '           { "label": "Search flights", "status": "completed", "detail": "Found 12 options" },',
+    '           { "label": "Compare options", "status": "in_progress" },',
+    '           { "label": "Select flight", "status": "pending" },',
+    '           { "label": "Complete booking", "status": "pending" }',
+    '         ]',
+    '       }',
+    '     }',
+    '   }',
+    '   ```',
+    '3. **On completion**, set `data.templateData.status` to `"completed"`. On failure, set it to `"failed"` and mark the failing step accordingly.',
+    '',
+    'Use this for ANY multi-step workflow where the user benefits from seeing structured progress instead of just "Running a command...".',
   ].join('\n');
 }
 
@@ -891,6 +982,9 @@ function buildDynamicSkillWorkflowSection(): string {
     '',
     '### Browser Skill Prerequisite',
     'If you need browser capabilities (navigating web pages, clicking elements, extracting content) and `browser_*` tools are not available, load the "browser" skill first using `skill_load`.',
+    '',
+    '### X (Twitter) Skill',
+    'When the user asks to post, reply, or interact with X/Twitter, load the "twitter" skill using `skill_load`. Do NOT use computer-use or the browser skill for X — the X skill provides CLI commands (`vellum x post`, `vellum x reply`) that are faster and more reliable.',
   ].join('\n');
 }
 

package/src/config/templates/IDENTITY.md

@@ -14,5 +14,12 @@ _ This file defines who you are. Fill it in during your first conversation. Make
 - **Emoji:** [Choose one that matches your personality.]
 - **Style tendency:** [Will be filled in by the evolution system based on personality]
 - **Role:** Personal AI assistant
+- **Home:** Local (~/.vellum/workspace)
+
+_ Home describes where this assistant lives. Format examples:
+_ Local (path): Local (~/.vellum/workspace)
+_ GCP: GCP (project: my-project, zone: us-central1-a, instance: vellum-abc)
+_ AWS: AWS (project: my-project, region: us-east-1, instance: vellum-abc)
+_ Custom: Custom (ip: 192.168.1.100, port: 8080)
 
 The user can change their emoji at any time — just update this file when they ask.

package/src/config/types.ts

@@ -27,6 +27,11 @@ export type {
   SkillEntryConfig,
   SkillsLoadConfig,
   SkillsInstallConfig,
+  AgentHeartbeatConfig,
   SwarmConfig,
   SkillsConfig,
+  WorkspaceGitConfig,
+  CallsConfig,
+  CallsDisclosureConfig,
+  CallsSafetyConfig,
 } from './schema.js';

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,
+});