vellum 0.2.0 → 0.2.1

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

@@ -2,7 +2,10 @@ import { RiskLevel } from '../../permissions/types.js';
 import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { getTask, listTasks, createTask } from '../../tasks/task-store.js';
-import { createWorkItem } from '../../work-items/work-item-store.js';
+import { createWorkItem, findActiveWorkItemsByTitle, updateWorkItem, identifyEntityById, buildWorkItemMismatchError } from '../../work-items/work-item-store.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('task-list-add');
 
 const PRIORITY_LABELS: Record<number, string> = {
   0: 'high',
@@ -43,6 +46,12 @@ const definition: ToolDefinition = {
         type: 'number',
         description: 'Manual sort order within the priority tier.',
       },
+      if_exists: {
+        type: 'string',
+        enum: ['create_duplicate', 'reuse_existing', 'update_existing'],
+        description:
+          'What to do if an active work item with the same title already exists. Defaults to "reuse_existing".',
+      },
     },
   },
 };
@@ -57,6 +66,50 @@ class TaskListAddTool implements Tool {
     return definition;
   }
 
+  /**
+   * Check for an existing active work item with the same title and handle
+   * according to the if_exists strategy. Returns a result if a duplicate was
+   * found and handled, or null if no duplicate exists (caller should proceed).
+   */
+  private handleDuplicate(
+    title: string,
+    ifExists: string,
+    input: Record<string, unknown>,
+  ): ToolExecutionResult | null {
+    const existing = findActiveWorkItemsByTitle(title);
+    if (existing.length === 0) return null;
+
+    const match = existing[0];
+    log.info({ title, existingId: match.id, ifExists }, 'task_list_add: duplicate detected');
+
+    if (ifExists === 'reuse_existing') {
+      log.info({ title, existingId: match.id }, 'task_list_add: reused existing item');
+      return {
+        content: `Task "${match.title}" already exists in the queue (ID: ${match.id}, status: ${match.status}). Use task_list_update to modify it.`,
+        isError: false,
+      };
+    }
+
+    if (ifExists === 'update_existing') {
+      const updates: Partial<{ title: string; notes: string; priorityTier: number; 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.sort_index !== undefined) updates.sortIndex = input.sort_index as number;
+      if (Object.keys(updates).length > 0) {
+        updateWorkItem(match.id, updates);
+      }
+      log.info({ title, existingId: match.id, updates }, 'task_list_add: updated existing item');
+      return {
+        content: `Reused existing task "${match.title}" (ID: ${match.id}) instead of creating a duplicate.${
+          Object.keys(updates).length > 0 ? ` Updated: ${Object.keys(updates).join(', ')}.` : ''
+        }`,
+        isError: false,
+      };
+    }
+
+    return null;
+  }
+
   async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
     try {
       const taskId = input.task_id as string | undefined;
@@ -66,6 +119,8 @@ class TaskListAddTool implements Tool {
       const priorityTier = input.priority_tier as number | undefined;
       const sortIndex = input.sort_index as number | undefined;
 
+      const ifExists = (input.if_exists as string) || 'reuse_existing';
+
       // Ad-hoc mode: title provided without task_id or task_name
       if (!taskId && !taskName) {
         if (!titleOverride) {
@@ -75,6 +130,16 @@ class TaskListAddTool implements Tool {
           };
         }
 
+        // Duplicate-prevention guard
+        if (ifExists !== 'create_duplicate') {
+          const duplicateResult = this.handleDuplicate(titleOverride, ifExists, input);
+          if (duplicateResult) return duplicateResult;
+        } else {
+          log.info({ title: titleOverride }, 'task_list_add: creating duplicate (if_exists=create_duplicate)');
+        }
+
+        log.debug({ title: titleOverride }, 'task_list_add: creating new item');
+
         // Auto-create a lightweight task template for the ad-hoc item
         const adHocTask = createTask({
           title: titleOverride,
@@ -89,6 +154,8 @@ class TaskListAddTool implements Tool {
           sortIndex,
         });
 
+        log.info({ selectorType: 'title', workItemId: workItem.id, title: workItem.title }, 'ad-hoc work item created');
+
         const priority = PRIORITY_LABELS[workItem.priorityTier] ?? `tier ${workItem.priorityTier}`;
         const lines = [
           `Enqueued work item:`,
@@ -112,7 +179,14 @@ class TaskListAddTool implements Tool {
       if (taskId) {
         resolvedTask = getTask(taskId);
         if (!resolvedTask) {
-          return { content: `Error: No task definition found with ID "${taskId}".`, isError: true };
+          const entity = identifyEntityById(taskId);
+          if (entity.type === 'work_item') {
+            return {
+              content: `Error: ${buildWorkItemMismatchError(taskId, entity.title!, 'task_list_update to modify the existing work item, or task_list_add with just a title for a new ad-hoc item')}`,
+              isError: true,
+            };
+          }
+          return { content: `Error: No task definition found with ID "${taskId}". Use task_list to see available task templates, or provide just a title to create an ad-hoc work item.`, isError: true };
         }
       } else {
         // Search by name (case-insensitive substring match)
@@ -141,14 +215,29 @@ class TaskListAddTool implements Tool {
         resolvedTask = matches[0];
       }
 
+      const finalTitle = titleOverride ?? resolvedTask.title;
+
+      // Duplicate-prevention guard
+      if (ifExists !== 'create_duplicate') {
+        const duplicateResult = this.handleDuplicate(finalTitle, ifExists, input);
+        if (duplicateResult) return duplicateResult;
+      } else {
+        log.info({ title: finalTitle }, 'task_list_add: creating duplicate (if_exists=create_duplicate)');
+      }
+
+      log.debug({ title: finalTitle }, 'task_list_add: creating new item');
+
+      const selectorType = taskId ? 'task_id' : 'task_name';
       const workItem = createWorkItem({
         taskId: resolvedTask.id,
-        title: titleOverride ?? resolvedTask.title,
+        title: finalTitle,
         notes,
         priorityTier: priorityTier ?? 1,
         sortIndex,
       });
 
+      log.info({ selectorType, taskId: resolvedTask.id, workItemId: workItem.id, title: workItem.title }, 'work item created from task definition');
+
       const priority = PRIORITY_LABELS[workItem.priorityTier] ?? `tier ${workItem.priorityTier}`;
       const lines = [
         `Enqueued work item:`,
@@ -168,6 +257,7 @@ class TaskListAddTool implements Tool {
       return { content: lines.join('\n'), isError: false };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      log.error({ error: msg }, 'enqueue failed');
       return { content: `Error: ${msg}`, isError: true };
     }
   }

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

@@ -3,12 +3,6 @@ import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { listWorkItems, type WorkItemStatus } from '../../work-items/work-item-store.js';
 
-const PRIORITY_LABELS: Record<number, string> = {
-  0: 'high',
-  1: 'medium',
-  2: 'low',
-};
-
 const definition: ToolDefinition = {
   name: 'task_list_show',
   description: 'List the user\'s Task Queue (work items) with their status, priority, and last run info. Use this when the user says "show my tasks", "what\'s in my queue", "what\'s on my task list", or similar.',
@@ -54,28 +48,19 @@ class TaskListShowTool implements Tool {
         items = listWorkItems();
       }
 
-      if (items.length === 0) {
-        return { content: 'No Tasks found.', isError: false };
-      }
+      const count = items.length;
+      const filtered = statusFilter !== undefined;
 
-      const lines = [`Found ${items.length} work item(s):`, ''];
-
-      for (const item of items) {
-        const priority = PRIORITY_LABELS[item.priorityTier] ?? `tier ${item.priorityTier}`;
-        lines.push(`- ${item.title}`);
-        lines.push(`    ID: ${item.id}`);
-        lines.push(`    Status: ${item.status}`);
-        lines.push(`    Priority: ${priority}`);
-        if (item.notes) {
-          lines.push(`    Notes: ${item.notes}`);
-        }
-        if (item.lastRunStatus) {
-          lines.push(`    Last run: ${item.lastRunStatus}`);
-        }
-        lines.push('');
+      if (count === 0) {
+        const suffix = filtered ? 'no items matching filter.' : 'no tasks queued.';
+        return { content: `Opened Tasks window \u2014 ${suffix}`, isError: false };
       }
 
-      return { content: lines.join('\n'), isError: false };
+      const label = filtered
+        ? `${count} ${Array.isArray(statusFilter) ? 'matching' : statusFilter} item${count === 1 ? '' : 's'}`
+        : `${count} item${count === 1 ? '' : 's'}`;
+
+      return { content: `Opened Tasks window (${label}).`, isError: false };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       return { content: `Error: ${msg}`, isError: true };

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

@@ -0,0 +1,112 @@
+import { RiskLevel } from '../../permissions/types.js';
+import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
+import type { ToolDefinition } from '../../providers/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,
+            };
+          }
+        }
+        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 };
+      }
+
+      const item = resolveResult.workItem;
+
+      log.info({ selectorType, selectorValue: input[selectorType], resolvedWorkItemId: item.id, title: item.title }, 'resolved work item for removal');
+
+      const removeResult = removeWorkItemFromQueue(item.id);
+
+      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 };
+    }
+  }
+}
+
+export const taskListRemoveTool = new TaskListRemoveTool();

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

