vellum 0.2.1 → 0.2.2

package/src/tools/tasks/work-item-remove.ts

@@ -1,112 +1,60 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { resolveWorkItem, removeWorkItemFromQueue, identifyEntityById, buildTaskTemplateMismatchError, type WorkItemStatus } from '../../work-items/work-item-store.js';
 import { getLogger } from '../../util/logger.js';
 
 const log = getLogger('task-list-remove');
 
-const definition: ToolDefinition = {
-  name: 'task_list_remove',
-  description:
-    'Remove a task from the Task Queue. Identifies the task by work item ID, task ID, task name, or title. When multiple items match, use the disambiguation fields (priority_tier, status, created_order) to narrow down.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      work_item_id: {
-        type: 'string',
-        description: 'Direct work item ID (most precise selector)',
-      },
-      task_id: {
-        type: 'string',
-        description: 'Task definition ID to find the work item for',
-      },
-      task_name: {
-        type: 'string',
-        description: 'Task name/title to search for (case-insensitive exact match)',
-      },
-      title: {
-        type: 'string',
-        description: 'Work item title to search for (case-insensitive exact match)',
-      },
-      priority_tier: {
-        type: 'number',
-        description: 'Disambiguator: filter by priority tier (0 = high, 1 = medium, 2 = low)',
-      },
-      status: {
-        type: 'string',
-        enum: ['queued', 'running', 'awaiting_review', 'failed'],
-        description: 'Disambiguator: filter by work item status',
-      },
-      created_order: {
-        type: 'number',
-        description: 'Disambiguator: 1-indexed creation order among matches (1 = oldest, 2 = second oldest, etc.)',
-      },
-    },
-  },
-};
-
-class TaskListRemoveTool implements Tool {
-  name = 'task_list_remove';
-  description = definition.description;
-  category = 'tasks';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const selectorType = input.work_item_id ? 'work_item_id' : input.task_id ? 'task_id' : input.task_name ? 'task_name' : input.title ? 'title' : 'none';
-
-    try {
-      const selector = {
-        workItemId: input.work_item_id as string | undefined,
-        taskId: input.task_id as string | undefined,
-        title: (input.task_name ?? input.title) as string | undefined,
-        priorityTier: input.priority_tier as number | undefined,
-        status: input.status as WorkItemStatus | undefined,
-        createdOrder: input.created_order as number | undefined,
-      };
-
-      const resolveResult = resolveWorkItem(selector);
-
-      if (resolveResult.status === 'not_found') {
-        // When the model passes an ID directly, check if it's a task template
-        if (selector.workItemId) {
-          const entity = identifyEntityById(selector.workItemId);
-          if (entity.type === 'task_template') {
-            log.warn({ selectorType, inputId: selector.workItemId }, 'task template ID passed as work_item_id');
-            return {
-              content: `Error: ${buildTaskTemplateMismatchError(selector.workItemId, entity.title!, 'task_delete to delete task templates')}`,
-              isError: true,
-            };
-          }
+export async function executeTaskListRemove(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const selectorType = input.work_item_id ? 'work_item_id' : input.task_id ? 'task_id' : input.task_name ? 'task_name' : input.title ? 'title' : 'none';
+
+  try {
+    const selector = {
+      workItemId: input.work_item_id as string | undefined,
+      taskId: input.task_id as string | undefined,
+      title: (input.task_name ?? input.title) as string | undefined,
+      priorityTier: input.priority_tier as number | undefined,
+      status: input.status as WorkItemStatus | undefined,
+      createdOrder: input.created_order as number | undefined,
+    };
+
+    const resolveResult = resolveWorkItem(selector);
+
+    if (resolveResult.status === 'not_found') {
+      // When the model passes an ID directly, check if it's a task template
+      if (selector.workItemId) {
+        const entity = identifyEntityById(selector.workItemId);
+        if (entity.type === 'task_template') {
+          log.warn({ selectorType, inputId: selector.workItemId }, 'task template ID passed as work_item_id');
+          return {
+            content: `Error: ${buildTaskTemplateMismatchError(selector.workItemId, entity.title!, 'task_delete to delete task templates')}`,
+            isError: true,
+          };
         }
-        log.warn({ selectorType, error: resolveResult.message }, 'work item not found for removal');
-        return { content: `Error: ${resolveResult.message}`, isError: true };
       }
+      log.warn({ selectorType, error: resolveResult.message }, 'work item not found for removal');
+      return { content: `Error: ${resolveResult.message}`, isError: true };
+    }
 
-      if (resolveResult.status === 'ambiguous') {
-        log.warn({ selectorType, matchCount: resolveResult.matches.length }, 'ambiguous selector for removal');
-        return { content: `Error: ${resolveResult.message}`, isError: true };
-      }
+    if (resolveResult.status === 'ambiguous') {
+      log.warn({ selectorType, matchCount: resolveResult.matches.length }, 'ambiguous selector for removal');
+      return { content: `Error: ${resolveResult.message}`, isError: true };
+    }
 
-      const item = resolveResult.workItem;
+    const item = resolveResult.workItem;
 
-      log.info({ selectorType, selectorValue: input[selectorType], resolvedWorkItemId: item.id, title: item.title }, 'resolved work item for removal');
+    log.info({ selectorType, selectorValue: input[selectorType], resolvedWorkItemId: item.id, title: item.title }, 'resolved work item for removal');
 
-      const removeResult = removeWorkItemFromQueue(item.id);
+    const removeResult = removeWorkItemFromQueue(item.id);
 
-      log.info({ resolvedWorkItemId: item.id, deletedCount: 1 }, 'work item removed');
+    log.info({ resolvedWorkItemId: item.id, deletedCount: 1 }, 'work item removed');
 
-      return { content: removeResult.message, isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ selectorType, error: msg }, 'remove failed');
-      return { content: `Error: ${msg}`, isError: true };
-    }
+    return { content: removeResult.message, isError: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ selectorType, error: msg }, 'remove failed');
+    return { content: `Error: ${msg}`, isError: true };
   }
 }
-
-export const taskListRemoveTool = new TaskListRemoveTool();

package/src/tools/tasks/work-item-update.ts

@@ -1,6 +1,4 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { resolveWorkItem, updateWorkItem, identifyEntityById, buildTaskTemplateMismatchError, type WorkItemStatus } from '../../work-items/work-item-store.js';
 import { getLogger } from '../../util/logger.js';
 
@@ -12,175 +10,105 @@ const PRIORITY_LABELS: Record<number, string> = {
   2: 'low',
 };
 
-const definition: ToolDefinition = {
-  name: 'task_list_update',
-  description:
-    'Update an existing task in the Task Queue. Can change priority, notes, status, or sort order. Identifies the task by work item ID, task ID, task name, or title.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      work_item_id: {
-        type: 'string',
-        description: 'Direct work item ID (most precise selector)',
-      },
-      task_id: {
-        type: 'string',
-        description: 'Task definition ID to find the work item for',
-      },
-      task_name: {
-        type: 'string',
-        description: 'Task name/title to search for (case-insensitive exact match)',
-      },
-      title: {
-        type: 'string',
-        description: 'Work item title to search for (case-insensitive exact match)',
-      },
-      priority_tier: {
-        type: 'number',
-        description: '0 = high, 1 = medium, 2 = low',
-      },
-      notes: {
-        type: 'string',
-        description: 'Updated notes for the work item',
-      },
-      status: {
-        type: 'string',
-        enum: ['queued', 'running', 'awaiting_review', 'failed', 'archived'],
-        description: 'New status for the work item',
-      },
-      sort_index: {
-        type: 'number',
-        description: 'Manual sort order within the same priority tier',
-      },
-      filter_priority_tier: {
-        type: 'number',
-        description:
-          'Disambiguation filter: narrow by current priority tier (0=high, 1=medium, 2=low) when multiple items share the same title/task_id. This identifies WHICH item to update — it is NOT the new priority value.',
-      },
-      filter_status: {
-        type: 'string',
-        enum: ['queued', 'running', 'awaiting_review', 'failed', 'done', 'archived'],
-        description:
-          'Disambiguation filter: narrow by current status when multiple items share the same title/task_id.',
-      },
-      created_order: {
-        type: 'number',
-        description:
-          'Disambiguation filter: pick the Nth oldest match (1 = oldest, 2 = second oldest, etc.) when multiple items share the same title/task_id.',
-      },
-    },
-  },
-};
-
-class TaskListUpdateTool implements Tool {
-  name = 'task_list_update';
-  description = definition.description;
-  category = 'tasks';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const selectorType = input.work_item_id ? 'work_item_id' : input.task_id ? 'task_id' : input.task_name ? 'task_name' : input.title ? 'title' : 'none';
-
-    try {
-      // Build selector from whichever identifier was provided
-      const selector = {
-        workItemId: input.work_item_id as string | undefined,
-        taskId: input.task_id as string | undefined,
-        title: (input.task_name ?? input.title) as string | undefined,
-        priorityTier: input.filter_priority_tier as number | undefined,
-        status: input.filter_status as WorkItemStatus | undefined,
-        createdOrder: input.created_order as number | undefined,
-      };
-
-      // Resolve the target work item
-      const result = resolveWorkItem(selector);
-
-      if (result.status === 'not_found') {
-        // When the model passes an ID directly, check if it's a task template
-        if (selector.workItemId) {
-          const entity = identifyEntityById(selector.workItemId);
-          if (entity.type === 'task_template') {
-            log.warn({ selectorType, inputId: selector.workItemId }, 'task template ID passed as work_item_id');
-            return {
-              content: `Error: ${buildTaskTemplateMismatchError(selector.workItemId, entity.title!, 'task_delete to remove task templates, or task_list to view them')}`,
-              isError: true,
-            };
-          }
+export async function executeTaskListUpdate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const selectorType = input.work_item_id ? 'work_item_id' : input.task_id ? 'task_id' : input.task_name ? 'task_name' : input.title ? 'title' : 'none';
+
+  try {
+    // Build selector from whichever identifier was provided
+    const selector = {
+      workItemId: input.work_item_id as string | undefined,
+      taskId: input.task_id as string | undefined,
+      title: (input.task_name ?? input.title) as string | undefined,
+      priorityTier: input.filter_priority_tier as number | undefined,
+      status: input.filter_status as WorkItemStatus | undefined,
+      createdOrder: input.created_order as number | undefined,
+    };
+
+    // Resolve the target work item
+    const result = resolveWorkItem(selector);
+
+    if (result.status === 'not_found') {
+      // When the model passes an ID directly, check if it's a task template
+      if (selector.workItemId) {
+        const entity = identifyEntityById(selector.workItemId);
+        if (entity.type === 'task_template') {
+          log.warn({ selectorType, inputId: selector.workItemId }, 'task template ID passed as work_item_id');
+          return {
+            content: `Error: ${buildTaskTemplateMismatchError(selector.workItemId, entity.title!, 'task_delete to remove task templates, or task_list to view them')}`,
+            isError: true,
+          };
         }
-        log.warn({ selectorType, error: result.message }, 'work item not found for update');
-        return { content: `Error: ${result.message}`, isError: true };
       }
+      log.warn({ selectorType, error: result.message }, 'work item not found for update');
+      return { content: `Error: ${result.message}`, isError: true };
+    }
 
-      if (result.status === 'ambiguous') {
-        log.warn({ selectorType, matchCount: result.matches.length }, 'ambiguous selector for update');
-        return { content: `Error: ${result.message}`, isError: true };
-      }
+    if (result.status === 'ambiguous') {
+      log.warn({ selectorType, matchCount: result.matches.length }, 'ambiguous selector for update');
+      return { content: `Error: ${result.message}`, isError: true };
+    }
 
-      const item = result.workItem;
+    const item = result.workItem;
 
-      // Block direct transitions to 'done' — the only path to done is
-      // through the Review action (handleWorkItemComplete in the daemon).
-      if (input.status === 'done') {
-        log.warn({ selectorType, resolvedWorkItemId: item.id }, 'rejected attempt to set status to done directly');
-        return {
-          content: 'Error: Cannot set status to \'done\' directly. Use the Review action in the Tasks window.',
-          isError: true,
-        };
-      }
+    // Block direct transitions to 'done' — the only path to done is
+    // through the Review action (handleWorkItemComplete in the daemon).
+    if (input.status === 'done') {
+      log.warn({ selectorType, resolvedWorkItemId: item.id }, 'rejected attempt to set status to done directly');
+      return {
+        content: 'Error: Cannot set status to \'done\' directly. Use the Review action in the Tasks window.',
+        isError: true,
+      };
+    }
 
-      log.info({ selectorType, selectorValue: input[selectorType], resolvedWorkItemId: item.id }, 'resolved work item for update');
-
-      // Build updates from provided fields
-      const updates: Partial<{
-        priorityTier: number;
-        notes: string;
-        status: WorkItemStatus;
-        sortIndex: number;
-      }> = {};
-      if (input.priority_tier !== undefined) updates.priorityTier = input.priority_tier as number;
-      if (input.notes !== undefined) updates.notes = input.notes as string;
-      if (input.status !== undefined) updates.status = input.status as WorkItemStatus;
-      if (input.sort_index !== undefined) updates.sortIndex = input.sort_index as number;
-
-      if (Object.keys(updates).length === 0) {
-        log.warn({ selectorType, resolvedWorkItemId: item.id }, 'update called with no fields to update');
-        return {
-          content: 'No updates specified. Provide at least one field to update (priority_tier, notes, status, sort_index).',
-          isError: true,
-        };
-      }
+    log.info({ selectorType, selectorValue: input[selectorType], resolvedWorkItemId: item.id }, 'resolved work item for update');
+
+    // Build updates from provided fields
+    const updates: Partial<{
+      priorityTier: number;
+      notes: string;
+      status: WorkItemStatus;
+      sortIndex: number;
+    }> = {};
+    if (input.priority_tier !== undefined) updates.priorityTier = input.priority_tier as number;
+    if (input.notes !== undefined) updates.notes = input.notes as string;
+    if (input.status !== undefined) updates.status = input.status as WorkItemStatus;
+    if (input.sort_index !== undefined) updates.sortIndex = input.sort_index as number;
+
+    if (Object.keys(updates).length === 0) {
+      log.warn({ selectorType, resolvedWorkItemId: item.id }, 'update called with no fields to update');
+      return {
+        content: 'No updates specified. Provide at least one field to update (priority_tier, notes, status, sort_index).',
+        isError: true,
+      };
+    }
 
-      const updated = updateWorkItem(item.id, updates);
-      if (!updated) {
-        log.error({ selectorType, resolvedWorkItemId: item.id, updates }, 'updateWorkItem returned null');
-        return {
-          content: `Error: Failed to update work item "${item.title}".`,
-          isError: true,
-        };
-      }
+    const updated = updateWorkItem(item.id, updates);
+    if (!updated) {
+      log.error({ selectorType, resolvedWorkItemId: item.id, updates }, 'updateWorkItem returned null');
+      return {
+        content: `Error: Failed to update work item "${item.title}".`,
+        isError: true,
+      };
+    }
 
-      log.info({ resolvedWorkItemId: item.id, updatedFields: Object.keys(updates) }, 'work item updated');
+    log.info({ resolvedWorkItemId: item.id, updatedFields: Object.keys(updates) }, 'work item updated');
 
-      // Build confirmation message
-      const parts: string[] = [`Updated "${updated.title}"`];
-      if (input.priority_tier !== undefined) {
-        parts.push(`priority → ${PRIORITY_LABELS[updated.priorityTier] ?? updated.priorityTier}`);
-      }
-      if (input.notes !== undefined) parts.push('notes updated');
-      if (input.status !== undefined) parts.push(`status → ${updated.status}`);
-      if (input.sort_index !== undefined) parts.push(`sort index → ${updated.sortIndex}`);
-
-      return { content: parts.join(', ') + '.', isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ selectorType, error: msg }, 'update failed');
-      return { content: `Error: ${msg}`, isError: true };
+    // Build confirmation message
+    const parts: string[] = [`Updated "${updated.title}"`];
+    if (input.priority_tier !== undefined) {
+      parts.push(`priority → ${PRIORITY_LABELS[updated.priorityTier] ?? updated.priorityTier}`);
     }
+    if (input.notes !== undefined) parts.push('notes updated');
+    if (input.status !== undefined) parts.push(`status → ${updated.status}`);
+    if (input.sort_index !== undefined) parts.push(`sort index → ${updated.sortIndex}`);
+
+    return { content: parts.join(', ') + '.', isError: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ selectorType, error: msg }, 'update failed');
+    return { content: `Error: ${msg}`, isError: true };
   }
 }
-
-export const taskListUpdateTool = new TaskListUpdateTool();

package/src/tools/terminal/backends/native.ts

@@ -9,6 +9,8 @@ import type { SandboxBackend, SandboxResult } from './types.js';
 
 const log = getLogger('sandbox');
 
+const HASH_DISPLAY_LENGTH = 12;
+
 /**
  * macOS sandbox-exec profile that restricts shell commands:
  * - Denies all by default
@@ -81,7 +83,7 @@ function getProfilePath(workingDir: string): string {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  const hash = createHash('sha256').update(workingDir).digest('hex').slice(0, 12);
+  const hash = createHash('sha256').update(workingDir).digest('hex').slice(0, HASH_DISPLAY_LENGTH);
   const path = join(dir, `sandbox-profile-${hash}.sb`);
 
   const profile = SANDBOX_PROFILE.replace(/__WORKING_DIR__/g, workingDir);

package/src/tools/tool-manifest.ts

@@ -12,20 +12,9 @@ import type { Tool } from './types.js';
 import { memorySearchTool, memorySaveTool, memoryUpdateTool } from './memory/register.js';
 import { credentialStoreTool } from './credentials/vault.js';
 import { accountManageTool } from './credentials/account-registry.js';
-import { reminderTool } from './reminder/reminder.js';
 import { screenWatchTool } from './watch/screen-watch.js';
 import { vellumSkillsCatalogTool } from './skills/vellum-catalog.js';
-import { documentCreateTool, documentUpdateTool } from './document/index.js';
 import { cliDiscoverTool } from './host-terminal/cli-discover.js';
-import { followupCreateTool, followupListTool, followupResolveTool } from './followups/index.js';
-import { taskSaveTool, taskRunTool, taskListTool, taskDeleteTool, taskListShowTool, taskListAddTool, taskListUpdateTool, taskListRemoveTool } from './tasks/index.js';
-import {
-  subagentSpawnTool,
-  subagentStatusTool,
-  subagentAbortTool,
-  subagentMessageTool,
-  subagentReadTool,
-} from './subagent/index.js';
 
 // ── Eager side-effect modules ───────────────────────────────────────
 // Importing these modules triggers a top-level `registerTool()` call.
@@ -40,22 +29,6 @@ export async function loadEagerModules(): Promise<void> {
   await import('./skills/scaffold-managed.js');
   await import('./skills/delete-managed.js');
   await import('./system/request-permission.js');
-  await import('./schedule/create.js');
-  await import('./schedule/list.js');
-  await import('./schedule/update.js');
-  await import('./schedule/delete.js');
-  await import('./watcher/create.js');
-  await import('./watcher/list.js');
-  await import('./watcher/update.js');
-  await import('./watcher/delete.js');
-  await import('./watcher/digest.js');
-  await import('./playbooks/playbook-create.js');
-  await import('./playbooks/playbook-list.js');
-  await import('./playbooks/playbook-update.js');
-  await import('./playbooks/playbook-delete.js');
-  await import('./contacts/contact-upsert.js');
-  await import('./contacts/contact-search.js');
-  await import('./contacts/contact-merge.js');
   await import('./assets/search.js');
   await import('./assets/materialize.js');
   await import('./filesystem/view-image.js');
@@ -78,22 +51,6 @@ export const eagerModuleToolNames: string[] = [
   'scaffold_managed_skill',
   'delete_managed_skill',
   'request_system_permission',
-  'schedule_create',
-  'schedule_list',
-  'schedule_update',
-  'schedule_delete',
-  'watcher_create',
-  'watcher_list',
-  'watcher_update',
-  'watcher_delete',
-  'watcher_digest',
-  'playbook_create',
-  'playbook_list',
-  'playbook_update',
-  'playbook_delete',
-  'contact_upsert',
-  'contact_search',
-  'contact_merge',
   'asset_search',
   'asset_materialize',
   'view_image',
@@ -112,28 +69,9 @@ export const explicitTools: Tool[] = [
   memoryUpdateTool,
   credentialStoreTool,
   accountManageTool,
-  reminderTool,
   screenWatchTool,
   vellumSkillsCatalogTool,
-  documentCreateTool,
-  documentUpdateTool,
   cliDiscoverTool,
-  followupCreateTool,
-  followupListTool,
-  followupResolveTool,
-  taskSaveTool,
-  taskRunTool,
-  taskListTool,
-  taskDeleteTool,
-  taskListShowTool,
-  taskListAddTool,
-  taskListUpdateTool,
-  taskListRemoveTool,
-  subagentSpawnTool,
-  subagentStatusTool,
-  subagentAbortTool,
-  subagentMessageTool,
-  subagentReadTool,
 ];
 
 // ── Lazy tool descriptors ───────────────────────────────────────────

package/src/tools/types.ts

@@ -52,6 +52,8 @@ export interface ToolExecutedEvent extends ToolLifecycleEventBase {
   result: ToolExecutionResult;
 }
 
+export type ErrorCategory = 'permission_denied' | 'auth' | 'tool_failure' | 'unexpected';
+
 export interface ToolExecutionErrorEvent extends ToolLifecycleEventBase {
   type: 'error';
   riskLevel: string;
@@ -59,6 +61,8 @@ export interface ToolExecutionErrorEvent extends ToolLifecycleEventBase {
   durationMs: number;
   errorMessage: string;
   isExpected: boolean;
+  /** Classifies the error for downstream consumers (audit, alerting, monitoring). */
+  errorCategory: ErrorCategory;
   errorName?: string;
   errorStack?: string;
 }
