ummaya 0.2.4 → 0.2.5

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

@@ -0,0 +1,247 @@
+import type { ToolResult, ToolUseContext } from '../../Tool.js'
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
+import {
+  blockTask,
+  deleteTask,
+  getTask,
+  getTaskListId,
+  type Task,
+  type TaskStatus,
+  updateTask,
+} from '../../utils/tasks.js'
+import { getAgentName, getTeammateColor } from '../../utils/teammate.js'
+import { writeToMailbox } from '../../utils/teammateMailbox.js'
+import { buildAgentSupportMetadata } from '../AgentTool/orchestrationSupport.js'
+import {
+  collectCompletedHookErrors,
+  needsVerificationNudge,
+} from './completion.js'
+import type { Output, TaskUpdateToolInput } from './schemas.js'
+
+type TaskUpdates = {
+  subject?: string
+  description?: string
+  activeForm?: string
+  status?: TaskStatus
+  owner?: string
+  metadata?: Record<string, unknown>
+}
+
+function expandTaskList(context: ToolUseContext): void {
+  context.setAppState(prev => {
+    if (prev.expandedView === 'tasks') return prev
+    return { ...prev, expandedView: 'tasks' }
+  })
+}
+
+function addChangedTextField(
+  updates: TaskUpdates,
+  updatedFields: string[],
+  field: 'subject' | 'description' | 'activeForm' | 'owner',
+  nextValue: string | undefined,
+  currentValue: string | undefined,
+): void {
+  if (nextValue === undefined || nextValue === currentValue) return
+  updates[field] = nextValue
+  updatedFields.push(field)
+}
+
+function applyMetadataUpdate(
+  updates: TaskUpdates,
+  updatedFields: string[],
+  existingTask: Task,
+  metadata: Record<string, unknown> | undefined,
+): void {
+  if (metadata === undefined) return
+
+  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')
+}
+
+function applyImplicitOwner(
+  updates: TaskUpdates,
+  updatedFields: string[],
+  input: TaskUpdateToolInput,
+  existingTask: Task,
+): void {
+  if (
+    !isAgentSwarmsEnabled() ||
+    input.status !== 'in_progress' ||
+    input.owner !== undefined ||
+    existingTask.owner
+  ) {
+    return
+  }
+
+  const agentName = getAgentName()
+  if (!agentName) return
+  updates.owner = agentName
+  updatedFields.push('owner')
+}
+
+async function notifyNewOwner(
+  taskListId: string,
+  updates: TaskUpdates,
+  input: TaskUpdateToolInput,
+  existingTask: Task,
+): Promise<void> {
+  if (!updates.owner || !isAgentSwarmsEnabled()) return
+
+  const senderName = getAgentName() || 'team-lead'
+  const assignmentMessage = JSON.stringify({
+    type: 'task_assignment',
+    taskId: input.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: getTeammateColor(),
+    },
+    taskListId,
+  )
+}
+
+async function applyDependencyUpdates(
+  taskListId: string,
+  input: TaskUpdateToolInput,
+  existingTask: Task,
+  updatedFields: string[],
+): Promise<void> {
+  if (input.addBlocks && input.addBlocks.length > 0) {
+    const newBlocks = input.addBlocks.filter(
+      id => !existingTask.blocks.includes(id),
+    )
+    for (const blockId of newBlocks) {
+      await blockTask(taskListId, input.taskId, blockId)
+    }
+    if (newBlocks.length > 0) updatedFields.push('blocks')
+  }
+
+  if (input.addBlockedBy && input.addBlockedBy.length > 0) {
+    const newBlockedBy = input.addBlockedBy.filter(
+      id => !existingTask.blockedBy.includes(id),
+    )
+    for (const blockerId of newBlockedBy) {
+      await blockTask(taskListId, blockerId, input.taskId)
+    }
+    if (newBlockedBy.length > 0) updatedFields.push('blockedBy')
+  }
+}
+
+function supportFailure(
+  input: TaskUpdateToolInput,
+  context: ToolUseContext,
+): Output {
+  return {
+    success: false,
+    taskId: input.taskId,
+    updatedFields: [],
+    error: 'Task not found',
+    ...buildAgentSupportMetadata({
+      taskId: input.taskId,
+      parentToolUseId: context.toolUseId,
+    }),
+  }
+}
+
+export async function callTaskUpdateTool(
+  input: TaskUpdateToolInput,
+  context: ToolUseContext,
+): Promise<ToolResult<Output>> {
+  const taskListId = getTaskListId()
+  const supportMetadata = buildAgentSupportMetadata({
+    taskId: input.taskId,
+    parentToolUseId: context.toolUseId,
+  })
+  expandTaskList(context)
+
+  const existingTask = await getTask(taskListId, input.taskId)
+  if (!existingTask) return { data: supportFailure(input, context) }
+
+  if (input.status === 'deleted') {
+    const deleted = await deleteTask(taskListId, input.taskId)
+    return {
+      data: {
+        success: deleted,
+        taskId: input.taskId,
+        updatedFields: deleted ? ['deleted'] : [],
+        error: deleted ? undefined : 'Failed to delete task',
+        statusChange: deleted
+          ? { from: existingTask.status, to: 'deleted' }
+          : undefined,
+        ...supportMetadata,
+      },
+    }
+  }
+
+  const updatedFields: string[] = []
+  const updates: TaskUpdates = {}
+  addChangedTextField(updates, updatedFields, 'subject', input.subject, existingTask.subject)
+  addChangedTextField(updates, updatedFields, 'description', input.description, existingTask.description)
+  addChangedTextField(updates, updatedFields, 'activeForm', input.activeForm, existingTask.activeForm)
+  addChangedTextField(updates, updatedFields, 'owner', input.owner, existingTask.owner)
+  applyImplicitOwner(updates, updatedFields, input, existingTask)
+  applyMetadataUpdate(updates, updatedFields, existingTask, input.metadata)
+
+  if (input.status !== undefined && input.status !== existingTask.status) {
+    if (input.status === 'completed') {
+      const blockingErrors = await collectCompletedHookErrors(
+        input,
+        context,
+        existingTask,
+      )
+      if (blockingErrors.length > 0) {
+        return {
+          data: {
+            success: false,
+            taskId: input.taskId,
+            updatedFields: [],
+            error: blockingErrors.join('\n'),
+            ...supportMetadata,
+          },
+        }
+      }
+    }
+    updates.status = input.status
+    updatedFields.push('status')
+  }
+
+  if (Object.keys(updates).length > 0) {
+    await updateTask(taskListId, input.taskId, updates)
+  }
+  await notifyNewOwner(taskListId, updates, input, existingTask)
+  await applyDependencyUpdates(taskListId, input, existingTask, updatedFields)
+
+  return {
+    data: {
+      success: true,
+      taskId: input.taskId,
+      updatedFields,
+      statusChange:
+        updates.status !== undefined
+          ? { from: existingTask.status, to: updates.status }
+          : undefined,
+      verificationNudgeNeeded: await needsVerificationNudge(
+        taskListId,
+        context,
+        updates,
+      ),
+      ...supportMetadata,
+    },
+  }
+}