@@ -0,0 +1,186 @@
+import { RiskLevel } from '../../permissions/types.js';
+import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
+import type { ToolDefinition } from '../../providers/types.js';
+import { resolveWorkItem, updateWorkItem, identifyEntityById, buildTaskTemplateMismatchError, type WorkItemStatus } from '../../work-items/work-item-store.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('task-list-update');
+
+const PRIORITY_LABELS: Record<number, string> = {
+  0: 'high',
+  1: 'medium',
+  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,
+            };
+          }
+        }
+        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 };
+      }
+
+      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,
+        };
+      }
+
+      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,
+        };
+      }
+
+      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 };
+    }
+  }
+}
+
+export const taskListUpdateTool = new TaskListUpdateTool();

package/src/tools/tool-manifest.ts

@@ -18,7 +18,7 @@ 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 } from './tasks/index.js';
+import { taskSaveTool, taskRunTool, taskListTool, taskDeleteTool, taskListShowTool, taskListAddTool, taskListUpdateTool, taskListRemoveTool } from './tasks/index.js';
 import {
   subagentSpawnTool,
   subagentStatusTool,
@@ -30,36 +30,39 @@ import {
 // ── Eager side-effect modules ───────────────────────────────────────
 // Importing these modules triggers a top-level `registerTool()` call.
 
-export const eagerModules: string[] = [
-  './filesystem/read.js',
-  './filesystem/write.js',
-  './filesystem/edit.js',
-  './network/web-search.js',
-  './network/web-fetch.js',
-  './skills/load.js',
-  './skills/scaffold-managed.js',
-  './skills/delete-managed.js',
-  './system/request-permission.js',
-  './schedule/create.js',
-  './schedule/list.js',
-  './schedule/update.js',
-  './schedule/delete.js',
-  './watcher/create.js',
-  './watcher/list.js',
-  './watcher/update.js',
-  './watcher/delete.js',
-  './watcher/digest.js',
-  './playbooks/playbook-create.js',
-  './playbooks/playbook-list.js',
-  './playbooks/playbook-update.js',
-  './playbooks/playbook-delete.js',
-  './contacts/contact-upsert.js',
-  './contacts/contact-search.js',
-  './contacts/contact-merge.js',
-  './assets/search.js',
-  './assets/materialize.js',
-  './filesystem/view-image.js',
-];
+export async function loadEagerModules(): Promise<void> {
+  await import('./filesystem/read.js');
+  await import('./filesystem/write.js');
+  await import('./filesystem/edit.js');
+  await import('./network/web-search.js');
+  await import('./network/web-fetch.js');
+  await import('./skills/load.js');
+  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');
+  await import('./calls/call-start.js');
+  await import('./calls/call-status.js');
+  await import('./calls/call-end.js');
+}
 
 // Tool names registered by the eager modules above.  Listed explicitly so
 // initializeTools() can recognise ESM-cached eager-module tools that were
@@ -94,6 +97,9 @@ export const eagerModuleToolNames: string[] = [
   'asset_search',
   'asset_materialize',
   'view_image',
+  'call_start',
+  'call_status',
+  'call_end',
 ];
 
 // ── Explicit tool instances ─────────────────────────────────────────
@@ -121,6 +127,8 @@ export const explicitTools: Tool[] = [
   taskDeleteTool,
   taskListShowTool,
   taskListAddTool,
+  taskListUpdateTool,
+  taskListRemoveTool,
   subagentSpawnTool,
   subagentStatusTool,
   subagentAbortTool,

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

@@ -35,6 +35,9 @@ export const uiShowTool: Tool = {
     'templateData shape: { location: string, currentTemp: number, feelsLike: number, unit: "F"|"C", condition: string, humidity: number, windSpeed: number, windDirection: string, ' +
     'hourly: Array<{ time: string, icon: string (SF Symbol name), temp: number }>, ' +
     'forecast: Array<{ day: string, icon: string (SF Symbol name), low: number, high: number, precip: number|null, condition: string }> }\n' +
+    '  Template "task_progress": renders a live-updating task progress widget showing structured step-by-step progress. ' +
+    'templateData shape: { title: string, status: "in_progress"|"completed"|"failed", ' +
+    'steps: Array<{ label: string, status: "pending"|"in_progress"|"completed"|"failed", detail?: string }> }\n' +
     '- table: Data table with columns, selectable rows, and action buttons. ' +
     'data shape: { columns: Array<{ id: string, label: string }>, rows: Array<{ id: string, cells: Record<string, string>, selectable?: boolean, selected?: boolean }>, selectionMode?: "none"|"single"|"multiple", caption?: string }\n' +
     '- form: Input form with typed fields. ' +