ummaya 0.2.4 → 0.2.5

package/tui/src/tools/TaskUpdateTool/TaskUpdateTool.ts

@@ -1,89 +1,18 @@
-import { feature } from 'bun:bundle'
-import { z } from 'zod/v4'
-import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
 import { buildTool, type ToolDef } from '../../Tool.js'
-import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
-import {
-  executeTaskCompletedHooks,
-  getTaskCompletedHookMessage,
-} from '../../utils/hooks.js'
-import { lazySchema } from '../../utils/lazySchema.js'
-import {
-  blockTask,
-  deleteTask,
-  getTask,
-  getTaskListId,
-  isTodoV2Enabled,
-  listTasks,
-  type TaskStatus,
-  TaskStatusSchema,
-  updateTask,
-} from '../../utils/tasks.js'
-import {
-  getAgentId,
-  getAgentName,
-  getTeammateColor,
-  getTeamName,
-} from '../../utils/teammate.js'
-import { writeToMailbox } from '../../utils/teammateMailbox.js'
-import { VERIFICATION_AGENT_TYPE } from '../AgentTool/constants.js'
+import { isTodoV2Enabled } from '../../utils/tasks.js'
 import { TASK_UPDATE_TOOL_NAME } from './constants.js'
 import { DESCRIPTION, PROMPT } from './prompt.js'
+import {
+  inputSchema,
+  outputSchema,
+  type InputSchema,
+  type Output,
+  type OutputSchema,
+} from './schemas.js'
+import { mapTaskUpdateResultToToolResultBlockParam } from './serialization.js'
+import { callTaskUpdateTool } from './statusUpdate.js'
 
