pybao-cli 1.4.43 → 1.4.44

package/dist/{chunk-MU5SIPBA.js → chunk-AYD24IXA.js}

@@ -2,13 +2,13 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   ripGrepWithStatus
-} from "./chunk-Z2P4A76S.js";
+} from "./chunk-GXNEEWUV.js";
 import {
   getCurrentProjectConfig,
   getGlobalConfig,
   getOrCreateUserID,
   saveCurrentProjectConfig
-} from "./chunk-I5KAA66I.js";
+} from "./chunk-3TW4UYVK.js";
 import {
   SESSION_ID,
   env,
@@ -16,10 +16,10 @@ import {
   getCwd,
   isContextScanDisabled,
   logError
-} from "./chunk-JFGQ5LGD.js";
+} from "./chunk-ZPGYMC3H.js";
 import {
   MACRO
-} from "./chunk-YMF3HIKQ.js";
+} from "./chunk-KUS6C7RQ.js";
 import {
   __require
 } from "./chunk-I3J4JYES.js";

package/dist/{chunk-NH7SWX57.js → chunk-C4EW6YOH.js}

@@ -4,10 +4,10 @@ import {
   PRODUCT_NAME,
   execFileNoThrow,
   logError
-} from "./chunk-JFGQ5LGD.js";
+} from "./chunk-ZPGYMC3H.js";
 import {
   MACRO
-} from "./chunk-YMF3HIKQ.js";
+} from "./chunk-KUS6C7RQ.js";
 
 // src/utils/session/autoUpdater.ts
 async function getSemver() {
@@ -82,7 +82,7 @@ async function checkAndNotifyUpdate() {
     const [
       { isAutoUpdaterDisabled, getGlobalConfig, saveGlobalConfig },
       { env }
-    ] = await Promise.all([import("./config-WDRMJEUV.js"), import("./env-3BNULBTS.js")]);
+    ] = await Promise.all([import("./config-3HTSPEEU.js"), import("./env-ARPQQ6L4.js")]);
     if (await isAutoUpdaterDisabled()) return;
     if (await env.getIsDocker()) return;
     if (!await env.hasInternetAccess()) return;

package/dist/{chunk-WUCVC3QT.js → chunk-C4JMYHEY.js}

@@ -15,6 +15,7 @@ import {
   NotebookEditTool,
   SkillTool,
   SlashCommandTool,
+  TaskList,
   WebFetchTool,
   WebSearchTool,
   applyMarkdown,
@@ -28,16 +29,16 @@ import {
   hasReadPermission,
   hasWritePermission,
   query
-} from "./chunk-VPQZQRSR.js";
+} from "./chunk-AEJORUDW.js";
 import {
   queryLLM
-} from "./chunk-6YLH7AMI.js";
+} from "./chunk-CZKMFNDC.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-VIGMIQJS.js";
+} from "./chunk-PLIISO75.js";
 import {
   TaskStoreConflictError,
   createTask,
@@ -48,45 +49,45 @@ import {
   getTaskNextId,
   listTasks,
   updateTask
-} from "./chunk-ETXZ5OPA.js";
+} from "./chunk-25W7KIUK.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-BHHF247Q.js";
+} from "./chunk-GSEVRFO7.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-BGMXYCEG.js";
+} from "./chunk-L62LBMEY.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-CGJFRSE7.js";
+} from "./chunk-MUXFNBSK.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-D2YR3LSF.js";
+} from "./chunk-TD7EJUWP.js";
 import {
   getModelManager
-} from "./chunk-UJ76NKSF.js";
+} from "./chunk-5BYVWKN2.js";
 import {
   getContext
-} from "./chunk-MU5SIPBA.js";
+} from "./chunk-AYD24IXA.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-Z2P4A76S.js";
+} from "./chunk-GXNEEWUV.js";
 import {
   getTheme
-} from "./chunk-2AV6L5GN.js";
+} from "./chunk-CZEV7RNL.js";
 import {
   debug
-} from "./chunk-4ZYN5JOV.js";
+} from "./chunk-VZLNH3C6.js";
 import {
   BunShell,
   getCwd,
@@ -97,7 +98,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-JFGQ5LGD.js";
+} from "./chunk-ZPGYMC3H.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -776,7 +777,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-4CMVIHK4.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-O52OCOG6.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1149,7 +1150,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-6ZD5473F.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-I7AZDBN2.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -2999,6 +3000,7 @@ var TaskTool = {
 };
 
 // src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
