pybao-cli 1.4.50 → 1.4.51

package/dist/{chunk-RW4ITNVB.js → chunk-LAFEZLTD.js}

@@ -20,7 +20,6 @@ import {
   WebSearchTool,
   applyMarkdown,
   buildTaskGraph,
-  calculateReadyBlocked,
   countTokens,
   findTaskCycles,
   getAgentPrompt,
@@ -29,64 +28,67 @@ import {
   hasReadPermission,
   hasWritePermission,
   query
-} from "./chunk-6JSMWPVG.js";
+} from "./chunk-YTUV273Y.js";
 import {
   queryLLM
-} from "./chunk-K7HQMRMK.js";
+} from "./chunk-LAQQRRQR.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-AB22WTOW.js";
+} from "./chunk-YNVGW5VZ.js";
 import {
   TaskStoreConflictError,
   createTask,
   emitReminderEvent,
   generateAgentId,
+  generateTaskListId,
   getTask,
   getTaskListPaths,
   listTasks,
+  runWithTaskListEnv,
+  runWithTaskListId,
   updateTask
-} from "./chunk-INTHXBZY.js";
+} from "./chunk-L2FQX7IL.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-THDYF2NK.js";
+} from "./chunk-KDKXQODT.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-O57TU7BN.js";
+} from "./chunk-5RX62PWR.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-XPPMTVLO.js";
+} from "./chunk-G2FI43IB.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-OOKJ3YEP.js";
+} from "./chunk-DCSAQNHW.js";
 import {
   getModelManager
-} from "./chunk-S4ZD6CIB.js";
+} from "./chunk-ZQAKMVXR.js";
 import {
   getContext
-} from "./chunk-5DMG6XJO.js";
+} from "./chunk-MZ6UJROW.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-DY6LXTDU.js";
+} from "./chunk-PKAVBIO7.js";
 import {
   getTheme
-} from "./chunk-F4YDJQRG.js";
+} from "./chunk-HY24VLOS.js";
 import {
   debug
-} from "./chunk-QMS564WP.js";
+} from "./chunk-6MFZG46W.js";
 import {
   BunShell,
   getCwd,
@@ -97,7 +99,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-HJDETBB6.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -776,7 +778,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-XDFG3NGH.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-T7WQKFBG.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1149,7 +1151,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-AQZ4MHRE.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-TG3EZZOU.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -2728,6 +2730,7 @@ var TaskTool = {
       tools = tools.filter((t) => !disallowedToolNames.has(t.name));
     }
     const agentId = input.resume || generateAgentId();
+    const taskListId = generateTaskListId();
     const baseTranscript = input.resume ? getAgentTranscript(input.resume)?.filter((m) => m.type !== "progress") ?? null : [];
     if (input.resume && baseTranscript === null) {
       throw Error(`No transcript found for agent ID: ${input.resume}`);
@@ -2787,47 +2790,54 @@ var TaskTool = {
         done: Promise.resolve()
       };
       taskRecord.done = (async () => {
-        try {
-          const bgMessages = [...messagesForQuery];
-          const bgTranscriptMessages = [...transcriptMessages];
-          for await (const msg of queryFn(
-            bgMessages,
-            systemPrompt,
-            context,
-            hasPermissionsToUseTool,
-            {
-              abortController: bgAbortController,
-              options: queryOptions,
-              messageId: getLastAssistantMessageId(bgMessages),
-              agentId,
-              readFileTimestamps,
-              setToolJSX: () => {
+        return runWithTaskListId(taskListId, async () => {
+          return runWithTaskListEnv(
+            { ...process.env, PYB_TASK_LIST_ID: taskListId },
+            async () => {
+              try {
+                const bgMessages = [...messagesForQuery];
+                const bgTranscriptMessages = [...transcriptMessages];
+                for await (const msg of queryFn(
+                  bgMessages,
+                  systemPrompt,
+                  context,
+                  hasPermissionsToUseTool,
+                  {
+                    abortController: bgAbortController,
+                    options: queryOptions,
+                    messageId: getLastAssistantMessageId(bgMessages),
+                    agentId,
+                    readFileTimestamps,
+                    setToolJSX: () => {
+                    }
+                  }
+                )) {
+                  bgMessages.push(msg);
+                  bgTranscriptMessages.push(msg);
+                  taskRecord.messages = [...bgTranscriptMessages];
+                  upsertBackgroundAgentTask(taskRecord);
+                }
+                const lastAssistant2 = last(
+                  bgTranscriptMessages.filter((m) => m.type === "assistant")
+                );
+                const content2 = lastAssistant2?.message?.content?.filter(
+                  (b) => b.type === "text"
+                );
+                taskRecord.status = "completed";
+                taskRecord.completedAt = Date.now();
+                taskRecord.resultText = (content2 || []).map((b) => b.text).join("\n");
+                taskRecord.messages = [...bgTranscriptMessages];
+                upsertBackgroundAgentTask(taskRecord);
+                saveAgentTranscript(agentId, bgTranscriptMessages);
+              } catch (e) {
+                taskRecord.status = "failed";
+                taskRecord.completedAt = Date.now();
+                taskRecord.error = e instanceof Error ? e.message : String(e);
+                upsertBackgroundAgentTask(taskRecord);
               }
             }
-          )) {
-            bgMessages.push(msg);
-            bgTranscriptMessages.push(msg);
-            taskRecord.messages = [...bgTranscriptMessages];
-            upsertBackgroundAgentTask(taskRecord);
-          }
-          const lastAssistant2 = last(
-            bgTranscriptMessages.filter((m) => m.type === "assistant")
           );
-          const content2 = lastAssistant2?.message?.content?.filter(
-            (b) => b.type === "text"
-          );
-          taskRecord.status = "completed";
-          taskRecord.completedAt = Date.now();
-          taskRecord.resultText = (content2 || []).map((b) => b.text).join("\n");
-          taskRecord.messages = [...bgTranscriptMessages];
-          upsertBackgroundAgentTask(taskRecord);
-          saveAgentTranscript(agentId, bgTranscriptMessages);
-        } catch (e) {
-          taskRecord.status = "failed";
-          taskRecord.completedAt = Date.now();
-          taskRecord.error = e instanceof Error ? e.message : String(e);
-          upsertBackgroundAgentTask(taskRecord);
-        }
+        });
       })();
       upsertBackgroundAgentTask(taskRecord);
       const output2 = {
@@ -2918,21 +2928,28 @@ var TaskTool = {
     };
     lastProgressEmitAt = Date.now();
     let toolUseCount = 0;
-    for await (const message of queryFn(
-      messagesForQuery,
-      systemPrompt,
-      context,
-      hasPermissionsToUseTool,
-      {
-        abortController,
-        options: queryOptions,
-        messageId: getLastAssistantMessageId(messagesForQuery),
-        agentId,
-        readFileTimestamps,
-        setToolJSX: () => {
-        }
-      }
-    )) {
+    const queryStream = runWithTaskListId(
+      taskListId,
+      () => runWithTaskListEnv(
+        { ...process.env, PYB_TASK_LIST_ID: taskListId },
+        () => queryFn(
+          messagesForQuery,
+          systemPrompt,
+          context,
+          hasPermissionsToUseTool,
+          {
+            abortController,
+            options: queryOptions,
+            messageId: getLastAssistantMessageId(messagesForQuery),
+            agentId,
+            readFileTimestamps,
+            setToolJSX: () => {
+            }
+          }
+        )
+      )
+    );
+    for await (const message of queryStream) {
       messagesForQuery.push(message);
       transcriptMessages.push(message);
       overwriteLog(
@@ -3000,14 +3017,31 @@ var TaskTool = {
 
 // src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
 import React9 from "react";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/utils/session/taskToolUtils.ts
+import { z as z9 } from "zod";
+var jsonValueSchema = z9.lazy(
+  () => z9.union([
+    z9.string(),
+    z9.number(),
+    z9.boolean(),
+    z9.null(),
+    z9.array(jsonValueSchema),
+    z9.record(jsonValueSchema)
+  ])
+);
+var metadataSchema = z9.record(jsonValueSchema);
+function mapStatusToOutput(status) {
+  if (status === "done" || status === "archived") return "completed";
+  if (status === "blocked") return "pending";
+  return status;
+}
 function toTaskListItem(task) {
   return {
     id: task.id,
     subject: task.subject,
-    status: task.status,
+    status: mapStatusToOutput(task.status),
     owner: task.assignee,
     blockedBy: task.blockedBy ?? []
   };
@@ -3018,7 +3052,7 @@ function toTaskDetail(task) {
     subject: task.subject,
     description: task.description,
     activeForm: task.activeForm,
-    status: task.status,
+    status: mapStatusToOutput(task.status),
     tags: task.tags,
     assignee: task.assignee,
     metadata: task.metadata,
@@ -3030,6 +3064,15 @@ function toTaskDetail(task) {
     legacyTodoId: task.legacyTodoId
   };
 }
+function toTaskGetDetail(task) {
+  return {
+    subject: task.subject,
+    description: task.description,
+    status: mapStatusToOutput(task.status),
+    blocks: task.blocks ?? [],
+    blockedBy: task.blockedBy ?? []
+  };
+}
 function createTaskToolError(params) {
   return {
     error: {
@@ -3042,23 +3085,28 @@ function createTaskToolError(params) {
 }
 
 // src/tools/interaction/TaskCreateTool/prompt.ts
-var DESCRIPTION6 = "Create a new task in the task list with optional status.";
+var DESCRIPTION6 = "Initialize new tasks with hierarchy 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 want to create a plan first and add dependencies later.
-4. You need to align with a user request to create a task list or plan.
+
+1. **Complex multi-step tasks** - When a task requires 3 or more distinct steps or actions
+2. **Non-trivial and complex tasks** - Tasks that require careful planning or multiple operations
+3. **User explicitly requests task list** - When the user directly asks you to use the task list
+4. **User provides multiple tasks** - When users provide a list of things to be done (numbered or comma-separated)
+5. **After receiving new instructions** - Immediately capture user requirements as structured a task list or plan with structured fields
 
 ## 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.
+
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
 NOTE that you should not use this tool if you are only updating status or details of an existing task.
 
 ## Input Notes
@@ -3132,19 +3180,11 @@ Assistant: I'll create a single task.
 `;
 
 // 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({ required_error: "activeForm is required" }).min(1),
-  status: z9.enum(["pending", "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(),
-  parent: z9.string().optional(),
-  related: z9.array(z9.string()).optional(),
-  legacyTodoId: z9.string().optional()
+var inputSchema9 = z10.strictObject({
+  subject: z10.string().min(1),
+  description: z10.string().min(1),
+  activeForm: z10.string().min(1).optional(),
+  metadata: metadataSchema.optional()
 });
 var TaskCreateTool = {
   name: "TaskCreate",
@@ -3186,23 +3226,13 @@ var TaskCreateTool = {
   async *call(input) {
     try {
       const subject = input.subject;
-      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,
-          parent: input.parent,
-          related: input.related,
-          legacyTodoId: input.legacyTodoId
-        },
-        { listId: input.listId }
-      );
-      const { listId } = getTaskListPaths(input.listId);
+      const task = createTask({
+        subject,
+        description: input.description,
+        activeForm: input.activeForm,
+        metadata: input.metadata
+      });
+      const { listId } = getTaskListPaths();
       emitReminderEvent("task.created", {
         listId,
         taskId: task.id,
@@ -3230,10 +3260,10 @@ var TaskCreateTool = {
 };
 
 // src/tools/interaction/TaskGetTool/TaskGetTool.tsx
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/tools/interaction/TaskGetTool/prompt.ts
-var DESCRIPTION7 = "Fetch a single task by id from the task list.";
+var DESCRIPTION7 = "Retrieve individual task details";
 var PROMPT7 = `Use this tool to fetch a single task by id.
 
 ## When to Use This Tool
@@ -3264,9 +3294,8 @@ Assistant: I'll fetch the task details first.
 `;
 
 // src/tools/interaction/TaskGetTool/TaskGetTool.tsx
-var inputSchema10 = z10.strictObject({
-  listId: z10.string().optional(),
-  taskId: z10.string().min(1)
+var inputSchema10 = z11.strictObject({
+  taskId: z11.string().min(1)
 });
 var TaskGetTool = {
   name: "TaskGet",
@@ -3300,8 +3329,8 @@ var TaskGetTool = {
     return null;
   },
   async *call(input) {
-    const { listId } = getTaskListPaths(input.listId);
-    const task = getTask(input.taskId, { listId: input.listId });
+    const { listId } = getTaskListPaths();
+    const task = getTask(input.taskId);
     if (!task) {
       yield {
         type: "result",
@@ -3318,17 +3347,17 @@ var TaskGetTool = {
       type: "result",
       data: {
         listId,
-        item: toTaskDetail(task)
+        item: toTaskGetDetail(task)
       }
     };
   }
 };
 
 // src/tools/interaction/TaskListTool/TaskListTool.tsx
-import { z as z11 } from "zod";
+import { z as z12 } 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 DESCRIPTION8 = "List all tasks in current task list.";
 var PROMPT8 = `Use this tool to list tasks and understand readiness. It returns ready and blocked groupings to help prioritize work. TaskList only returns id/subject/status/owner/blockedBy for summaries; use TaskGet for details.
 
 ## When to Use This Tool
@@ -3348,9 +3377,7 @@ Skip using this tool when:
 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.
 - blockedBy may be empty early in planning and will appear as dependencies are added.
 
 ## Examples of When to Use TaskList
@@ -3375,10 +3402,8 @@ Assistant: I'll list tasks to show the updated ready/blocked breakdown.
 `;
 
 // src/tools/interaction/TaskListTool/TaskListTool.tsx
-var inputSchema11 = z11.strictObject({
-  listId: z11.string().optional(),
-  status: z11.array(z11.enum(["pending", "in_progress", "blocked", "done", "archived"])).optional(),
-  includeBlocked: z11.boolean().optional()
+var inputSchema11 = z12.strictObject({
+  status: z12.enum(["pending", "in_progress", "completed"]).optional()
 });
 var filterByStatus = (tasks, statuses) => {
   if (!statuses || statuses.length === 0) {
@@ -3387,6 +3412,12 @@ var filterByStatus = (tasks, statuses) => {
   const allowed = new Set(statuses);
   return tasks.filter((item) => allowed.has(item.status));
 };
+var mapStatusFilterInput = (input) => {
+  if (!input) return void 0;
+  if (input === "completed") return ["done", "archived"];
+  if (input === "pending") return ["pending"];
+  return ["in_progress"];
+};
 var TaskListTool = {
   name: "TaskList",
   cachedDescription: DESCRIPTION8,
@@ -3420,21 +3451,15 @@ var TaskListTool = {
   },
   async *call(input) {
     try {
-      const { listId } = getTaskListPaths(input.listId);
-      const tasks = listTasks({ listId: input.listId });
-      const filtered = filterByStatus(tasks, input.status);
-      const readyBlocked = calculateReadyBlocked(filtered);
-      const ready = readyBlocked.ready.map(toTaskListItem);
-      const blocked = readyBlocked.blocked.map(toTaskListItem);
-      const includeBlocked = input.includeBlocked !== false;
-      const items = includeBlocked ? filtered.map(toTaskListItem) : filtered.filter((item) => ready.some((entry) => entry.id === item.id)).map(toTaskListItem);
+      const { listId } = getTaskListPaths();
+      const tasks = listTasks();
+      const filtered = filterByStatus(tasks, mapStatusFilterInput(input.status));
+      const items = filtered.map(toTaskListItem);
       yield {
         type: "result",
         data: {
           listId,
-          items,
-          ready,
-          blocked: includeBlocked ? blocked : []
+          items
         }
       };
     } catch (error) {
@@ -3452,10 +3477,10 @@ var TaskListTool = {
 
 // src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
 import React10 from "react";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/tools/interaction/TaskUpdateTool/prompt.ts
-var DESCRIPTION9 = "Update an existing task, including status, metadata, and dependencies with conflict checks.";
+var DESCRIPTION9 = "Modify task status, metadata, and dependencies";
 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
@@ -3526,10 +3551,38 @@ Assistant: I'll refetch the task and retry the update.
 // src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
 var isCompletedStatus = (status) => status === "done" || status === "archived";
 var normalizeDeps = (items) => [...items ?? []].filter(Boolean).sort();
-var normalizeBlockedBy = (items) => {
-  if (!items) return void 0;
-  const filtered = items.filter(Boolean);
-  return Array.from(new Set(filtered));
+var mergeDeps = (current, additions) => {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of current ?? []) {
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    merged.push(id);
+  }
+  for (const id of additions ?? []) {
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    merged.push(id);
+  }
+  return merged;
+};
+var mergeMetadata = (existing, updates) => {
+  if (!updates) return existing;
+  const next = { ...existing ?? {} };
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === null) {
+      delete next[key];
+    } else {
+      next[key] = value;
+    }
+  }
+  return Object.keys(next).length > 0 ? next : void 0;
+};
+var mapStatusInput = (status) => {
+  if (!status) return void 0;
+  if (status === "completed") return "done";
+  if (status === "deleted") return "archived";
+  return status;
 };
 var depsChanged = (prev, next) => {
   if (prev.parent !== next.parent) return true;
@@ -3539,6 +3592,12 @@ var depsChanged = (prev, next) => {
   for (let i = 0; i < prevBlockedBy.length; i += 1) {
     if (prevBlockedBy[i] !== nextBlockedBy[i]) 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 prevRelated = normalizeDeps(prev.related);
   const nextRelated = normalizeDeps(next.related);
   if (prevRelated.length !== nextRelated.length) return true;
@@ -3554,7 +3613,10 @@ var getDepsSnapshot = (task) => ({
   related: task.related ?? []
 });
 var getMissingBlockedBy = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
-var isPlanFinalized = (metadata) => metadata?.planFinalized === "true";
+var isPlanFinalized = (metadata) => {
+  const value = metadata?.planFinalized;
+  return value === true || value === "true";
+};
 var compareTaskId = (left, right) => {
   const leftValue = Number(left.id);
   const rightValue = Number(right.id);
@@ -3565,25 +3627,16 @@ var compareTaskId = (left, right) => {
   if (rightIsNumber) return 1;
   return left.id.localeCompare(right.id);
 };
-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(["pending", "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 inputSchema12 = z13.strictObject({
+  taskId: z13.string().min(1),
+  subject: z13.string().optional(),
+  description: z13.string().optional(),
+  activeForm: z13.string().optional(),
+  status: z13.enum(["pending", "in_progress", "completed", "deleted"]).optional(),
+  owner: z13.string().optional(),
+  metadata: metadataSchema.optional(),
+  addBlockedBy: z13.array(z13.string()).optional(),
+  addBlocks: z13.array(z13.string()).optional()
 });
 var TaskUpdateTool = {
   name: "TaskUpdate",
@@ -3623,8 +3676,8 @@ var TaskUpdateTool = {
     return null;
   },
   async *call(input) {
-    const { listId } = getTaskListPaths(input.listId);
-    const existing = getTask(input.taskId, { listId: input.listId });
+    const { listId } = getTaskListPaths();
+    const existing = getTask(input.taskId);
     if (!existing) {
       yield {
         type: "result",
@@ -3637,27 +3690,37 @@ var TaskUpdateTool = {
       };
       return;
     }
-    const tasks = listTasks({ listId: input.listId });
+    const tasks = listTasks();
     const subject = input.subject ?? existing.subject;
-    const nextBlockedBy = normalizeBlockedBy(input.blockedBy);
+    const mergedBlockedBy = mergeDeps(existing.blockedBy, input.addBlockedBy);
+    const mappedStatus = mapStatusInput(input.status);
+    const mergedMetadata = mergeMetadata(existing.metadata, input.metadata);
+    const metadataUpdate = input.metadata;
+    const addBlocksTargets = new Set(
+      (input.addBlocks ?? []).filter((id) => id && id !== existing.id)
+    );
     const updatedTask = {
       ...existing,
       subject,
       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,
-      blockedBy: nextBlockedBy ?? existing.blockedBy,
-      parent: input.parent ?? existing.parent,
-      related: input.related ?? existing.related,
-      legacyTodoId: input.legacyTodoId ?? existing.legacyTodoId
+      status: mappedStatus ?? existing.status,
+      assignee: input.owner ?? existing.assignee,
+      metadata: mergedMetadata ?? existing.metadata,
+      blockedBy: mergedBlockedBy
     };
-    const candidateTasks = tasks.map(
-      (task) => task.id === existing.id ? updatedTask : task
-    );
+    const candidateTasks = tasks.map((task) => {
+      if (task.id === existing.id) {
+        return updatedTask;
+      }
+      if (addBlocksTargets.has(task.id)) {
+        return {
+          ...task,
+          blockedBy: mergeDeps(task.blockedBy, [existing.id])
+        };
+      }
+      return task;
+    });
     const candidateIds = new Set(candidateTasks.map((task) => task.id));
     if (tasks.length > 1 && tasks[0]?.id !== updatedTask.id && (updatedTask.blockedBy?.length ?? 0) === 0) {
       emitReminderEvent("task.dependency_chain_missing", {
@@ -3667,20 +3730,44 @@ var TaskUpdateTool = {
         timestamp: Date.now()
       });
     }
-    if (input.blockedBy) {
-      const missing = getMissingBlockedBy(updatedTask.blockedBy, candidateIds);
-      if (missing.length > 0) {
-        yield {
-          type: "result",
-          data: createTaskToolError({
-            type: "validation",
-            code: "TASK_BLOCKEDBY_NOT_FOUND",
-            message: "BlockedBy tasks must exist in the same list",
-            details: { taskId: updatedTask.id, listId, missingBlockedBy: missing }
-          })
-        };
-        return;
-      }
+    const missingBlockedBy = getMissingBlockedBy(
+      updatedTask.blockedBy,
+      candidateIds
+    );
+    if (missingBlockedBy.length > 0) {
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "validation",
+          code: "TASK_BLOCKEDBY_NOT_FOUND",
+          message: "BlockedBy tasks must exist in the same list",
+          details: {
+            taskId: updatedTask.id,
+            listId,
+            missingBlockedBy
+          }
+        })
+      };
+      return;
+    }
+    const missingBlocks = (input.addBlocks ?? []).filter(
+      (id) => id && !candidateIds.has(id)
+    );
+    if (missingBlocks.length > 0) {
+      yield {
+        type: "result",
+        data: createTaskToolError({
+          type: "validation",
+          code: "TASK_BLOCKEDBY_NOT_FOUND",
+          message: "Blocked tasks must exist in the same list",
+          details: {
+            taskId: updatedTask.id,
+            listId,
+            missingBlocks
+          }
+        })
+      };
+      return;
     }
     const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
     if (cycles.length > 0) {
@@ -3695,7 +3782,7 @@ var TaskUpdateTool = {
       };
       return;
     }
-    const nextMetadata = input.metadata ?? existing.metadata;
+    const nextMetadata = mergedMetadata ?? existing.metadata;
     if (isPlanFinalized(nextMetadata) && !isPlanFinalized(existing.metadata)) {
       const activeTasks = candidateTasks.filter((task) => task.status !== "archived");
       const ordered = [...activeTasks].sort(compareTaskId);
@@ -3728,7 +3815,7 @@ var TaskUpdateTool = {
         }
       }
     }
-    if (input.status && isCompletedStatus(input.status)) {
+    if (mappedStatus && isCompletedStatus(mappedStatus)) {
       const parentId = updatedTask.parent;
       if (parentId) {
         const parentTask = tasks.find((task) => task.id === parentId);
@@ -3750,25 +3837,34 @@ var TaskUpdateTool = {
       }
     }
     try {
-      const baseVersion = input.baseVersion ?? input.version;
+      for (const task of tasks) {
+        if (!addBlocksTargets.has(task.id)) continue;
+        const merged = mergeDeps(task.blockedBy, [existing.id]);
+        const current = normalizeDeps(task.blockedBy);
+        const next = normalizeDeps(merged);
+        let same = current.length === next.length;
+        if (same) {
+          for (let i = 0; i < current.length; i += 1) {
+            if (current[i] !== next[i]) {
+              same = false;
+              break;
+            }
+          }
+        }
+        if (same) continue;
+        updateTask(task.id, { blockedBy: merged });
+      }
       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,
-          blockedBy: nextBlockedBy,
-          parent: input.parent,
-          related: input.related,
-          baseVersion,
-          legacyTodoId: input.legacyTodoId
-        },
-        { listId: input.listId, allowMerge: input.allowMerge }
+          status: mappedStatus,
+          assignee: input.owner,
+          metadata: metadataUpdate,
+          blockedBy: mergedBlockedBy
+        }
       );
       const didDepsChange = depsChanged(existing, result.task);
       emitReminderEvent("task.updated", {