@@ -89,6 +93,8 @@ export interface ToolContext {
   workingDir: string;
   sessionId: string;
   conversationId: string;
+  /** When set, the tool execution is part of a task run. Used to retrieve ephemeral permission rules. */
+  taskRunId?: string;
   /** Per-message request ID for log correlation across session/connection boundaries. */
   requestId?: string;
   /** Optional callback for streaming incremental output to the client. */

package/src/tools/ui-surface/definitions.ts

@@ -120,7 +120,9 @@ export const uiShowTool: Tool = {
 
 export const uiUpdateTool: Tool = {
   name: 'ui_update',
-  description: "Update an existing surface's data. The provided data object is merged into the surface's current data.",
+  description:
+    "Update an existing surface's data. The provided data object is merged into the surface's current data.\n" +
+    'For card templates (for example `task_progress`), update nested fields under `data.templateData` rather than sending template fields at the top level.',
   category: 'ui-surface',
   defaultRiskLevel: RiskLevel.Low,
   executionMode: 'proxy',

package/src/tools/watch/screen-watch.ts

@@ -13,6 +13,8 @@ import type { WatchSession } from './watch-state.js';
 
 const log = getLogger('screen-watch');
 
+const SHORT_HASH_LENGTH = 8;
+
 class ScreenWatchTool implements Tool {
   name = 'start_screen_watch';
   description = 'Start observing the screen at regular intervals for a specified duration. Captures OCR text from the active window and provides periodic commentary.';
@@ -77,7 +79,7 @@ class ScreenWatchTool implements Tool {
     }
 
     // Generate watchId
-    const watchId = crypto.randomUUID().slice(0, 8);
+    const watchId = crypto.randomUUID().slice(0, SHORT_HASH_LENGTH);
     const now = Date.now();
     const durationSeconds = durationMinutes * 60;