pybao-cli 1.4.37 → 1.4.39

package/dist/{chunk-EAYSPMFV.js → chunk-HD4IO3I5.js}

@@ -15,68 +15,77 @@ import {
   NotebookEditTool,
   SkillTool,
   SlashCommandTool,
-  TodoWriteTool,
   WebFetchTool,
   WebSearchTool,
   applyMarkdown,
+  buildTaskGraph,
+  calculateReadyBlocked,
   countTokens,
+  findTaskCycles,
   getAgentPrompt,
   getMaxThinkingTokens,
   hasPermissionsToUseTool,
   hasReadPermission,
   hasWritePermission,
   query
-} from "./chunk-LKVOJGOX.js";
+} from "./chunk-RS2N2KBH.js";
 import {
   queryLLM
-} from "./chunk-VLPRSVXT.js";
+} from "./chunk-E5EB22W4.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-3UUOVYVA.js";
+} from "./chunk-VFQU3JSH.js";
 import {
-  generateAgentId
-} from "./chunk-5N7MDY6T.js";
+  TaskStoreConflictError,
+  createTask,
+  emitReminderEvent,
+  generateAgentId,
+  getTask,
+  getTaskListPaths,
+  listTasks,
+  updateTask
+} from "./chunk-AI7FJQR4.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-N4AX7MAG.js";
+} from "./chunk-KNLFFHBT.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-A6CGJVI5.js";
+} from "./chunk-DLBWS3IW.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-VNOOSZ37.js";
+} from "./chunk-NMJYV37P.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-42XD5HC6.js";
+} from "./chunk-7TGWBYFN.js";
 import {
   getModelManager
-} from "./chunk-5EVKZGDP.js";
+} from "./chunk-4LXZDGCO.js";
 import {
   getContext
-} from "./chunk-WZFW5MLS.js";
+} from "./chunk-GXHSGPIF.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-CWSAGAMM.js";
+} from "./chunk-6KSM5M7T.js";
 import {
   getTheme
-} from "./chunk-C5PFCHI6.js";
+} from "./chunk-GD43B2GV.js";
 import {
   debug
-} from "./chunk-ADVVJQQL.js";
+} from "./chunk-O5OT26P6.js";
 import {
   BunShell,
   getCwd,
@@ -87,7 +96,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-YA6QWTQZ.js";
+} from "./chunk-ZGVGFR4C.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -766,7 +775,7 @@ async function analyzeOutputWithLsp(output, exitCode) {
   if (exitCode !== 0 || errorCount > 0 || warningCount > 0) {
     try {
       const { isAbsolute: isAbsolute3, resolve: resolve4 } = await import("path");
-      const { getSessionRoot: getSessionRoot2 } = await import("./state-A5SI47U2.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-4AIVX6VM.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1139,7 +1148,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-36PBULHA.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-IXEAYT4K.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -2988,6 +2997,758 @@ var TaskTool = {
   }
 };
 
+// src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
+import { z as z9 } from "zod";
+
+// src/utils/session/taskToolUtils.ts
+function getTaskDependencySummary(task) {
+  return {
+    blocks: task.blocks ?? [],
+    blockedBy: task.blockedBy ?? [],
+    parent: task.parent,
+    related: task.related ?? []
+  };
+}
+function toTaskSummary(task) {
+  return {
+    task,
+    deps: getTaskDependencySummary(task)
+  };
+}
+function createTaskToolError(params) {
+  return {
+    error: {
+      type: params.type,
+      message: params.message,
+      code: params.code,
+      details: params.details
+    }
+  };
+}
+
+// src/tools/interaction/TaskCreateTool/prompt.ts
+var DESCRIPTION6 = "Create a new task in the task list with optional status and dependencies.";
+var PROMPT6 = `Use this tool to create a new task in the current task list. It is the entry point for planning multi-step work.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+1. You need to add a task with structured fields (subject, status, tags).
+2. You want to seed a plan for multi-step work before implementation starts.
+3. You need to define dependencies (blocks, blockedBy, parent, related) at creation time.
+4. You need to align with a user request to create a task list or plan.
+
+## When NOT to Use This Tool
+- You need to modify an existing task (use TaskUpdate).
+Skip using this tool when:
+1. You only need to read task data (use TaskGet or TaskList).
+2. You need to modify an existing task (use TaskUpdate).
+3. You are only reporting progress without changing any task fields.
+- subject is required.
+NOTE that you should not use this tool if you are only updating status or details of an existing task.
+
+## Input Notes
+- subject is required.
+- listId is optional; omit to use the default list.
+- Dependencies are validated for cycles; invalid cycles will be rejected.
+- baseVersion is set automatically for new tasks.
+- status can be open, in_progress, blocked, done, or archived.
+- activeForm will be generated from subject if omitted.
+- blocks and blockedBy are always stored as arrays (empty when not used).
+- description and blockedBy are kept separate in JSON; any joining is only for terminal rendering.
+- Task ordering relies on task id; do not use priority fields.
+
+## Status Notes
+- Use blocked when dependencies prevent work and fill blockedBy.
+
+## Examples of When to Use TaskCreate
+
+<example>
+User: I need to implement user registration, product catalog, and checkout.
+Assistant: I will create tasks for each feature.
+*Creates tasks:*
+1. User registration
+2. Product catalog
+3. Checkout flow
+</example>
+
+<example>
+User: Please add tests and run lint after the refactor.
+Assistant: I'll seed tasks for the refactor and verification steps.
+*Creates tasks:*
+1. Refactor target module
+2. Add tests
+3. Run lint and typecheck
+</example>
+
+<example>
+User: The API task depends on database schema changes.
+Assistant: I'll create tasks with dependencies.
+*Creates tasks:*
+1. Update database schema
+2. Implement API endpoints (blockedBy: schema task)
+</example>
+`;
+
+// src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
+var inputSchema9 = z9.strictObject({
+  listId: z9.string().optional(),
+  subject: z9.string().min(1),
+  description: z9.string().optional(),
+  activeForm: z9.string().optional(),
+  status: z9.enum(["open", "in_progress", "blocked", "done", "archived"]).optional(),
+  tags: z9.array(z9.string()).optional(),
+  assignee: z9.string().optional(),
+  metadata: z9.record(z9.string()).optional(),
+  archived: z9.boolean().optional(),
+  blocks: z9.array(z9.string()).optional(),
+  blockedBy: z9.array(z9.string()).optional(),
+  parent: z9.string().optional(),
+  related: z9.array(z9.string()).optional(),
+  legacyTodoId: z9.string().optional()
+});
+var TaskCreateTool = {
+  name: "TaskCreate",
+  cachedDescription: DESCRIPTION6,
+  async description() {
+    return DESCRIPTION6;
+  },
+  async prompt() {
+    return PROMPT6;
+  },
+  inputSchema: inputSchema9,
+  userFacingName() {
+    return "TaskCreate";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output, null, 2);
+  },
+  renderToolUseMessage() {
+    return null;
+  },
+  async *call(input) {
+    try {
+      const subject = input.subject;
+      const title = subject;
+      const tasks = listTasks({ listId: input.listId });
+      const nextId = Math.max(
+        0,
+        ...tasks.map((task2) => Number(task2.id)).filter((value) => !Number.isNaN(value))
+      ) + 1;
+      const now = Date.now();
+      const candidateTask = {
+        id: String(nextId),
+        subject,
+        title,
+        description: input.description,
+        activeForm: input.activeForm,
+        status: input.status ?? "open",
+        tags: input.tags,
+        assignee: input.assignee,
+        metadata: input.metadata,
+        archived: input.archived,
+        blocks: input.blocks,
+        blockedBy: input.blockedBy,
+        parent: input.parent,
+        related: input.related,
+        createdAt: now,
+        updatedAt: now,
+        baseVersion: 1,
+        version: 1,
+        legacyTodoId: input.legacyTodoId
+      };
+      const candidateTasks = [...tasks, candidateTask];
+      const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
+      if (cycles.length > 0) {
+        yield {
+          type: "result",
+          data: createTaskToolError({
+            type: "validation",
+            code: "TASK_CYCLE_DETECTED",
+            message: "Task dependency cycle detected",
+            details: { cycles }
+          })
+        };
+        return;
+      }
+      const task = createTask(
+        {
+          subject,
+          description: input.description,
+          activeForm: input.activeForm,
+          status: input.status,
+          tags: input.tags,
+          assignee: input.assignee,
+          metadata: input.metadata,
+          archived: input.archived,
+          blocks: input.blocks,
+          blockedBy: input.blockedBy,
+          parent: input.parent,
+          related: input.related,
+          legacyTodoId: input.legacyTodoId
+        },
+        { listId: input.listId }
+      );
+      const { listId } = getTaskListPaths(input.listId);
+      emitReminderEvent("task.created", {
+        listId,
+        taskId: task.id,
+        task,
+        timestamp: Date.now()
+      });
+      yield {
+        type: "result",
+        data: {
+          listId,
+          item: toTaskSummary(task)
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Task create failed";
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "unknown",
+          message
+        })
+      };
+    }
+  }
+};
+
+// src/tools/interaction/TaskGetTool/TaskGetTool.tsx
+import { z as z10 } from "zod";
+
+// src/tools/interaction/TaskGetTool/prompt.ts
+var DESCRIPTION7 = "Fetch a single task by id from the task list.";
+var PROMPT7 = `Use this tool to fetch a single task by id.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. You need details for one task to confirm its fields, status, or dependencies.
+2. You need the latest version/baseVersion before updating a task.
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. You need multiple tasks or readiness info (use TaskList).
+2. You need to modify a task (use TaskUpdate) or create one (use TaskCreate).
+
+NOTE that TaskGet returns a single task only; use TaskList for summaries or readiness.
+
+## Input Notes
+- taskId is required.
+- listId is optional; omit to use the default list.
+
+## Examples of When to Use TaskGet
+
+<example>
+User: Can you check the status of task t-17 before updating it?
+Assistant: I'll fetch the task details first.
+*Fetches task t-17*
+</example>
+`;
+
+// src/tools/interaction/TaskGetTool/TaskGetTool.tsx
+var inputSchema10 = z10.strictObject({
+  listId: z10.string().optional(),
+  taskId: z10.string().min(1)
+});
+var TaskGetTool = {
+  name: "TaskGet",
+  cachedDescription: DESCRIPTION7,
+  async description() {
+    return DESCRIPTION7;
+  },
+  async prompt() {
+    return PROMPT7;
+  },
+  inputSchema: inputSchema10,
+  userFacingName() {
+    return "TaskGet";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output, null, 2);
+  },
+  renderToolUseMessage() {
+    return null;
+  },
+  async *call(input) {
+    const { listId } = getTaskListPaths(input.listId);
+    const task = getTask(input.taskId, { listId: input.listId });
+    if (!task) {
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "not_found",
+          code: "TASK_NOT_FOUND",
+          message: `Task ${input.taskId} not found`,
+          details: { taskId: input.taskId, listId }
+        })
+      };
+      return;
+    }
+    yield {
+      type: "result",
+      data: {
+        listId,
+        item: toTaskSummary(task)
+      }
+    };
+  }
+};
+
+// src/tools/interaction/TaskListTool/TaskListTool.tsx
+import { z as z11 } from "zod";
+
+// src/tools/interaction/TaskListTool/prompt.ts
+var DESCRIPTION8 = "List tasks in a task list, optionally filtered by status with ready/blocked breakdown.";
+var PROMPT8 = `Use this tool to list tasks and understand readiness. It returns ready and blocked groupings to help prioritize work.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. You need a list of tasks for a listId (or default list).
+2. You need ready/blocked calculations to prioritize work.
+3. You need to filter by status.
+4. You want a quick summary of what can be started now.
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. You need a single task by id (use TaskGet).
+2. You need to create or update tasks (use TaskCreate or TaskUpdate).
+
+NOTE that TaskList is for summaries and readiness; use TaskGet for details.
+
+## Input Notes
+- listId is optional; omit to use the default list.
+- status filters the returned items; omit to exclude archived tasks by default.
+- includeBlocked=false returns only ready items.
+
+## Examples of When to Use TaskList
+
+<example>
+User: What should we work on next?
+Assistant: I'll list tasks and check readiness.
+*Lists tasks with ready/blocked breakdown*
+</example>
+
+<example>
+User: Show only in-progress items.
+Assistant: I'll list tasks filtered by status.
+*Lists tasks with status filter*
+</example>
+`;
+
+// src/tools/interaction/TaskListTool/TaskListTool.tsx
+var inputSchema11 = z11.strictObject({
+  listId: z11.string().optional(),
+  status: z11.array(z11.enum(["open", "in_progress", "blocked", "done", "archived"])).optional(),
+  includeBlocked: z11.boolean().optional()
+});
+var filterByStatus = (tasks, statuses) => {
+  if (!statuses || statuses.length === 0) {
+    return tasks.filter((item) => item.task.status !== "archived");
+  }
+  const allowed = new Set(statuses);
+  return tasks.filter((item) => allowed.has(item.task.status));
+};
+var TaskListTool = {
+  name: "TaskList",
+  cachedDescription: DESCRIPTION8,
+  async description() {
+    return DESCRIPTION8;
+  },
+  async prompt() {
+    return PROMPT8;
+  },
+  inputSchema: inputSchema11,
+  userFacingName() {
+    return "TaskList";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output, null, 2);
+  },
+  renderToolUseMessage() {
+    return null;
+  },
+  async *call(input) {
+    try {
+      const { listId } = getTaskListPaths(input.listId);
+      const tasks = listTasks({ listId: input.listId });
+      const summaries = tasks.map(toTaskSummary);
+      const filtered = filterByStatus(summaries, input.status);
+      const readyBlocked = calculateReadyBlocked(
+        filtered.map((item) => item.task)
+      );
+      const ready = readyBlocked.ready.map(toTaskSummary);
+      const blocked = readyBlocked.blocked.map(toTaskSummary);
+      const includeBlocked = input.includeBlocked !== false;
+      const items = includeBlocked ? filtered : filtered.filter(
+        (item) => ready.some((entry) => entry.task.id === item.task.id)
+      );
+      yield {
+        type: "result",
+        data: {
+          listId,
+          items,
+          ready,
+          blocked: includeBlocked ? blocked : []
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Task list failed";
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "unknown",
+          message
+        })
+      };
+    }
+  }
+};
+
+// src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
+import { z as z12 } from "zod";
+
+// src/tools/interaction/TaskUpdateTool/prompt.ts
+var DESCRIPTION9 = "Update an existing task, including status, metadata, and dependencies with conflict checks.";
+var PROMPT9 = `Use this tool to update an existing task. It is the primary way to track progress and adjust task details.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. You need to change task fields (subject/description/status/tags).
+2. You need to adjust dependencies (blocks, blockedBy, parent, related).
+3. You need optimistic concurrency control with baseVersion/version.
+4. You are moving a task across states (open \u2192 in_progress \u2192 done).
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. You need to create a new task (use TaskCreate).
+2. You only need to read tasks (use TaskGet or TaskList).
+
+NOTE that TaskUpdate requires the correct baseVersion or version when concurrency checks are enabled.
+
+## Input Notes
+- taskId is required.
+- listId is optional; omit to use the default list.
+- If you provide status=done/archived and a parent exists, parent must already be completed.
+- Dependencies are validated for cycles; invalid cycles will be rejected.
+- Use baseVersion or version for concurrency checks; allowMerge can relax conflicts.
+- activeForm will be generated from subject if omitted.
+- blocks and blockedBy are always stored as arrays (empty when not used).
+- description and blockedBy are kept separate in JSON; any joining is only for terminal rendering.
+- Task ordering relies on task id; do not use priority fields.
+
+## Status Notes
+- Use in_progress for the task you are actively working on.
+- Use blocked when dependencies prevent progress and set blockedBy.
+- Use done or archived only when all child/parent constraints are satisfied.
+
+## Examples of When to Use TaskUpdate
+
+<example>
+User: Mark the API task as in progress.
+Assistant: I'll update the task status.
+*Updates task status to in_progress*
+</example>
+
+<example>
+User: The UI task depends on the API task now.
+Assistant: I'll update dependencies.
+*Updates blockedBy to include the API task*
+</example>
+
+<example>
+User: The task update failed due to version conflict.
+Assistant: I'll refetch the task and retry with the latest baseVersion.
+*Fetches task, then updates with baseVersion*
+</example>
+`;
+
+// src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
+var isCompletedStatus = (status) => status === "done" || status === "archived";
+var normalizeDeps = (items) => [...items ?? []].filter(Boolean).sort();
+var depsChanged = (prev, next) => {
+  if (prev.parent !== next.parent) return true;
+  const prevBlocks = normalizeDeps(prev.blocks);
+  const nextBlocks = normalizeDeps(next.blocks);
+  if (prevBlocks.length !== nextBlocks.length) return true;
+  for (let i = 0; i < prevBlocks.length; i += 1) {
+    if (prevBlocks[i] !== nextBlocks[i]) return true;
+  }
+  const prevBlockedBy = normalizeDeps(prev.blockedBy);
+  const nextBlockedBy = normalizeDeps(next.blockedBy);
+  if (prevBlockedBy.length !== nextBlockedBy.length) return true;
+  for (let i = 0; i < prevBlockedBy.length; i += 1) {
+    if (prevBlockedBy[i] !== nextBlockedBy[i]) return true;
+  }
+  const prevRelated = normalizeDeps(prev.related);
+  const nextRelated = normalizeDeps(next.related);
+  if (prevRelated.length !== nextRelated.length) return true;
+  for (let i = 0; i < prevRelated.length; i += 1) {
+    if (prevRelated[i] !== nextRelated[i]) return true;
+  }
+  return false;
+};
+var getDepsSnapshot = (task) => ({
+  blocks: task.blocks ?? [],
+  blockedBy: task.blockedBy ?? [],
+  parent: task.parent,
+  related: task.related ?? []
+});
+var inputSchema12 = z12.strictObject({
+  listId: z12.string().optional(),
+  taskId: z12.string().min(1),
+  subject: z12.string().optional(),
+  description: z12.string().optional(),
+  activeForm: z12.string().optional(),
+  status: z12.enum(["open", "in_progress", "blocked", "done", "archived"]).optional(),
+  tags: z12.array(z12.string()).optional(),
+  assignee: z12.string().optional(),
+  metadata: z12.record(z12.string()).optional(),
+  archived: z12.boolean().optional(),
+  blocks: z12.array(z12.string()).optional(),
+  blockedBy: z12.array(z12.string()).optional(),
+  parent: z12.string().optional(),
+  related: z12.array(z12.string()).optional(),
+  baseVersion: z12.number().optional(),
+  version: z12.number().optional(),
+  allowMerge: z12.boolean().optional(),
+  legacyTodoId: z12.string().optional()
+});
+var TaskUpdateTool = {
+  name: "TaskUpdate",
+  cachedDescription: DESCRIPTION9,
+  async description() {
+    return DESCRIPTION9;
+  },
+  async prompt() {
+    return PROMPT9;
+  },
+  inputSchema: inputSchema12,
+  userFacingName() {
+    return "TaskUpdate";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output, null, 2);
+  },
+  renderToolUseMessage() {
+    return null;
+  },
+  async *call(input) {
+    const { listId } = getTaskListPaths(input.listId);
+    const existing = getTask(input.taskId, { listId: input.listId });
+    if (!existing) {
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "not_found",
+          code: "TASK_NOT_FOUND",
+          message: `Task ${input.taskId} not found`,
+          details: { taskId: input.taskId, listId }
+        })
+      };
+      return;
+    }
+    const tasks = listTasks({ listId: input.listId });
+    const subject = input.subject ?? existing.subject;
+    const title = subject;
+    const updatedTask = {
+      ...existing,
+      subject,
+      title,
+      description: input.description ?? existing.description,
+      activeForm: input.activeForm ?? existing.activeForm,
+      status: input.status ?? existing.status,
+      tags: input.tags ?? existing.tags,
+      assignee: input.assignee ?? existing.assignee,
+      metadata: input.metadata ?? existing.metadata,
+      archived: input.archived ?? existing.archived,
+      blocks: input.blocks ?? existing.blocks,
+      blockedBy: input.blockedBy ?? existing.blockedBy,
+      parent: input.parent ?? existing.parent,
+      related: input.related ?? existing.related,
+      legacyTodoId: input.legacyTodoId ?? existing.legacyTodoId
+    };
+    const candidateTasks = tasks.map(
+      (task) => task.id === existing.id ? updatedTask : task
+    );
+    const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
+    if (cycles.length > 0) {
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "validation",
+          code: "TASK_CYCLE_DETECTED",
+          message: "Task dependency cycle detected",
+          details: { cycles }
+        })
+      };
+      return;
+    }
+    if (input.status && isCompletedStatus(input.status)) {
+      const parentId = updatedTask.parent;
+      if (parentId) {
+        const parentTask = tasks.find((task) => task.id === parentId);
+        if (!parentTask || !isCompletedStatus(parentTask.status)) {
+          yield {
+            type: "result",
+            data: createTaskToolError({
+              type: "validation",
+              code: "TASK_PARENT_INCOMPLETE",
+              message: "Cannot complete task while parent is incomplete",
+              details: {
+                taskId: existing.id,
+                parentId
+              }
+            })
+          };
+          return;
+        }
+      }
+    }
+    try {
+      const baseVersion = input.baseVersion ?? input.version;
+      const result = updateTask(
+        input.taskId,
+        {
+          subject: input.subject,
+          description: input.description,
+          activeForm: input.activeForm,
+          status: input.status,
+          tags: input.tags,
+          assignee: input.assignee,
+          metadata: input.metadata,
+          archived: input.archived,
+          blocks: input.blocks,
+          blockedBy: input.blockedBy,
+          parent: input.parent,
+          related: input.related,
+          baseVersion,
+          legacyTodoId: input.legacyTodoId
+        },
+        { listId: input.listId, allowMerge: input.allowMerge }
+      );
+      emitReminderEvent("task.updated", {
+        listId,
+        taskId: result.task.id,
+        task: result.task,
+        timestamp: Date.now()
+      });
+      if (existing.status !== result.task.status) {
+        emitReminderEvent("task.status_changed", {
+          listId,
+          taskId: result.task.id,
+          previousStatus: existing.status,
+          status: result.task.status,
+          timestamp: Date.now()
+        });
+      }
+      if (depsChanged(existing, result.task)) {
+        emitReminderEvent("task.deps_changed", {
+          listId,
+          taskId: result.task.id,
+          previousDeps: getDepsSnapshot(existing),
+          deps: getDepsSnapshot(result.task),
+          timestamp: Date.now()
+        });
+      }
+      yield {
+        type: "result",
+        data: {
+          listId,
+          item: toTaskSummary(result.task)
+        }
+      };
+    } catch (error) {
+      if (error instanceof TaskStoreConflictError) {
+        emitReminderEvent("task:conflict_detected", {
+          listId,
+          taskId: error.taskId,
+          expected: error.expectedBaseVersion,
+          actual: error.actualBaseVersion,
+          timestamp: Date.now()
+        });
+        yield {
+          type: "result",
+          data: createTaskToolError({
+            type: "conflict",
+            code: error.code,
+            message: error.message,
+            details: {
+              taskId: error.taskId,
+              expected: error.expectedBaseVersion,
+              actual: error.actualBaseVersion
+            }
+          })
+        };
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Task update failed";
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "unknown",
+          message
+        })
+      };
+    }
+  }
+};
+
 // src/tools/index.ts
 var getAllTools = () => [
   TaskTool,
@@ -3004,7 +3765,10 @@ var getAllTools = () => [
   FileWriteTool,
   DeleteTool,
   NotebookEditTool,
-  TodoWriteTool,
+  TaskCreateTool,
+  TaskGetTool,
+  TaskUpdateTool,
+  TaskListTool,
   WebFetchTool,
   WebSearchTool,
   AskUserQuestionTool,