wave-agent-sdk 0.17.1 → 0.17.3

package/dist/tools/taskManagementTools.js

@@ -1,4 +1,21 @@
 import { TASK_CREATE_TOOL_NAME, TASK_GET_TOOL_NAME, TASK_UPDATE_TOOL_NAME, TASK_LIST_TOOL_NAME, } from "../constants/tools.js";
+/**
+ * Helper to record and commit a reversion snapshot for a task file.
+ */
+async function recordSnapshot(context, taskManager, taskId, operation) {
+    if (!context.reversionManager || !context.messageId)
+        return undefined;
+    const snapshotId = await context.reversionManager.recordSnapshot(context.messageId, taskManager.getTaskPath(taskId), operation);
+    await context.reversionManager.commitSnapshot(snapshotId);
+    return snapshotId;
+}
+/**
+ * Helper to update a target task's blocks/blockedBy array and record a reversion snapshot.
+ */
+async function updateTaskField(context, taskManager, targetTask, field, value) {
+    await recordSnapshot(context, taskManager, targetTask.id, "modify");
+    await taskManager.updateTask({ ...targetTask, [field]: value });
+}
 export const taskCreateTool = {
     name: TASK_CREATE_TOOL_NAME,
     config: {
@@ -15,31 +32,12 @@ export const taskCreateTool = {
                     },
                     description: {
                         type: "string",
-                        description: "A detailed description of what needs to be done",
-                    },
-                    status: {
-                        type: "string",
-                        enum: ["pending", "in_progress", "completed", "deleted"],
-                        description: "Initial status of the task. Defaults to 'pending'.",
+                        description: "What needs to be done",
                     },
                     activeForm: {
                         type: "string",
                         description: 'Present continuous form shown in spinner when in_progress (e.g., "Running tests")',
                     },
-                    owner: {
-                        type: "string",
-                        description: "Optional owner of the task.",
-                    },
-                    blocks: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "List of task IDs that this task blocks.",
-                    },
-                    blockedBy: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "List of task IDs that block this task.",
-                    },
                     metadata: {
                         type: "object",
                         description: "Arbitrary metadata to attach to the task",
@@ -78,7 +76,7 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 ## Task Fields
 
 - **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-- **description**: Detailed description of what needs to be done, including context and acceptance criteria
+- **description**: What needs to be done, including context and acceptance criteria
 - **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
 
 **IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status \`pending\`.
@@ -91,32 +89,21 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 - Check TaskList first to avoid creating duplicate tasks`,
     execute: async (args, context) => {
         const taskManager = context.taskManager;
-        if (args.status === "deleted") {
-            return {
-                success: true,
-                content: `Task creation skipped because status was set to 'deleted'.`,
-                shortResult: `Skipped deleted task`,
-            };
-        }
         const task = {
             subject: args.subject,
             description: args.description,
-            status: args.status || "pending",
+            status: "pending",
             activeForm: args.activeForm,
-            owner: args.owner,
-            blocks: args.blocks || [],
-            blockedBy: args.blockedBy || [],
+            owner: undefined,
+            blocks: [],
+            blockedBy: [],
             metadata: args.metadata || {},
         };
         const taskId = await taskManager.createTask(task);
-        if (context.reversionManager && context.messageId) {
-            const taskPath = taskManager.getTaskPath(taskId);
-            const snapshotId = await context.reversionManager.recordSnapshot(context.messageId, taskPath, "create");
-            await context.reversionManager.commitSnapshot(snapshotId);
-        }
+        await recordSnapshot(context, taskManager, taskId, "create");
         return {
             success: true,
-            content: `Task created with ID: ${taskId}`,
+            content: `Task #${taskId} created successfully: ${task.subject}`,
             shortResult: `Created task ${taskId}: ${task.subject}`,
         };
     },
@@ -168,12 +155,24 @@ Returns full task details:
         if (!task) {
             return {
                 success: false,
-                content: `Task with ID ${taskId} not found.`,
+                content: `Task not found`,
             };
         }
+        // Format like Claude Code: structured text instead of raw JSON
+        const lines = [
+            `Task #${task.id}: ${task.subject}`,
+            `Status: ${task.status}`,
+            `Description: ${task.description}`,
+        ];
+        if (task.blockedBy.length > 0) {
+            lines.push(`Blocked by: ${task.blockedBy.map((id) => `#${id}`).join(", ")}`);
+        }
+        if (task.blocks.length > 0) {
+            lines.push(`Blocks: ${task.blocks.map((id) => `#${id}`).join(", ")}`);
+        }
         return {
             success: true,
-            content: JSON.stringify(task, null, 2),
+            content: lines.join("\n"),
         };
     },
 };
@@ -313,160 +312,106 @@ Set up task dependencies:
         if (!existingTask) {
             return {
                 success: false,
-                content: `Task with ID ${taskId} not found.`,
+                content: `Task #${taskId} not found`,
             };
         }
+        // Handle deletion — just delete the task file (like Claude Code)
         if (args.status === "deleted") {
-            // Reciprocal Dependency Cleanup
-            // For each task in the deleted task's blocks list, remove the deleted task's ID from their blockedBy list.
-            for (const targetId of existingTask.blocks) {
-                const targetTask = await taskManager.getTask(targetId);
-                if (targetTask && targetTask.blockedBy.includes(taskId)) {
-                    let targetSnapshotId;
-                    if (context.reversionManager && context.messageId) {
-                        const targetPath = taskManager.getTaskPath(targetId);
-                        targetSnapshotId = await context.reversionManager.recordSnapshot(context.messageId, targetPath, "modify");
-                    }
-                    await taskManager.updateTask({
-                        ...targetTask,
-                        blockedBy: targetTask.blockedBy.filter((id) => id !== taskId),
-                    });
-                    if (context.reversionManager && targetSnapshotId) {
-                        await context.reversionManager.commitSnapshot(targetSnapshotId);
-                    }
-                }
-            }
-            // For each task in the deleted task's blockedBy list, remove the deleted task's ID from their blocks list.
-            for (const targetId of existingTask.blockedBy) {
-                const targetTask = await taskManager.getTask(targetId);
-                if (targetTask && targetTask.blocks.includes(taskId)) {
-                    let targetSnapshotId;
-                    if (context.reversionManager && context.messageId) {
-                        const targetPath = taskManager.getTaskPath(targetId);
-                        targetSnapshotId = await context.reversionManager.recordSnapshot(context.messageId, targetPath, "modify");
-                    }
-                    await taskManager.updateTask({
-                        ...targetTask,
-                        blocks: targetTask.blocks.filter((id) => id !== taskId),
-                    });
-                    if (context.reversionManager && targetSnapshotId) {
-                        await context.reversionManager.commitSnapshot(targetSnapshotId);
-                    }
-                }
-            }
-            // Record delete snapshot for the task itself
-            if (context.reversionManager && context.messageId) {
-                const taskPath = taskManager.getTaskPath(taskId);
-                const deleteSnapshotId = await context.reversionManager.recordSnapshot(context.messageId, taskPath, "delete");
-                await context.reversionManager.commitSnapshot(deleteSnapshotId);
-            }
+            await recordSnapshot(context, taskManager, taskId, "delete");
             await taskManager.deleteTask(taskId);
             return {
                 success: true,
-                content: `Task #${taskId} deleted and removed from disk.`,
+                content: `Task #${taskId} deleted`,
                 shortResult: `Deleted task ${taskId}`,
             };
         }
-        let snapshotId;
-        if (context.reversionManager && context.messageId) {
-            const taskPath = taskManager.getTaskPath(taskId);
-            snapshotId = await context.reversionManager.recordSnapshot(context.messageId, taskPath, "modify");
-        }
+        // Build updates object — only include changed fields
         const updatedFields = [];
-        const updatedTask = {
-            ...existingTask,
-        };
+        const updates = {};
         if (args.subject !== undefined && args.subject !== existingTask.subject) {
-            updatedTask.subject = args.subject;
+            updates.subject = args.subject;
             updatedFields.push("subject");
         }
         if (args.description !== undefined &&
             args.description !== existingTask.description) {
-            updatedTask.description = args.description;
+            updates.description = args.description;
             updatedFields.push("description");
         }
-        if (args.status !== undefined && args.status !== existingTask.status) {
-            updatedTask.status = args.status;
-            updatedFields.push("status");
-        }
         if (args.activeForm !== undefined &&
             args.activeForm !== existingTask.activeForm) {
-            updatedTask.activeForm = args.activeForm;
+            updates.activeForm = args.activeForm;
             updatedFields.push("activeForm");
         }
         if (args.owner !== undefined && args.owner !== existingTask.owner) {
-            updatedTask.owner = args.owner;
+            updates.owner = args.owner;
             updatedFields.push("owner");
         }
+        if (args.status !== undefined && args.status !== existingTask.status) {
+            updates.status = args.status;
+            updatedFields.push("status");
+        }
+        // Merge metadata (null values delete keys)
         if (args.metadata !== undefined) {
-            const newMetadata = { ...(existingTask.metadata || {}) };
+            const merged = { ...(existingTask.metadata ?? {}) };
             for (const [key, value] of Object.entries(args.metadata)) {
                 if (value === null) {
-                    delete newMetadata[key];
+                    delete merged[key];
                 }
                 else {
-                    newMetadata[key] = value;
+                    merged[key] = value;
                 }
             }
-            updatedTask.metadata = newMetadata;
+            updates.metadata = merged;
             updatedFields.push("metadata");
         }
+        // Apply basic field updates
+        if (Object.keys(updates).length > 0) {
+            await recordSnapshot(context, taskManager, taskId, "modify");
+            await taskManager.updateTask({ ...existingTask, ...updates });
+        }
+        // Add blocks: update this task's blocks + reciprocal blockedBy on targets
         if (args.addBlocks !== undefined) {
-            const blocksToAdd = args.addBlocks.filter((id) => !updatedTask.blocks.includes(id));
+            const blocksToAdd = args.addBlocks.filter((id) => !existingTask.blocks.includes(id));
             if (blocksToAdd.length > 0) {
-                updatedTask.blocks = [...updatedTask.blocks, ...blocksToAdd];
+                await recordSnapshot(context, taskManager, taskId, "modify");
+                await taskManager.updateTask({
+                    ...existingTask,
+                    ...updates,
+                    blocks: [...existingTask.blocks, ...blocksToAdd],
+                });
                 updatedFields.push("blocks");
-                // Also update the blockedBy of the target tasks
                 for (const targetId of blocksToAdd) {
                     const targetTask = await taskManager.getTask(targetId);
                     if (targetTask && !targetTask.blockedBy.includes(taskId)) {
-                        let targetSnapshotId;
-                        if (context.reversionManager && context.messageId) {
-                            const targetPath = taskManager.getTaskPath(targetId);
-                            targetSnapshotId = await context.reversionManager.recordSnapshot(context.messageId, targetPath, "modify");
-                        }
-                        await taskManager.updateTask({
-                            ...targetTask,
-                            blockedBy: [...targetTask.blockedBy, taskId],
-                        });
-                        if (context.reversionManager && targetSnapshotId) {
-                            await context.reversionManager.commitSnapshot(targetSnapshotId);
-                        }
+                        await updateTaskField(context, taskManager, targetTask, "blockedBy", [...targetTask.blockedBy, taskId]);
                     }
                 }
             }
         }
+        // Add blockedBy: update this task's blockedBy + reciprocal blocks on targets
         if (args.addBlockedBy !== undefined) {
-            const blockedByToAdd = args.addBlockedBy.filter((id) => !updatedTask.blockedBy.includes(id));
+            const blockedByToAdd = args.addBlockedBy.filter((id) => !existingTask.blockedBy.includes(id));
             if (blockedByToAdd.length > 0) {
-                updatedTask.blockedBy = [...updatedTask.blockedBy, ...blockedByToAdd];
+                await recordSnapshot(context, taskManager, taskId, "modify");
+                await taskManager.updateTask({
+                    ...existingTask,
+                    ...updates,
+                    blockedBy: [...existingTask.blockedBy, ...blockedByToAdd],
+                });
                 updatedFields.push("blockedBy");
-                // Also update the blocks of the target tasks
                 for (const targetId of blockedByToAdd) {
                     const targetTask = await taskManager.getTask(targetId);
                     if (targetTask && !targetTask.blocks.includes(taskId)) {
-                        let targetSnapshotId;
-                        if (context.reversionManager && context.messageId) {
-                            const targetPath = taskManager.getTaskPath(targetId);
-                            targetSnapshotId = await context.reversionManager.recordSnapshot(context.messageId, targetPath, "modify");
-                        }
-                        await taskManager.updateTask({
-                            ...targetTask,
-                            blocks: [...targetTask.blocks, taskId],
-                        });
-                        if (context.reversionManager && targetSnapshotId) {
-                            await context.reversionManager.commitSnapshot(targetSnapshotId);
-                        }
+                        await updateTaskField(context, taskManager, targetTask, "blocks", [
+                            ...targetTask.blocks,
+                            taskId,
+                        ]);
                     }
                 }
             }
         }
-        await taskManager.updateTask(updatedTask);
-        if (context.reversionManager && snapshotId) {
-            await context.reversionManager.commitSnapshot(snapshotId);
-        }
         let content = `Updated task #${taskId} ${updatedFields.join(", ")}`;
-        if (updatedTask.status === "completed") {
+        if (updates.status === "completed") {
             content += `\n\nTask completed. Call TaskList now to find your next available task or see if your work unblocked others.`;
         }
         return {
@@ -485,13 +430,7 @@ export const taskListTool = {
             description: "List all tasks in the task list",
             parameters: {
                 type: "object",
-                properties: {
-                    status: {
-                        type: "string",
-                        enum: ["pending", "in_progress", "completed", "deleted"],
-                        description: "Optional filter by status.",
-                    },
-                },
+                properties: {},
             },
         },
     },
@@ -515,22 +454,29 @@ Returns a summary of each task:
 - **blockedBy**: List of open task IDs that must be resolved first (tasks with blockedBy cannot be claimed until dependencies resolve)
 
 Use TaskGet with a specific task ID to view full details including description and comments.`,
-    execute: async (args, context) => {
+    execute: async (_args, context) => {
         const taskManager = context.taskManager;
-        let tasks = await taskManager.listTasks();
-        if (args.status) {
-            tasks = tasks.filter((t) => t.status === args.status);
-        }
-        if (tasks.length === 0) {
+        // Filter out internal metadata tasks (like Claude Code)
+        const allTasks = (await taskManager.listTasks()).filter((t) => !t.metadata?._internal);
+        if (allTasks.length === 0) {
             return {
                 success: true,
-                content: "No tasks found.",
+                content: "No tasks found",
             };
         }
         // Sort by ID numerically
-        tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
-        const content = tasks
-            .map((t) => `[${t.id}] ${t.subject} (${t.status})`)
+        allTasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+        // Filter resolved blockers from blockedBy
+        const completedIds = new Set(allTasks.filter((t) => t.status === "completed").map((t) => t.id));
+        const content = allTasks
+            .map((t) => {
+            const blockedBy = t.blockedBy.filter((id) => !completedIds.has(id));
+            const owner = t.owner ? ` (${t.owner})` : "";
+            const blocked = blockedBy.length > 0
+                ? ` [blocked by ${blockedBy.map((id) => `#${id}`).join(", ")}]`
+                : "";
+            return `#${t.id} [${t.status}] ${t.subject}${owner}${blocked}`;
+        })
             .join("\n");
         return {
             success: true,

package/dist/tools/types.d.ts

@@ -96,5 +96,7 @@ export interface ToolContext {
     originalWorkdir?: string;
     /** Merged environment variables (process.env + agent env) for child processes */
     env?: Record<string, string>;
+    /** Workflow manager instance for workflow orchestration */
+    workflowManager?: import("../managers/workflowManager.js").WorkflowManager;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,0BAA0B,CAAC;IACnC,OAAO,EAAE,CACP,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,KACjB,OAAO,CAAC,UAAU,CAAC,CAAC;IACzB,mBAAmB,CAAC,EAAE,CACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,WAAW,KACjB,MAAM,CAAC;IACZ;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;QACf,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;QAC7C,eAAe,CAAC,EAAE,aAAa,EAAE,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,KAAK,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IAEH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,sCAAsC,EAAE,qBAAqB,CAAC;IAC7F,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,WAAW,CAAC,EAAE,OAAO,4BAA4B,EAAE,WAAW,CAAC;IAC/D,8CAA8C;IAC9C,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,iCAAiC;IACjC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,wDAAwD;IACxD,iBAAiB,CAAC,EAAE,OAAO,kCAAkC,EAAE,iBAAiB,CAAC;IACjF,iDAAiD;IACjD,UAAU,CAAC,EAAE,OAAO,2BAA2B,EAAE,UAAU,CAAC;IAC5D,iDAAiD;IACjD,UAAU,CAAC,EAAE,OAAO,iBAAiB,EAAE,WAAW,CAAC;IACnD,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,OAAO,iCAAiC,EAAE,gBAAgB,CAAC;IAC9E,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,qBAAqB,CAAC,EAAE,OAAO,uBAAuB,EAAE,sBAAsB,CAAC;IAC/E,gDAAgD;IAChD,WAAW,EAAE,OAAO,4BAA4B,EAAE,WAAW,CAAC;IAC9D,qDAAqD;IACrD,eAAe,CAAC,EAAE,OAAO,gCAAgC,EAAE,eAAe,CAAC;IAC3E,kDAAkD;IAClD,YAAY,CAAC,EAAE,OAAO,6BAA6B,EAAE,YAAY,CAAC;IAClE,iDAAiD;IACjD,WAAW,CAAC,EAAE,OAAO,4BAA4B,EAAE,WAAW,CAAC;IAC/D,4CAA4C;IAC5C,SAAS,CAAC,EAAE,OAAO,0BAA0B,EAAE,SAAS,CAAC;IACzD,4CAA4C;IAC5C,SAAS,CAAC,EAAE,cAAc,0BAA0B,CAAC,CAAC;IACtD,sDAAsD;IACtD,cAAc,CAAC,EAAE,OAAO,+BAA+B,EAAE,cAAc,CAAC;IACxE,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,mEAAmE;IACnE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,yCAAyC;IACzC,iBAAiB,CAAC,EAAE;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,mEAAmE;IACnE,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,4BAA4B,EAAE,WAAW,CAAC;IAC/D,oEAAoE;IACpE,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,uEAAuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,2DAA2D;IAC3D,eAAe,CAAC,EAAE,OAAO,gCAAgC,EAAE,eAAe,CAAC;CAC5E"}

package/dist/tools/webFetchTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webFetchTool.d.ts","sourceRoot":"","sources":["../../src/tools/webFetchTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAoGtE,eAAO,MAAM,YAAY,EAAE,UAoL1B,CAAC"}
+{"version":3,"file":"webFetchTool.d.ts","sourceRoot":"","sources":["../../src/tools/webFetchTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAiGtE,eAAO,MAAM,YAAY,EAAE,UA2K1B,CAAC"}

package/dist/tools/webFetchTool.js

@@ -73,7 +73,6 @@ function isPermittedRedirect(originalUrl, redirectUrl) {
         return false;
     }
 }
-const GITHUB_URL_ERROR = "For GitHub URLs, please use the 'gh' CLI via the Bash tool instead (e.g., 'gh pr view', 'gh issue view', 'gh api').";
 // --- Tool ---
 export const webFetchTool = {
     name: WEB_FETCH_TOOL_NAME,
@@ -142,14 +141,6 @@ Usage notes:
                 error: validation.error,
             };
         }
-        // Check for GitHub URLs
-        if (url.includes("github.com")) {
-            return {
-                success: false,
-                content: "",
-                error: GITHUB_URL_ERROR,
-            };
-        }
         try {
             const cached = cache.get(url);
             if (cached) {

package/dist/tools/workflowTool.d.ts

@@ -0,0 +1,11 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Workflow tool plugin for executing deterministic multi-subagent orchestration scripts.
+ *
+ * The AI model calls this tool with a JavaScript script that orchestrates
+ * multiple subagents via agent(), parallel(), pipeline(), phase(), log() APIs.
+ * Workflows run in the background — the tool returns immediately with a run ID,
+ * and a <task-notification> arrives when the workflow completes.
+ */
+export declare const workflowTool: ToolPlugin;
+//# sourceMappingURL=workflowTool.d.ts.map

package/dist/tools/workflowTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowTool.d.ts","sourceRoot":"","sources":["../../src/tools/workflowTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAItE;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,UAgM1B,CAAC"}

package/dist/tools/workflowTool.js

@@ -0,0 +1,190 @@
+import { WORKFLOW_TOOL_NAME } from "../constants/tools.js";
+import { logger } from "../utils/globalLogger.js";
+/**
+ * Workflow tool plugin for executing deterministic multi-subagent orchestration scripts.
+ *
+ * The AI model calls this tool with a JavaScript script that orchestrates
+ * multiple subagents via agent(), parallel(), pipeline(), phase(), log() APIs.
+ * Workflows run in the background — the tool returns immediately with a run ID,
+ * and a <task-notification> arrives when the workflow completes.
+ */
+export const workflowTool = {
+    name: WORKFLOW_TOOL_NAME,
+    config: {
+        type: "function",
+        function: {
+            name: WORKFLOW_TOOL_NAME,
+            description: "Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a run ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.",
+            parameters: {
+                type: "object",
+                properties: {
+                    script: {
+                        type: "string",
+                        description: "Inline workflow script (JavaScript). Must start with 'export const meta = {name, description, phases}'. Pass the script inline — do not Write it to a file first. Every Workflow invocation automatically persists its script.",
+                    },
+                    scriptPath: {
+                        type: "string",
+                        description: "Path to a saved workflow script file. Use this to re-run or iterate on a previously saved script. One of 'script' or 'scriptPath' is required.",
+                    },
+                    args: {
+                        description: "Arguments passed to the workflow script as the `args` global. Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string.",
+                    },
+                    resumeFromRunId: {
+                        type: "string",
+                        description: "Resume from a previous run's journal. Cached agent results are replayed instantly; the first edited/new call and everything after it runs live.",
+                    },
+                },
+            },
+        },
+    },
+    prompt: () => `Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a task ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.
+
+A workflow structures work across many agents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.
+
+ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of agents and consume a large amount of tokens; the user must request that scale, not have it inferred. Explicit opt-in means one of:
+- The user directly asked you to run a workflow or use multi-agent orchestration in their own words ("use a workflow", "run a workflow", "fan out agents", "orchestrate this with subagents"). The ask must be in the user's words — a task that would merely benefit from a workflow does not count.
+- The user invoked a skill or slash command whose instructions tell you to call Workflow.
+- The user asked you to run a specific named or saved workflow.
+
+For any other task — even one that would clearly benefit from parallelism — do NOT call this tool. Use the Agent tool for individual subagents, or briefly describe what a multi-agent workflow could do and how much it would roughly cost, and ask the user whether to run it.
+
+When you do call it, the right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then call Workflow to pipeline over it.
+
+Common single-phase workflows you can chain across turns:
+- **Understand** — parallel readers over relevant subsystems → structured map
+- **Design** — judge panel of N independent approaches → scored synthesis
+- **Review** — dimensions → find → adversarially verify
+- **Research** — multi-modal sweep → deep-read → synthesize
+- **Migrate** — discover sites → transform each (worktree isolation) → verify
+
+For larger work, run several in sequence — read each result before deciding the next phase.
+
+Every script must begin with \`export const meta = {...}\`:
+  export const meta = {
+    name: 'find-flaky-tests',
+    description: 'Find flaky tests and propose fixes',
+    phases: [
+      { title: 'Scan', detail: 'grep test logs for retries' },
+      { title: 'Fix', detail: 'one agent per flaky test' },
+    ],
+  }
+  // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
+
+Script body hooks:
+- **agent(prompt, opts?)**: Promise<any> — spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema), the subagent is forced to call a StructuredOutput tool and agent() returns the validated object — no parsing needed. Returns null if the user skips the agent mid-run or the subagent dies on a terminal API error (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase assigns this agent to a progress group. opts.model overrides the model for this agent call. opts.agentType uses a custom subagent type instead of the default.
+- **pipeline(items, stage1, stage2, ...)**: Promise<any[]> — run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Every stage callback receives (prevResult, originalItem, index). In the first stage prevResult is undefined; in later stages it is the return value of the previous stage. A stage that throws drops that item to null. Example single-stage: \`pipeline(files, (prev, file) => agent('Read ' + file))\`. Example two-stage: \`pipeline(files, (prev, file) => agent('Read ' + file), (prev, file) => agent('Summarize: ' + prev))\`.
+- **parallel(thunks: Array<() => Promise<any>>)**: Promise<any[]> — run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws resolves to null in the result array. Use ONLY when you genuinely need all results together.
+- **log(message: string)**: void — emit a progress message
+- **phase(title: string)**: void — start a new phase; subsequent agent() calls are grouped under this title
+- **args**: any — the value passed as Workflow's args input, verbatim
+- **budget**: {total: number|null, spent(): number, remaining(): number} — the turn's token target
+
+Scripts are plain JavaScript, NOT TypeScript — type annotations fail to parse. The script body runs in an async context — use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available — EXCEPT Date.now()/Math.random()/argless new Date(), which throw (they would break resume). No filesystem or Node.js API access.
+
+DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when you genuinely need ALL prior-stage results together.
+
+Concurrent agent() calls are capped at min(16, cpu cores - 2) per workflow. Total agent count is capped at 1000 per run. A single parallel()/pipeline() call accepts at most 4096 items.
+
+Quality patterns:
+- **Adversarial verify**: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if >=majority refute.
+- **Judge panel**: generate N independent approaches, score with parallel judges, synthesize from the winner.
+- **Loop-until-dry**: keep spawning finders until K consecutive rounds return nothing new.
+- **Multi-modal sweep**: parallel agents each searching a different way (by-container, by-content, by-entity).
+- **Completeness critic**: a final agent that asks "what's missing?" — findings become next round of work.
+- **No silent caps**: if a workflow bounds coverage, log() what was dropped.
+
+## Resume
+
+The tool result includes a runId. To resume after a pause, kill, or script edit, relaunch with Workflow({scriptPath, resumeFromRunId}) — the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live.
+
+Use this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.`,
+    execute: async (args, context) => {
+        const workflowManager = context.workflowManager;
+        if (!workflowManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Workflow manager not available in tool context",
+                shortResult: "Workflow execution failed",
+            };
+        }
+        const script = args.script;
+        const scriptPath = args.scriptPath;
+        const workflowArgs = args.args;
+        const resumeFromRunId = args.resumeFromRunId;
+        // Resolve script text
+        let scriptText;
+        if (script) {
+            scriptText = script;
+        }
+        else if (scriptPath) {
+            try {
+                const fs = await import("fs/promises");
+                scriptText = await fs.readFile(scriptPath, "utf-8");
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `Failed to read script file: ${error instanceof Error ? error.message : String(error)}`,
+                    shortResult: "Workflow script read failed",
+                };
+            }
+        }
+        else {
+            return {
+                success: false,
+                content: "",
+                error: "Either 'script' or 'scriptPath' parameter is required",
+                shortResult: "Workflow execution failed",
+            };
+        }
+        try {
+            // Create run
+            const run = await workflowManager.createRun(scriptText, workflowArgs, {
+                resumeFromRunId,
+            });
+            // Start execution in background
+            await workflowManager.startRun(run.runId);
+            return {
+                success: true,
+                content: [
+                    `Workflow started with run ID: ${run.runId}`,
+                    `Name: ${run.meta.name}`,
+                    `Description: ${run.meta.description}`,
+                    run.meta.phases?.length
+                        ? `Phases: ${run.meta.phases.map((p) => p.title).join(" → ")}`
+                        : "",
+                    `The workflow is running in the background. You will be notified automatically when it completes.`,
+                    `Use /workflows to watch live progress.`,
+                    `Script saved to: ${run.scriptPath}`,
+                ]
+                    .filter(Boolean)
+                    .join("\n"),
+                shortResult: `Workflow started: ${run.meta.name} (${run.runId})`,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.error(`[Workflow Tool] execution failed: ${msg}`);
+            return {
+                success: false,
+                content: `Workflow failed: ${msg}. Fix the error and try again.`,
+                error: `Workflow execution failed: ${msg}`,
+                shortResult: "Workflow execution failed",
+            };
+        }
+    },
+    formatCompactParams: (params) => {
+        if (params.scriptPath) {
+            return `scriptPath: ${params.scriptPath}`;
+        }
+        const script = params.script;
+        if (script) {
+            // Extract meta.name from the script
+            const nameMatch = script.match(/name:\s*['"]([^'"]+)['"]/);
+            return nameMatch ? nameMatch[1] : script.slice(0, 50) + "...";
+        }
+        return "workflow";
+    },
+};