@xortex/xcode 3.0.0

package/tools/TaskOutputTool/constants.ts

@@ -0,0 +1 @@
+export const TASK_OUTPUT_TOOL_NAME = 'TaskOutput'

package/tools/TaskStopTool/TaskStopTool.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod/v4'
+import type { TaskStateBase } from '../../Task.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { stopTask } from '../../tasks/stopTask.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { DESCRIPTION, TASK_STOP_TOOL_NAME } from './prompt.js'
+import { renderToolResultMessage, renderToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    task_id: z
+      .string()
+      .optional()
+      .describe('The ID of the background task to stop'),
+    // shell_id is accepted for backward compatibility with the deprecated KillShell tool
+    shell_id: z.string().optional().describe('Deprecated: use task_id instead'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    message: z.string().describe('Status message about the operation'),
+    task_id: z.string().describe('The ID of the task that was stopped'),
+    task_type: z.string().describe('The type of the task that was stopped'),
+    // Optional: tool outputs are persisted to transcripts and replayed on --resume
+    // without re-validation, so sessions from before this field was added lack it.
+    command: z
+      .string()
+      .optional()
+      .describe('The command or description of the stopped task'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const TaskStopTool = buildTool({
+  name: TASK_STOP_TOOL_NAME,
+  searchHint: 'kill a running background task',
+  // KillShell is the deprecated name - kept as alias for backward compatibility
+  // with existing transcripts and SDK users
+  aliases: ['KillShell'],
+  maxResultSizeChars: 100_000,
+  userFacingName: () => (process.env.USER_TYPE === 'ant' ? '' : 'Stop Task'),
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  shouldDefer: true,
+  isConcurrencySafe() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.task_id ?? input.shell_id ?? ''
+  },
+  async validateInput({ task_id, shell_id }, { getAppState }) {
+    // Support both task_id and shell_id (deprecated KillShell compat)
+    const id = task_id ?? shell_id
+    if (!id) {
+      return {
+        result: false,
+        message: 'Missing required parameter: task_id',
+        errorCode: 1,
+      }
+    }
+
+    const appState = getAppState()
+    const task = appState.tasks?.[id] as TaskStateBase | undefined
+
+    if (!task) {
+      return {
+        result: false,
+        message: `No task found with ID: ${id}`,
+        errorCode: 1,
+      }
+    }
+
+    if (task.status !== 'running') {
+      return {
+        result: false,
+        message: `Task ${id} is not running (status: ${task.status})`,
+        errorCode: 3,
+      }
+    }
+
+    return { result: true }
+  },
+  async description() {
+    return `Stop a running background task by ID`
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: jsonStringify(output),
+    }
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  async call(
+    { task_id, shell_id },
+    { getAppState, setAppState, abortController },
+  ) {
+    // Support both task_id and shell_id (deprecated KillShell compat)
+    const id = task_id ?? shell_id
+    if (!id) {
+      throw new Error('Missing required parameter: task_id')
+    }
+
+    const result = await stopTask(id, {
+      getAppState,
+      setAppState,
+    })
+
+    return {
+      data: {
+        message: `Successfully stopped task: ${result.taskId} (${result.command})`,
+        task_id: result.taskId,
+        task_type: result.taskType,
+        command: result.command,
+      },
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/tools/TaskStopTool/UI.tsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { Text } from '../../ink.js';
+import { truncateToWidthNoEllipsis } from '../../utils/format.js';
+import type { Output } from './TaskStopTool.js';
+export function renderToolUseMessage(): React.ReactNode {
+  return '';
+}
+const MAX_COMMAND_DISPLAY_LINES = 2;
+const MAX_COMMAND_DISPLAY_CHARS = 160;
+function truncateCommand(command: string): string {
+  const lines = command.split('\n');
+  let truncated = command;
+  if (lines.length > MAX_COMMAND_DISPLAY_LINES) {
+    truncated = lines.slice(0, MAX_COMMAND_DISPLAY_LINES).join('\n');
+  }
+  if (stringWidth(truncated) > MAX_COMMAND_DISPLAY_CHARS) {
+    truncated = truncateToWidthNoEllipsis(truncated, MAX_COMMAND_DISPLAY_CHARS);
+  }
+  return truncated.trim();
+}
+export function renderToolResultMessage(output: Output, _progressMessagesForMessage: unknown[], {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if ("external" === 'ant') {
+    return null;
+  }
+  const rawCommand = output.command ?? '';
+  const command = verbose ? rawCommand : truncateCommand(rawCommand);
+  const suffix = command !== rawCommand ? '… · stopped' : ' · stopped';
+  return <MessageResponse>
+      <Text>
+        {command}
+        {suffix}
+      </Text>
+    </MessageResponse>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/tools/TaskStopTool/prompt.ts

@@ -0,0 +1,8 @@
+export const TASK_STOP_TOOL_NAME = 'TaskStop'
+
+export const DESCRIPTION = `
+- Stops a running background task by its ID
+- Takes a task_id parameter identifying the task to stop
+- Returns a success or failure status
+- Use this tool when you need to terminate a long-running task
+`

package/tools/TaskUpdateTool/TaskUpdateTool.ts

@@ -0,0 +1,406 @@
+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 { TASK_UPDATE_TOOL_NAME } from './constants.js'
+import { DESCRIPTION, PROMPT } from './prompt.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 const TaskUpdateTool = buildTool({
+  name: TASK_UPDATE_TOOL_NAME,
+  searchHint: 'update a task',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'TaskUpdate'
+  },
+  shouldDefer: true,
+  isEnabled() {
+    return isTodoV2Enabled()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    const parts = [input.taskId]
+    if (input.status) parts.push(input.status)
+    if (input.subject) parts.push(input.subject)
+    return parts.join(' ')
+  },
+  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,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/tools/TaskUpdateTool/constants.ts

@@ -0,0 +1 @@
+export const TASK_UPDATE_TOOL_NAME = 'TaskUpdate'

package/tools/TaskUpdateTool/prompt.ts

@@ -0,0 +1,77 @@
+export const DESCRIPTION = 'Update a task in the task list'
+
+export const PROMPT = `Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Mark tasks as resolved:**
+- When you have completed the work described in a task
+- When a task is no longer needed or has been superseded
+- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
+- After resolving, call TaskList to find your next task
+
+- ONLY mark a task as completed when you have FULLY accomplished it
+- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+- When blocked, create a new task describing what needs to be resolved
+- Never mark a task as completed if:
+  - Tests are failing
+  - Implementation is partial
+  - You encountered unresolved errors
+  - You couldn't find necessary files or dependencies
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+- Setting status to \`deleted\` permanently removes the task
+
+**Update task details:**
+- When requirements change or become clearer
+- When establishing dependencies between tasks
+
+## Fields You Can Update
+
+- **status**: The task status (see Status Workflow below)
+- **subject**: Change the task title (imperative form, e.g., "Run tests")
+- **description**: Change the task description
+- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
+- **owner**: Change the task owner (agent name)
+- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
+- **addBlocks**: Mark tasks that cannot start until this one completes
+- **addBlockedBy**: Mark tasks that must complete before this one can start
+
+## Status Workflow
+
+Status progresses: \`pending\` → \`in_progress\` → \`completed\`
+
+Use \`deleted\` to permanently remove a task.
+
+## Staleness
+
+Make sure to read a task's latest state using \`TaskGet\` before updating it.
+
+## Examples
+
+Mark task as in progress when starting work:
+\`\`\`json
+{"taskId": "1", "status": "in_progress"}
+\`\`\`
+
+Mark task as completed after finishing work:
+\`\`\`json
+{"taskId": "1", "status": "completed"}
+\`\`\`
+
+Delete a task:
+\`\`\`json
+{"taskId": "1", "status": "deleted"}
+\`\`\`
+
+Claim a task by setting owner:
+\`\`\`json
+{"taskId": "1", "owner": "my-name"}
+\`\`\`
+
+Set up task dependencies:
+\`\`\`json
+{"taskId": "2", "addBlockedBy": ["1"]}
+\`\`\`
+`