package/tui/src/tools/TodoWriteTool/TodoWriteTool.ts

@@ -7,6 +7,7 @@ import { lazySchema } from '../../utils/lazySchema.js'
 import { isTodoV2Enabled } from '../../utils/tasks.js'
 import { TodoListSchema } from '../../utils/todo/types.js'
 import { VERIFICATION_AGENT_TYPE } from '../AgentTool/constants.js'
+import { buildAgentSupportMetadata } from '../AgentTool/orchestrationSupport.js'
 import { TODO_WRITE_TOOL_NAME } from './constants.js'
 import { DESCRIPTION, PROMPT } from './prompt.js'
 
@@ -22,6 +23,10 @@ const outputSchema = lazySchema(() =>
     oldTodos: TodoListSchema().describe('The todo list before the update'),
     newTodos: TodoListSchema().describe('The todo list after the update'),
     verificationNudgeNeeded: z.boolean().optional(),
+    evidenceJoinKey: z.string(),
+    parentToolUseId: z.string(),
+    resumeToken: z.string(),
+    permissionFlow: z.literal('coordinator_parent_round_trip'),
   }),
 )
 type OutputSchema = ReturnType<typeof outputSchema>
@@ -98,18 +103,32 @@ export const TodoWriteTool = buildTool({
         oldTodos,
         newTodos: todos,
         verificationNudgeNeeded,
+        ...buildAgentSupportMetadata({
+          taskId: todoKey,
+          parentToolUseId: context.toolUseId,
+        }),
       },
     }
   },