-const inputSchema = lazySchema(() => {
-  // Extended status schema that includes 'deleted' as a special action
-  const TaskUpdateStatusSchema = TaskStatusSchema().or(z.literal('deleted'))
-
-  return z.strictObject({
-    taskId: z.string().describe('The ID of the task to update'),
-    subject: z.string().optional().describe('New subject for the task'),
-    description: z.string().optional().describe('New description for the task'),
-    activeForm: z
-      .string()
-      .optional()
-      .describe(
-        'Present continuous form shown in spinner when in_progress (e.g., "Running tests")',
-      ),
-    status: TaskUpdateStatusSchema.optional().describe(
-      'New status for the task',
-    ),
-    addBlocks: z
-      .array(z.string())
-      .optional()
-      .describe('Task IDs that this task blocks'),
-    addBlockedBy: z
-      .array(z.string())
-      .optional()
-      .describe('Task IDs that block this task'),
-    owner: z.string().optional().describe('New owner for the task'),
-    metadata: z
-      .record(z.string(), z.unknown())
-      .optional()
-      .describe(
-        'Metadata keys to merge into the task. Set a key to null to delete it.',
-      ),
-  })
-})
-type InputSchema = ReturnType<typeof inputSchema>
-
-const outputSchema = lazySchema(() =>
-  z.object({
-    success: z.boolean(),
-    taskId: z.string(),
-    updatedFields: z.array(z.string()),
-    error: z.string().optional(),
-    statusChange: z
-      .object({
-        from: z.string(),
-        to: z.string(),
-      })
-      .optional(),
-    verificationNudgeNeeded: z.boolean().optional(),
-  }),
-)
-type OutputSchema = ReturnType<typeof outputSchema>
-
-export type Output = z.infer<OutputSchema>
+export type { Output } from './schemas.js'
 
 export const TaskUpdateTool = buildTool({
   name: TASK_UPDATE_TOOL_NAME,
@@ -120,287 +49,8 @@ export const TaskUpdateTool = buildTool({
   renderToolUseMessage() {
     return null
   },
-  async call(
-    {
-      taskId,
-      subject,
-      description,
-      activeForm,
-      status,
-      owner,
-      addBlocks,
-      addBlockedBy,
-      metadata,
-    },
-    context,
-  ) {
-    const taskListId = getTaskListId()
-
-    // Auto-expand task list when updating tasks
-    context.setAppState(prev => {
-      if (prev.expandedView === 'tasks') return prev
-      return { ...prev, expandedView: 'tasks' as const }
-    })
-
-    // Check if task exists
-    const existingTask = await getTask(taskListId, taskId)
-    if (!existingTask) {
-      return {
-        data: {
-          success: false,
-          taskId,
-          updatedFields: [],
-          error: 'Task not found',
-        },
-      }
-    }
-
-    const updatedFields: string[] = []
-
-    // Update basic fields if provided and different from current value
-    const updates: {
-      subject?: string
-      description?: string
-      activeForm?: string
-      status?: TaskStatus
-      owner?: string
-      metadata?: Record<string, unknown>
-    } = {}
-    if (subject !== undefined && subject !== existingTask.subject) {
-      updates.subject = subject
-      updatedFields.push('subject')
-    }
-    if (description !== undefined && description !== existingTask.description) {
-      updates.description = description
-      updatedFields.push('description')
-    }
-    if (activeForm !== undefined && activeForm !== existingTask.activeForm) {
-      updates.activeForm = activeForm
-      updatedFields.push('activeForm')
-    }
-    if (owner !== undefined && owner !== existingTask.owner) {
-      updates.owner = owner
-      updatedFields.push('owner')
-    }
-    // Auto-set owner when a teammate marks a task as in_progress without
-    // explicitly providing an owner. This ensures the task list can match
-    // todo items to teammates for showing activity status.
-    if (
-      isAgentSwarmsEnabled() &&
-      status === 'in_progress' &&
-      owner === undefined &&
-      !existingTask.owner
-    ) {
-      const agentName = getAgentName()
-      if (agentName) {
-        updates.owner = agentName
-        updatedFields.push('owner')
-      }
-    }
-    if (metadata !== undefined) {
-      const merged = { ...(existingTask.metadata ?? {}) }
-      for (const [key, value] of Object.entries(metadata)) {
-        if (value === null) {
-          delete merged[key]
-        } else {
-          merged[key] = value
-        }
-      }
-      updates.metadata = merged
-      updatedFields.push('metadata')
-    }
-    if (status !== undefined) {
-      // Handle deletion - delete the task file and return early
-      if (status === 'deleted') {
-        const deleted = await deleteTask(taskListId, taskId)
-        return {
-          data: {
-            success: deleted,
-            taskId,
-            updatedFields: deleted ? ['deleted'] : [],
-            error: deleted ? undefined : 'Failed to delete task',
-            statusChange: deleted
-              ? { from: existingTask.status, to: 'deleted' }
-              : undefined,
-          },
-        }
-      }
-
-      // For regular status updates, validate and apply if different
-      if (status !== existingTask.status) {
-        // Run TaskCompleted hooks when marking a task as completed
-        if (status === 'completed') {
-          const blockingErrors: string[] = []
-
-          const generator = executeTaskCompletedHooks(
-            taskId,
-            existingTask.subject,
-            existingTask.description,
-            getAgentName(),
-            getTeamName(),
-            undefined,
-            context?.abortController?.signal,
-            undefined,
-            context,
-          )
-
-          for await (const result of generator) {
-            if (result.blockingError) {
-              blockingErrors.push(
-                getTaskCompletedHookMessage(result.blockingError),
-              )
-            }
-          }
-
-          if (blockingErrors.length > 0) {
-            return {
-              data: {
-                success: false,
-                taskId,
-                updatedFields: [],
-                error: blockingErrors.join('\n'),
-              },
-            }
-          }
-        }
-
-        updates.status = status
-        updatedFields.push('status')
-      }
-    }
-
-    if (Object.keys(updates).length > 0) {
-      await updateTask(taskListId, taskId, updates)
-    }
-
-    // Notify new owner via mailbox when ownership changes
-    if (updates.owner && isAgentSwarmsEnabled()) {
-      const senderName = getAgentName() || 'team-lead'
-      const senderColor = getTeammateColor()
-      const assignmentMessage = JSON.stringify({
-        type: 'task_assignment',
-        taskId,
-        subject: existingTask.subject,
-        description: existingTask.description,
-        assignedBy: senderName,
-        timestamp: new Date().toISOString(),
-      })
-      await writeToMailbox(
-        updates.owner,
-        {
-          from: senderName,
-          text: assignmentMessage,
-          timestamp: new Date().toISOString(),
-          color: senderColor,
-        },
-        taskListId,
-      )
-    }
-
-    // Add blocks if provided and not already present
-    if (addBlocks && addBlocks.length > 0) {
-      const newBlocks = addBlocks.filter(
-        id => !existingTask.blocks.includes(id),
-      )
-      for (const blockId of newBlocks) {
-        await blockTask(taskListId, taskId, blockId)
-      }
-      if (newBlocks.length > 0) {
-        updatedFields.push('blocks')
-      }
-    }
-
-    // Add blockedBy if provided and not already present (reverse: the blocker blocks this task)
-    if (addBlockedBy && addBlockedBy.length > 0) {
-      const newBlockedBy = addBlockedBy.filter(
-        id => !existingTask.blockedBy.includes(id),
-      )
-      for (const blockerId of newBlockedBy) {
-        await blockTask(taskListId, blockerId, taskId)
-      }
-      if (newBlockedBy.length > 0) {
-        updatedFields.push('blockedBy')
-      }
-    }
-
-    // Structural verification nudge: if the main-thread agent just closed
-    // out a 3+ task list and none of those tasks was a verification step,
-    // append a reminder to the tool result. Fires at the loop-exit moment
-    // where skips happen ("when the last task closed, the loop exited").
-    // Mirrors the TodoWriteTool nudge for V1 sessions; this covers V2
-    // (interactive CLI). TaskUpdateToolOutput is @internal so this field
-    // does not touch the public SDK surface.
-    let verificationNudgeNeeded = false
-    if (
-      feature('VERIFICATION_AGENT') &&
-      getFeatureValue_CACHED_MAY_BE_STALE('tengu_hive_evidence', false) &&
-      !context.agentId &&
-      updates.status === 'completed'
-    ) {
-      const allTasks = await listTasks(taskListId)
-      const allDone = allTasks.every(t => t.status === 'completed')
-      if (
-        allDone &&
-        allTasks.length >= 3 &&
-        !allTasks.some(t => /verif/i.test(t.subject))
-      ) {
-        verificationNudgeNeeded = true
-      }
-    }
-
-    return {
-      data: {
-        success: true,
-        taskId,
-        updatedFields,
-        statusChange:
-          updates.status !== undefined
-            ? { from: existingTask.status, to: updates.status }
-            : undefined,
-        verificationNudgeNeeded,
-      },
-    }
-  },
-  mapToolResultToToolResultBlockParam(content, toolUseID) {
-    const {
-      success,
-      taskId,
-      updatedFields,
-      error,
-      statusChange,
-      verificationNudgeNeeded,
-    } = content as Output
-    if (!success) {
-      // Return as non-error so it doesn't trigger sibling tool cancellation
-      // in StreamingToolExecutor. "Task not found" is a benign condition
-      // (e.g., task list already cleaned up) that the model can handle.
-      return {
-        tool_use_id: toolUseID,
-        type: 'tool_result',
-        content: error || `Task #${taskId} not found`,
-      }
-    }
-
-    let resultContent = `Updated task #${taskId} ${updatedFields.join(', ')}`
-
-    // Add reminder for teammates when they complete a task (supports in-process teammates)
-    if (
-      statusChange?.to === 'completed' &&
-      getAgentId() &&
-      isAgentSwarmsEnabled()
-    ) {
-      resultContent +=
-        '\n\nTask completed. Call TaskList now to find your next available task or see if your work unblocked others.'
-    }
-
-    if (verificationNudgeNeeded) {
-      resultContent += `\n\nNOTE: You just closed out 3+ tasks and none of them was a verification step. Before writing your final summary, spawn the verification agent (subagent_type="${VERIFICATION_AGENT_TYPE}"). You cannot self-assign PARTIAL by listing caveats in your summary — only the verifier issues a verdict.`
-    }
-
-    return {
-      tool_use_id: toolUseID,
-      type: 'tool_result',
-      content: resultContent,
-    }
+  call(input, context) {
+    return callTaskUpdateTool(input, context)
   },
+  mapToolResultToToolResultBlockParam: mapTaskUpdateResultToToolResultBlockParam,
 } satisfies ToolDef<InputSchema, Output>)

package/tui/src/tools/TaskUpdateTool/completion.ts

@@ -0,0 +1,62 @@
+import { feature } from 'bun:bundle'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+import type { ToolUseContext } from '../../Tool.js'
+import {
+  executeTaskCompletedHooks,
+  getTaskCompletedHookMessage,
+} from '../../utils/hooks.js'
+import { listTasks, type Task, type TaskStatus } from '../../utils/tasks.js'
+import { getAgentName, getTeamName } from '../../utils/teammate.js'
+import type { TaskUpdateToolInput } from './schemas.js'
+
+export type CompletionStatusUpdate = {
+  readonly status?: TaskStatus
+}
+
+export async function collectCompletedHookErrors(
+  input: TaskUpdateToolInput,
+  context: ToolUseContext,
+  existingTask: Task,
+): Promise<string[]> {
+  const blockingErrors: string[] = []
+  const generator = executeTaskCompletedHooks(
+    input.taskId,
+    existingTask.subject,
+    existingTask.description,
+    getAgentName(),
+    getTeamName(),
+    undefined,
+    context.abortController.signal,
+    undefined,
+    context,
+  )
+
+  for await (const result of generator) {
+    if (result.blockingError) {
+      blockingErrors.push(getTaskCompletedHookMessage(result.blockingError))
+    }
+  }
+  return blockingErrors
+}
+
+export async function needsVerificationNudge(
+  taskListId: string,
+  context: ToolUseContext,
+  updates: CompletionStatusUpdate,
+): Promise<boolean> {
+  if (
+    !feature('VERIFICATION_AGENT') ||
+    !getFeatureValue_CACHED_MAY_BE_STALE('tengu_hive_evidence', false) ||
+    context.agentId ||
+    updates.status !== 'completed'
+  ) {
+    return false
+  }
+
+  const allTasks = await listTasks(taskListId)
+  return (
+    allTasks.every(task => task.status === 'completed') &&
+    allTasks.length >= 3 &&
+    !allTasks.some(task => /verif/i.test(task.subject))
+  )
+}

package/tui/src/tools/TaskUpdateTool/schemas.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod/v4'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { TaskStatusSchema } from '../../utils/tasks.js'
+
+export const inputSchema = lazySchema(() => {
+  const taskUpdateStatusSchema = TaskStatusSchema().or(z.literal('deleted'))
+
+  return z.strictObject({
+    taskId: z.string().describe('The ID of the task to update'),
+    subject: z.string().optional().describe('New subject for the task'),
+    description: z.string().optional().describe('New description for the task'),
+    activeForm: z
+      .string()
+      .optional()
+      .describe(
+        'Present continuous form shown in spinner when in_progress (e.g., "Running tests")',
+      ),
+    status: taskUpdateStatusSchema.optional().describe(
+      'New status for the task',
+    ),
+    addBlocks: z
+      .array(z.string())
+      .optional()
+      .describe('Task IDs that this task blocks'),
+    addBlockedBy: z
+      .array(z.string())
+      .optional()
+      .describe('Task IDs that block this task'),
+    owner: z.string().optional().describe('New owner for the task'),
+    metadata: z
+      .record(z.string(), z.unknown())
+      .optional()
+      .describe(
+        'Metadata keys to merge into the task. Set a key to null to delete it.',
+      ),
+  })
+})
+
+export const outputSchema = lazySchema(() =>
+  z.object({
+    success: z.boolean(),
+    taskId: z.string(),
+    updatedFields: z.array(z.string()),
+    error: z.string().optional(),
+    statusChange: z
+      .object({
+        from: z.string(),
+        to: z.string(),
+      })
+      .optional(),
+    verificationNudgeNeeded: z.boolean().optional(),
+    evidenceJoinKey: z.string(),
+    parentToolUseId: z.string(),
+    resumeToken: z.string(),
+    permissionFlow: z.literal('coordinator_parent_round_trip'),
+  }),
+)
+
+export type InputSchema = ReturnType<typeof inputSchema>
+export type OutputSchema = ReturnType<typeof outputSchema>
+export type TaskUpdateToolInput = z.infer<InputSchema>
+export type Output = z.infer<OutputSchema>

package/tui/src/tools/TaskUpdateTool/serialization.ts

@@ -0,0 +1,46 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
+import { getAgentId } from '../../utils/teammate.js'
+import { VERIFICATION_AGENT_TYPE } from '../AgentTool/constants.js'
+import type { Output } from './schemas.js'
+
+function supportMetadataText(content: Output): string {
+  return `evidence_join_key: ${content.evidenceJoinKey}
+parent_tool_use_id: ${content.parentToolUseId}
+resume_token: ${content.resumeToken}
+permission_flow: ${content.permissionFlow}`
+}
+
+function completedTaskReminder(content: Output): string {
+  if (content.statusChange?.to !== 'completed') return ''
+  if (!getAgentId() || !isAgentSwarmsEnabled()) return ''
+  return '\n\nTask completed. Call TaskList now to find your next available task or see if your work unblocked others.'
+}
+
+function verificationReminder(content: Output): string {
+  if (!content.verificationNudgeNeeded) return ''
+  return `\n\nNOTE: You just closed out 3+ tasks and none of them was a verification step. Before writing your final summary, spawn the verification agent (subagent_type="${VERIFICATION_AGENT_TYPE}"). You cannot self-assign PARTIAL by listing caveats in your summary — only the verifier issues a verdict.`
+}
+
+export function mapTaskUpdateResultToToolResultBlockParam(
+  content: Output,
+  toolUseID: string,
+): ToolResultBlockParam {
+  const metadata = supportMetadataText(content)
+  if (!content.success) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `${content.error || `Task #${content.taskId} not found`}\n${metadata}`,
+    }
+  }
+
+  const resultContent = `Updated task #${content.taskId} ${content.updatedFields.join(', ')}
+${metadata}${completedTaskReminder(content)}${verificationReminder(content)}`
+
+  return {
+    tool_use_id: toolUseID,
+    type: 'tool_result',
+    content: resultContent,
+  }
+}