+import React9 from "react";
 import { z as z9 } from "zod";
 
 // src/utils/session/taskToolUtils.ts
@@ -3048,7 +3050,7 @@ var PROMPT6 = `Use this tool to create a new task in the current task list. It i
 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 (blockedBy, parent, related) at creation time.
+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.
 
 ## When NOT to Use This Tool
@@ -3064,12 +3066,13 @@ NOTE that you should not use this tool if you are only updating status or detail
 - subject is required.
 - listId is optional; omit to use the default list.
 - Dependencies are validated for cycles; invalid cycles will be rejected.
-- For multi-step plans, you MUST create a blockedBy dependency chain (at least linear).
+- For multi-step plans, you need to create structured task list without blockedBy and add dependencies later via TaskUpdate.
 - status can be open, in_progress, blocked, done, or archived.
 - activeForm will be generated from subject if omitted.
 - blockedBy is always stored as an array (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.
+- Use metadata.planFinalized="true" in TaskUpdate when dependencies are ready to be validated globally.
 
 ## Batch Input Notes
 - Use tasks: [...] to create multiple tasks in one call.
@@ -3133,6 +3136,12 @@ Assistant: I'll create tasks in batch and keep your blockedBy values.
 *Creates tasks with tasks array and explicit blockedBy fields*
 </example>
 
+<example>
+User: Let's sketch the task list first and add dependencies later.
+Assistant: I'll create the tasks now and we can add blockedBy with TaskUpdate afterward.
+*Creates tasks without blockedBy*
+</example>
+
 <example>
 User: Create just one task.
 Assistant: I'll create a single task.
@@ -3141,15 +3150,11 @@ Assistant: I'll create a single task.
 `;
 
 // src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
-var shouldEnforceDependencyChain = () => {
-  const value = process.env.PYB_TASK_DEPENDENCY_ENFORCE?.toLowerCase();
-  if (!value) return true;
-  return value !== "false" && value !== "0";
-};
 var shouldAutoChainDependencies = () => {
   const value = process.env.PYB_TASK_AUTOCHAIN?.toLowerCase();
   return value === "true" || value === "1";
 };
+var getMissingBlockedBy = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
 var taskInputSchema = z9.strictObject({
   subject: z9.string().min(1),
   description: z9.string().optional(),
@@ -3251,6 +3256,12 @@ var TaskCreateTool = {
   renderResultForAssistant(output) {
     return JSON.stringify(output, null, 2);
   },
+  renderToolResultMessage(output) {
+    if ("error" in output) {
+      return null;
+    }
+    return /* @__PURE__ */ React9.createElement(TaskList, { listId: output.listId });
+  },
   renderToolUseMessage() {
     return null;
   },
@@ -3296,18 +3307,22 @@ var TaskCreateTool = {
               blockedBy: candidateBatch[index].blockedBy ?? [],
               timestamp: Date.now()
             });
-            if (shouldEnforceDependencyChain()) {
-              yield {
-                type: "result",
-                data: createTaskToolError({
-                  type: "validation",
-                  code: "TASK_DEPENDENCY_CHAIN_REQUIRED",
-                  message: "Task dependency chain required for multi-step plans",
-                  details: { taskId: candidateBatch[index].id, listId: listId2 }
-                })
-              };
-              return;
-            }
+          }
+        }
+        const candidateIds2 = new Set(candidateTasks2.map((task2) => task2.id));
+        for (const task2 of candidateBatch) {
+          const missing2 = getMissingBlockedBy(task2.blockedBy, candidateIds2);
+          if (missing2.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: task2.id, listId: listId2, missingBlockedBy: missing2 }
+              })
+            };
+            return;
           }
         }
         const cycles2 = findTaskCycles(buildTaskGraph(candidateTasks2));
@@ -3394,20 +3409,23 @@ var TaskCreateTool = {
           blockedBy: candidateTask.blockedBy ?? [],
           timestamp: Date.now()
         });
-        if (shouldEnforceDependencyChain()) {
-          yield {
-            type: "result",
-            data: createTaskToolError({
-              type: "validation",
-              code: "TASK_DEPENDENCY_CHAIN_REQUIRED",
-              message: "Task dependency chain required for multi-step plans",
-              details: { taskId: candidateTask.id, listId: listId2 }
-            })
-          };
-          return;
-        }
       }
       const candidateTasks = [...tasks, candidateTask];