-  mapToolResultToToolResultBlockParam({ verificationNudgeNeeded }, toolUseID) {
+  mapToolResultToToolResultBlockParam(
+    {
+      verificationNudgeNeeded,
+      evidenceJoinKey,
+      parentToolUseId,
+      resumeToken,
+      permissionFlow,
+    },
+    toolUseID,
+  ) {
     const base = `Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable`
+    const support = `\n\nevidence_join_key: ${evidenceJoinKey}\nparent_tool_use_id: ${parentToolUseId}\nresume_token: ${resumeToken}\npermission_flow: ${permissionFlow}`
     const nudge = verificationNudgeNeeded
       ? `\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 \u2014 only the verifier issues a verdict.`
       : ''
     return {
       tool_use_id: toolUseID,
       type: 'tool_result',
-      content: base + nudge,
+      content: base + support + nudge,
     }
   },
 } satisfies ToolDef<InputSchema, Output>)

package/tui/src/tools/ToolSearchTool/ToolSearchTool.ts

@@ -1,305 +1,26 @@
 import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
-import memoize from 'lodash-es/memoize.js'
-import { z } from 'zod/v4'
 import {
   type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
   logEvent,
 } from '../../services/analytics/index.js'
-import {
-  buildTool,
-  findToolByName,
-  type Tool,
-  type ToolDef,
-  type Tools,
-} from '../../Tool.js'
+import { buildTool, findToolByName, type ToolDef } from '../../Tool.js'
 import { logForDebugging } from '../../utils/debug.js'
-import { lazySchema } from '../../utils/lazySchema.js'
-import { escapeRegExp } from '../../utils/stringUtils.js'
 import { isToolSearchEnabledOptimistic } from '../../utils/toolSearch.js'
+import {
+  clearToolSearchDescriptionCache,
+  maybeInvalidateCache,
+} from './descriptionCache.js'
+import { searchToolsWithKeywords } from './keywordSearch.js'
 import { getPrompt, isDeferredTool, TOOL_SEARCH_TOOL_NAME } from './prompt.js'
+import {
+  buildSearchResult,
+  makeToolReferenceContent,
+} from './resultMapping.js'
+import type { InputSchema, Output, OutputSchema } from './schemas.js'
+import { inputSchema, outputSchema } from './schemas.js'
+import { getToolSearchPool } from './searchPool.js'
 
-export const inputSchema = lazySchema(() =>
-  z.object({
-    query: z
-      .string()
-      .describe(
-        'Query to find deferred tools. Use "select:<tool_name>" for direct selection, or keywords to search.',
-      ),
-    max_results: z
-      .number()
-      .optional()
-      .default(5)
-      .describe('Maximum number of results to return (default: 5)'),
-  }),
-)
-type InputSchema = ReturnType<typeof inputSchema>
-
-export const outputSchema = lazySchema(() =>
-  z.object({
-    matches: z.array(z.string()),
-    query: z.string(),
-    total_deferred_tools: z.number(),
-    pending_mcp_servers: z.array(z.string()).optional(),
-  }),
-)
-type OutputSchema = ReturnType<typeof outputSchema>
-
-export type Output = z.infer<OutputSchema>
-
-// Track deferred tool names to detect when cache should be cleared
-let cachedDeferredToolNames: string | null = null
-
-/**
- * Get a cache key representing the current set of deferred tools.
- */
-function getDeferredToolsCacheKey(deferredTools: Tools): string {
-  return deferredTools
-    .map(t => t.name)
-    .sort()
-    .join(',')
-}
-
-/**
- * Get tool description, memoized by tool name.
- * Used for keyword search scoring.
- */
-const getToolDescriptionMemoized = memoize(
-  async (toolName: string, tools: Tools): Promise<string> => {
-    const tool = findToolByName(tools, toolName)
-    if (!tool) {
-      return ''
-    }
-    return tool.prompt({
-      getToolPermissionContext: async () => ({
-        mode: 'default' as const,
-        additionalWorkingDirectories: new Map(),
-        alwaysAllowRules: {},
-        alwaysDenyRules: {},
-        alwaysAskRules: {},
-        isBypassPermissionsModeAvailable: false,
-      }),
-      tools,
-      agents: [],
-    })
-  },
-  (toolName: string) => toolName,
-)
-
-/**
- * Invalidate the description cache if deferred tools have changed.
- */
-function maybeInvalidateCache(deferredTools: Tools): void {
-  const currentKey = getDeferredToolsCacheKey(deferredTools)
-  if (cachedDeferredToolNames !== currentKey) {
-    logForDebugging(
-      `ToolSearchTool: cache invalidated - deferred tools changed`,
-    )
-    getToolDescriptionMemoized.cache.clear?.()
-    cachedDeferredToolNames = currentKey
-  }
-}
-
-export function clearToolSearchDescriptionCache(): void {
-  getToolDescriptionMemoized.cache.clear?.()
-  cachedDeferredToolNames = null
-}
-
-/**
- * Build the search result output structure.
- */
-function buildSearchResult(
-  matches: string[],
-  query: string,
-  totalDeferredTools: number,
-  pendingMcpServers?: string[],
-): { data: Output } {
-  return {
-    data: {
-      matches,
-      query,
-      total_deferred_tools: totalDeferredTools,
-      ...(pendingMcpServers && pendingMcpServers.length > 0
-        ? { pending_mcp_servers: pendingMcpServers }
-        : {}),
-    },
-  }
-}
-
-/**
- * Parse tool name into searchable parts.
- * Handles both MCP tools (mcp__server__action) and regular tools (CamelCase).
- */
-function parseToolName(name: string): {
-  parts: string[]
-  full: string
-  isMcp: boolean
-} {
-  // Check if it's an MCP tool
-  if (name.startsWith('mcp__')) {
-    const withoutPrefix = name.replace(/^mcp__/, '').toLowerCase()
-    const parts = withoutPrefix.split('__').flatMap(p => p.split('_'))
-    return {
-      parts: parts.filter(Boolean),
-      full: withoutPrefix.replace(/__/g, ' ').replace(/_/g, ' '),
-      isMcp: true,
-    }
-  }
-
-  // Regular tool - split by CamelCase and underscores
-  const parts = name
-    .replace(/([a-z])([A-Z])/g, '$1 $2') // CamelCase to spaces
-    .replace(/_/g, ' ')
-    .toLowerCase()
-    .split(/\s+/)
-    .filter(Boolean)
-
-  return {
-    parts,
-    full: parts.join(' '),
-    isMcp: false,
-  }
-}
-
-/**
- * Pre-compile word-boundary regexes for all search terms.
- * Called once per search instead of tools×terms×2 times.
- */
-function compileTermPatterns(terms: string[]): Map<string, RegExp> {
-  const patterns = new Map<string, RegExp>()
-  for (const term of terms) {
-    if (!patterns.has(term)) {
-      patterns.set(term, new RegExp(`\\b${escapeRegExp(term)}\\b`))
-    }
-  }
-  return patterns
-}
-
-/**
- * Keyword-based search over tool names and descriptions.
- * Handles both MCP tools (mcp__server__action) and regular tools (CamelCase).
- *
- * The model typically queries with:
- * - Server names when it knows the integration (e.g., "slack", "github")
- * - Action words when looking for functionality (e.g., "read", "list", "create")
- * - Tool-specific terms (e.g., "notebook", "shell", "kill")
- */
-async function searchToolsWithKeywords(
-  query: string,
-  deferredTools: Tools,
-  tools: Tools,
-  maxResults: number,
-): Promise<string[]> {
-  const queryLower = query.toLowerCase().trim()
-
-  // Fast path: if query matches a tool name exactly, return it directly.
-  // Handles models using a bare tool name instead of select: prefix (seen
-  // from subagents/post-compaction). Checks deferred first, then falls back
-  // to the full tool set — selecting an already-loaded tool is a harmless
-  // no-op that lets the model proceed without retry churn.
-  const exactMatch =
-    deferredTools.find(t => t.name.toLowerCase() === queryLower) ??
-    tools.find(t => t.name.toLowerCase() === queryLower)
-  if (exactMatch) {
-    return [exactMatch.name]
-  }
-
-  // If query looks like an MCP tool prefix (mcp__server), find matching tools.
-  // Handles models searching by server name with mcp__ prefix.
-  if (queryLower.startsWith('mcp__') && queryLower.length > 5) {
-    const prefixMatches = deferredTools
-      .filter(t => t.name.toLowerCase().startsWith(queryLower))
-      .slice(0, maxResults)
-      .map(t => t.name)
-    if (prefixMatches.length > 0) {
-      return prefixMatches
-    }
-  }
-
-  const queryTerms = queryLower.split(/\s+/).filter(term => term.length > 0)
-
-  // Partition into required (+prefixed) and optional terms
-  const requiredTerms: string[] = []
-  const optionalTerms: string[] = []
-  for (const term of queryTerms) {
-    if (term.startsWith('+') && term.length > 1) {
-      requiredTerms.push(term.slice(1))
-    } else {
-      optionalTerms.push(term)
-    }
-  }
-
-  const allScoringTerms =
-    requiredTerms.length > 0 ? [...requiredTerms, ...optionalTerms] : queryTerms
-  const termPatterns = compileTermPatterns(allScoringTerms)
-
-  // Pre-filter to tools matching ALL required terms in name or description
-  let candidateTools = deferredTools
-  if (requiredTerms.length > 0) {
-    const matches = await Promise.all(
-      deferredTools.map(async tool => {
-        const parsed = parseToolName(tool.name)
-        const description = await getToolDescriptionMemoized(tool.name, tools)
-        const descNormalized = description.toLowerCase()
-        const hintNormalized = tool.searchHint?.toLowerCase() ?? ''
-        const matchesAll = requiredTerms.every(term => {
-          const pattern = termPatterns.get(term)!
-          return (
-            parsed.parts.includes(term) ||
-            parsed.parts.some(part => part.includes(term)) ||
-            pattern.test(descNormalized) ||
-            (hintNormalized && pattern.test(hintNormalized))
-          )
-        })
-        return matchesAll ? tool : null
-      }),
-    )
-    candidateTools = matches.filter((t): t is Tool => t !== null)
-  }
-
-  const scored = await Promise.all(
-    candidateTools.map(async tool => {
-      const parsed = parseToolName(tool.name)
-      const description = await getToolDescriptionMemoized(tool.name, tools)
-      const descNormalized = description.toLowerCase()
-      const hintNormalized = tool.searchHint?.toLowerCase() ?? ''
-
-      let score = 0
-      for (const term of allScoringTerms) {
-        const pattern = termPatterns.get(term)!
-
-        // Exact part match (high weight for MCP server names, tool name parts)
-        if (parsed.parts.includes(term)) {
-          score += parsed.isMcp ? 12 : 10
-        } else if (parsed.parts.some(part => part.includes(term))) {
-          score += parsed.isMcp ? 6 : 5
-        }
-
-        // Full name fallback (for edge cases)
-        if (parsed.full.includes(term) && score === 0) {
-          score += 3
-        }
-
-        // searchHint match — curated capability phrase, higher signal than prompt
-        if (hintNormalized && pattern.test(hintNormalized)) {
-          score += 4
-        }
-
-        // Description match - use word boundary to avoid false positives
-        if (pattern.test(descNormalized)) {
-          score += 2
-        }
-      }
-
-      return { name: tool.name, score }
-    }),
-  )
-
-  return scored
-    .filter(item => item.score > 0)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, maxResults)
-    .map(item => item.name)
-}
+export { clearToolSearchDescriptionCache }
 
 export const ToolSearchTool = buildTool({
   isEnabled() {
@@ -328,7 +49,8 @@ export const ToolSearchTool = buildTool({
   async call(input, { options: { tools }, getAppState }) {
     const { query, max_results = 5 } = input
 
-    const deferredTools = tools.filter(isDeferredTool)
+    const searchableTools = await getToolSearchPool(tools, getAppState, query)
+    const deferredTools = searchableTools.filter(isDeferredTool)
     maybeInvalidateCache(deferredTools)
 
     // Check for MCP servers still connecting
@@ -362,7 +84,7 @@ export const ToolSearchTool = buildTool({
     // is a harmless no-op that lets the model proceed without retry churn.
     const selectMatch = query.match(/^select:(.+)$/i)
     if (selectMatch) {
-      const requested = selectMatch[1]!
+      const requested = (selectMatch[1] ?? '')
         .split(',')
         .map(s => s.trim())
         .filter(Boolean)
@@ -372,7 +94,7 @@ export const ToolSearchTool = buildTool({
       for (const toolName of requested) {
         const tool =
           findToolByName(deferredTools, toolName) ??
-          findToolByName(tools, toolName)
+          findToolByName(searchableTools, toolName)
         if (tool) {
           if (!found.includes(tool.name)) found.push(tool.name)
         } else {
@@ -409,7 +131,7 @@ export const ToolSearchTool = buildTool({
     const matches = await searchToolsWithKeywords(
       query,
       deferredTools,
-      tools,
+      searchableTools,
       max_results,
     )
 
@@ -462,10 +184,7 @@ export const ToolSearchTool = buildTool({
     return {
       type: 'tool_result',
       tool_use_id: toolUseID,
-      content: content.matches.map(name => ({
-        type: 'tool_reference' as const,
-        tool_name: name,
-      })),
-    } as unknown as ToolResultBlockParam
+      content: makeToolReferenceContent(content.matches),
+    }
   },
 } satisfies ToolDef<InputSchema, Output>)