+      const candidateIds = new Set(candidateTasks.map((task2) => task2.id));
+      const missing = getMissingBlockedBy(candidateTask.blockedBy, candidateIds);
+      if (missing.length > 0) {
+        const { listId: listId2 } = getTaskListPaths(input.listId);
+        yield {
+          type: "result",
+          data: createTaskToolError({
+            type: "validation",
+            code: "TASK_BLOCKEDBY_NOT_FOUND",
+            message: "BlockedBy tasks must exist in the same list",
+            details: { taskId: candidateTask.id, listId: listId2, missingBlockedBy: missing }
+          })
+        };
+        return;
+      }
       const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
       if (cycles.length > 0) {
         yield {
@@ -3587,6 +3605,7 @@ NOTE that TaskList is for summaries and readiness; use TaskGet for details.
 - 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
 
@@ -3601,6 +3620,12 @@ User: Show only in-progress items.
 Assistant: I'll list tasks filtered by status.
 *Lists tasks with status filter*
 </example>
+
+<example>
+User: We just added dependencies, can we see what's blocked now?
+Assistant: I'll list tasks to show the updated ready/blocked breakdown.
+*Lists tasks with ready/blocked breakdown*
+</example>
 `;
 
 // src/tools/interaction/TaskListTool/TaskListTool.tsx
@@ -3680,6 +3705,7 @@ var TaskListTool = {
 };
 
 // src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
+import React10 from "react";
 import { z as z12 } from "zod";
 
 // src/tools/interaction/TaskUpdateTool/prompt.ts
@@ -3707,7 +3733,8 @@ NOTE that TaskUpdate should be used when you need to persist task changes.
 - 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.
-- For multi-step plans, you MUST keep a blockedBy dependency chain (at least linear).
+- Use TaskUpdate to add blockedBy after tasks are created.
+- You can set metadata.planFinalized="true" to trigger a full dependency validation pass.
 - If an update fails due to a conflict, refetch the task and retry.
 - activeForm will be generated from subject if omitted.
 - blockedBy is always stored as an array (empty when not used).
@@ -3734,26 +3761,26 @@ Assistant: I'll update dependencies.
 </example>
 
 <example>
-User: The task update failed due to a conflict.
-Assistant: I'll refetch the task and retry the update.
-*Fetches task, then updates again*
+User: We've finished adding dependencies and want to finalize the plan.
+Assistant: I'll set metadata.planFinalized to trigger the global validation.
+*Updates metadata.planFinalized to "true"*
 </example>
 
 <example>
-User: Clear blockedBy for the second task in a multi-step plan.
-Assistant: I can't clear blockedBy for a non-first task. I'll keep the dependency chain intact.
-*Keeps blockedBy and updates other fields if needed*
+User: The task update failed due to a conflict.
+Assistant: I'll refetch the task and retry the update.
+*Fetches task, then updates again*
 </example>
 `;
 
 // src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
-var shouldEnforceDependencyChain2 = () => {
-  const value = process.env.PYB_TASK_DEPENDENCY_ENFORCE?.toLowerCase();
-  if (!value) return true;
-  return value !== "false" && value !== "0";
-};
 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 depsChanged = (prev, next) => {
   if (prev.parent !== next.parent) return true;
   const prevBlockedBy = normalizeDeps(prev.blockedBy);
@@ -3776,6 +3803,18 @@ var getDepsSnapshot = (task) => ({
   parent: task.parent,
   related: task.related ?? []
 });
+var getMissingBlockedBy2 = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
+var isPlanFinalized = (metadata) => metadata?.planFinalized === "true";
+var compareTaskId = (left, right) => {
+  const leftValue = Number(left.id);
+  const rightValue = Number(right.id);
+  const leftIsNumber = !Number.isNaN(leftValue);
+  const rightIsNumber = !Number.isNaN(rightValue);
+  if (leftIsNumber && rightIsNumber) return leftValue - rightValue;
+  if (leftIsNumber) return -1;
+  if (rightIsNumber) return 1;
+  return left.id.localeCompare(right.id);
+};
 var inputSchema12 = z12.strictObject({
   listId: z12.string().optional(),
   taskId: z12.string().min(1),
@@ -3824,6 +3863,12 @@ var TaskUpdateTool = {
   renderResultForAssistant(output) {
     return JSON.stringify(output, null, 2);
   },
+  renderToolResultMessage(output) {
+    if ("error" in output || !output.depsChanged) {
+      return null;
+    }
+    return /* @__PURE__ */ React10.createElement(TaskList, { listId: output.listId });
+  },
   renderToolUseMessage() {
     return null;
   },
@@ -3844,6 +3889,7 @@ var TaskUpdateTool = {
     }
     const tasks = listTasks({ listId: input.listId });
     const subject = input.subject ?? existing.subject;
+    const nextBlockedBy = normalizeBlockedBy(input.blockedBy);
     const updatedTask = {
       ...existing,
       subject,
@@ -3854,7 +3900,7 @@ var TaskUpdateTool = {
       assignee: input.assignee ?? existing.assignee,
       metadata: input.metadata ?? existing.metadata,
       archived: input.archived ?? existing.archived,
-      blockedBy: input.blockedBy ?? existing.blockedBy,
+      blockedBy: nextBlockedBy ?? existing.blockedBy,
       parent: input.parent ?? existing.parent,
       related: input.related ?? existing.related,
       legacyTodoId: input.legacyTodoId ?? existing.legacyTodoId
@@ -3862,6 +3908,7 @@ var TaskUpdateTool = {
     const candidateTasks = tasks.map(
       (task) => task.id === existing.id ? updatedTask : 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", {
         listId,
@@ -3869,14 +3916,17 @@ var TaskUpdateTool = {
         blockedBy: updatedTask.blockedBy ?? [],
         timestamp: Date.now()
       });
-      if (shouldEnforceDependencyChain2()) {
+    }
+    if (input.blockedBy) {
+      const missing = getMissingBlockedBy2(updatedTask.blockedBy, candidateIds);
+      if (missing.length > 0) {
         yield {
           type: "result",
           data: createTaskToolError({
             type: "validation",
-            code: "TASK_DEPENDENCY_CHAIN_REQUIRED",
-            message: "Task dependency chain required for multi-step plans",
-            details: { taskId: updatedTask.id, listId }
+            code: "TASK_BLOCKEDBY_NOT_FOUND",
+            message: "BlockedBy tasks must exist in the same list",
+            details: { taskId: updatedTask.id, listId, missingBlockedBy: missing }
           })
         };
         return;
@@ -3895,6 +3945,39 @@ var TaskUpdateTool = {
       };
       return;
     }
+    const nextMetadata = input.metadata ?? existing.metadata;
+    if (isPlanFinalized(nextMetadata) && !isPlanFinalized(existing.metadata)) {
+      const activeTasks = candidateTasks.filter((task) => task.status !== "archived");
+      const ordered = [...activeTasks].sort(compareTaskId);
+      const firstTaskId = ordered[0]?.id;
+      for (const task of activeTasks) {
+        const missing = getMissingBlockedBy2(task.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: task.id, listId, missingBlockedBy: missing }
+            })
+          };
+          return;
+        }
+        if (task.id !== firstTaskId && (task.blockedBy?.length ?? 0) === 0) {
+          yield {
+            type: "result",
+            data: createTaskToolError({
+              type: "validation",
+              code: "TASK_DEPENDENCY_FINALIZE_REQUIRED",
+              message: "Task dependency chain required before planFinalized",
+              details: { taskId: task.id, listId }
+            })
+          };
+          return;
+        }
+      }
+    }
     if (input.status && isCompletedStatus(input.status)) {
       const parentId = updatedTask.parent;
       if (parentId) {
@@ -3929,7 +4012,7 @@ var TaskUpdateTool = {
           assignee: input.assignee,
           metadata: input.metadata,
           archived: input.archived,
-          blockedBy: input.blockedBy,
+          blockedBy: nextBlockedBy,
           parent: input.parent,
           related: input.related,
           baseVersion,
@@ -3937,6 +4020,7 @@ var TaskUpdateTool = {
         },
         { listId: input.listId, allowMerge: input.allowMerge }
       );
+      const didDepsChange = depsChanged(existing, result.task);
       emitReminderEvent("task.updated", {
         listId,
         taskId: result.task.id,
@@ -3952,7 +4036,7 @@ var TaskUpdateTool = {
           timestamp: Date.now()
         });
       }
-      if (depsChanged(existing, result.task)) {
+      if (didDepsChange) {
         emitReminderEvent("task.deps_changed", {
           listId,
           taskId: result.task.id,
@@ -3965,7 +4049,8 @@ var TaskUpdateTool = {
         type: "result",
         data: {
           listId,
-          item: toTaskDetail(result.task)
+          item: toTaskDetail(result.task),
+          depsChanged: didDepsChange
         }
       };
     } catch (error) {