@hdwebsoft/hdcode-agent-team 0.1.0 → 0.1.1

package/dist/index.js

@@ -3,7 +3,7 @@ import { readdir as readdir2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 
 // src/utils.ts
-import { readdir, mkdir, rename, unlink } from "node:fs/promises";
+import { readdir, mkdir, rename, unlink, stat } from "node:fs/promises";
 import { join } from "node:path";
 var TEAM_ROOT = ".team";
 var SAFE_NAME = /^[a-z0-9-]+$/;
@@ -20,7 +20,12 @@ function teamDir(base, teamName) {
   return join(base, TEAM_ROOT, teamName);
 }
 async function exists(path) {
-  return Bun.file(path).exists();
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function writeJsonAtomic(path, data) {
   const tmp = path + ".tmp";
@@ -176,481 +181,491 @@ async function appendToInbox(inboxPath, message) {
 }
 
 // src/tools/team-tools.ts
-var teamTools = {
-  team_create: tool({
-    description: "Create a new agent team with directory structure and CC-aligned config. Lead is automatically added as first member. Returns the team config.",
-    args: {
-      teamName: tool.schema.string().regex(/^[a-z0-9-]+$/).describe("Team name in kebab-case"),
-      description: tool.schema.string().describe("Team description")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (await exists(join4(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" already exists`;
-      }
-      await ensureDir(join4(dir, "tasks"));
-      await ensureDir(join4(dir, "inboxes"));
-      await ensureDir(join4(dir, "reports"));
-      const now = Date.now();
-      const leadId = `team-lead@${args.teamName}`;
-      const config = {
-        name: args.teamName,
-        description: args.description,
-        createdAt: now,
-        leadAgentId: leadId,
-        members: [
-          {
-            agentId: leadId,
-            name: "team-lead",
-            agentType: "team-lead",
-            model: "unknown",
-            planModeRequired: false,
-            joinedAt: now,
-            cwd: context.directory,
-            isActive: true
-          }
-        ]
-      };
-      await writeJsonAtomic(join4(dir, "config.json"), config);
-      await writeJsonAtomic(join4(dir, "inboxes", "team-lead.json"), []);
-      return JSON.stringify(config, null, 2);
-    }
-  }),
-  team_delete: tool({
-    description: "Delete a team and all its data (tasks, inboxes, reports).",
-    args: {
-      teamName: tool.schema.string().describe("Team name to delete")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join4(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
-      }
-      await rm(dir, { recursive: true, force: true });
-      return `Team "${args.teamName}" deleted successfully`;
-    }
-  }),
-  team_status: tool({
-    description: "Get team status: config, task summary by status, message counts per agent, reports, completion flag.",
-    args: {
-      teamName: tool.schema.string().describe("Team name")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join4(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
+function createTeamTools(directory) {
+  return {
+    team_create: tool({
+      description: "Create a new agent team with directory structure and CC-aligned config. Lead is automatically added as first member. Returns the team config.",
+      args: {
+        teamName: tool.schema.string().regex(/^[a-z0-9-]+$/).describe("Team name in kebab-case"),
+        description: tool.schema.string().describe("Team description")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (await exists(join4(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" already exists`;
+        }
+        await ensureDir(join4(dir, "tasks"));
+        await ensureDir(join4(dir, "inboxes"));
+        await ensureDir(join4(dir, "reports"));
+        const now = Date.now();
+        const leadId = `team-lead@${args.teamName}`;
+        const config = {
+          name: args.teamName,
+          description: args.description,
+          createdAt: now,
+          leadAgentId: leadId,
+          members: [
+            {
+              agentId: leadId,
+              name: "team-lead",
+              agentType: "team-lead",
+              model: "unknown",
+              planModeRequired: false,
+              joinedAt: now,
+              cwd: directory,
+              isActive: true
+            }
+          ]
+        };
+        await writeJsonAtomic(join4(dir, "config.json"), config);
+        await writeJsonAtomic(join4(dir, "inboxes", "team-lead.json"), []);
+        return JSON.stringify(config, null, 2);
       }
-      const config = await readJson(join4(dir, "config.json"));
-      const tasks = await loadAllTasks(context.directory, args.teamName);
-      const summary = { pending: 0, in_progress: 0, completed: 0 };
-      for (const t of tasks) {
-        if (t.status in summary) {
-          summary[t.status]++;
+    }),
+    team_delete: tool({
+      description: "Delete a team and all its data (tasks, inboxes, reports).",
+      args: {
+        teamName: tool.schema.string().describe("Team name to delete")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join4(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
         }
+        await rm(dir, { recursive: true, force: true });
+        return `Team "${args.teamName}" deleted successfully`;
       }
-      const inboxesDir = join4(dir, "inboxes");
-      const messageCounts = {};
-      if (await exists(inboxesDir)) {
-        const inboxFiles = await listJsonFiles(inboxesDir);
-        for (const f of inboxFiles) {
-          const agentName = f.split("/").pop().replace(".json", "");
-          const messages = await readInbox(f);
-          messageCounts[agentName] = {
-            total: messages.length,
-            unread: messages.filter((m) => !m.read).length
-          };
+    }),
+    team_status: tool({
+      description: "Get team status: config, task summary by status, message counts per agent, reports, completion flag.",
+      args: {
+        teamName: tool.schema.string().describe("Team name")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join4(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
+        }
+        const config = await readJson(join4(dir, "config.json"));
+        const tasks = await loadAllTasks(directory, args.teamName);
+        const summary = { pending: 0, in_progress: 0, completed: 0 };
+        for (const t of tasks) {
+          if (t.status in summary) {
+            summary[t.status]++;
+          }
         }
+        const inboxesDir = join4(dir, "inboxes");
+        const messageCounts = {};
+        if (await exists(inboxesDir)) {
+          const inboxFiles = await listJsonFiles(inboxesDir);
+          for (const f of inboxFiles) {
+            const agentName = f.split("/").pop().replace(".json", "");
+            const messages = await readInbox(f);
+            messageCounts[agentName] = {
+              total: messages.length,
+              unread: messages.filter((m) => !m.read).length
+            };
+          }
+        }
+        const reportDir = join4(dir, "reports");
+        const reports = await exists(reportDir) ? (await readdir3(reportDir)).filter((f) => !f.startsWith(".")) : [];
+        const total = Object.values(summary).reduce((a, b) => a + b, 0);
+        const isComplete = total > 0 && summary.pending === 0 && summary.in_progress === 0;
+        return JSON.stringify({ config, taskSummary: summary, messageCounts, reports, isComplete }, null, 2);
       }
-      const reportDir = join4(dir, "reports");
-      const reports = await exists(reportDir) ? (await readdir3(reportDir)).filter((f) => !f.startsWith(".")) : [];
-      const total = Object.values(summary).reduce((a, b) => a + b, 0);
-      const isComplete = total > 0 && summary.pending === 0 && summary.in_progress === 0;
-      return JSON.stringify({ config, taskSummary: summary, messageCounts, reports, isComplete }, null, 2);
-    }
-  }),
-  team_list: tool({
-    description: "List all teams with basic info.",
-    args: {},
-    async execute(_args, context) {
-      const root = join4(context.directory, TEAM_ROOT);
-      if (!await exists(root))
-        return "No teams found";
-      const entries = await readdir3(root, { withFileTypes: true });
-      const teams = [];
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const configPath = join4(root, entry.name, "config.json");
-        if (!await exists(configPath))
-          continue;
-        const config = await readJson(configPath);
-        const tasks = await loadAllTasks(context.directory, entry.name);
-        const pending = tasks.filter((t) => t.status === "pending").length;
-        const inProgress = tasks.filter((t) => t.status === "in_progress").length;
-        const completed = tasks.filter((t) => t.status === "completed").length;
-        const isComplete = tasks.length > 0 && pending === 0 && inProgress === 0;
-        teams.push({
-          name: config.name,
-          description: config.description,
-          createdAt: config.createdAt,
-          memberCount: config.members.length,
-          taskSummary: { pending, in_progress: inProgress, completed },
-          isComplete
-        });
+    }),
+    team_list: tool({
+      description: "List all teams with basic info.",
+      args: {},
+      async execute() {
+        const root = join4(directory, TEAM_ROOT);
+        if (!await exists(root))
+          return "No teams found";
+        const entries = await readdir3(root, { withFileTypes: true });
+        const teams = [];
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          const configPath = join4(root, entry.name, "config.json");
+          if (!await exists(configPath))
+            continue;
+          const config = await readJson(configPath);
+          const tasks = await loadAllTasks(directory, entry.name);
+          const pending = tasks.filter((t) => t.status === "pending").length;
+          const inProgress = tasks.filter((t) => t.status === "in_progress").length;
+          const completed = tasks.filter((t) => t.status === "completed").length;
+          const isComplete = tasks.length > 0 && pending === 0 && inProgress === 0;
+          teams.push({
+            name: config.name,
+            description: config.description,
+            createdAt: config.createdAt,
+            memberCount: config.members.length,
+            taskSummary: { pending, in_progress: inProgress, completed },
+            isComplete
+          });
+        }
+        return teams.length > 0 ? JSON.stringify(teams, null, 2) : "No teams found";
       }
-      return teams.length > 0 ? JSON.stringify(teams, null, 2) : "No teams found";
-    }
-  })
-};
+    })
+  };
+}
 
 // src/tools/task-tools.ts
 import { join as join5 } from "node:path";
 import { tool as tool2 } from "@opencode-ai/plugin";
-var taskTools = {
-  task_create: tool2({
-    description: "Create a task with auto-increment integer ID. Supports optional dependencies (addBlocks/addBlockedBy) at creation. If blockedBy tasks are not completed, status stays pending. Returns created task.",
-    args: {
-      teamName: tool2.schema.string().describe("Team name"),
-      subject: tool2.schema.string().describe("Task subject, <60 chars, imperative"),
-      description: tool2.schema.string().describe("Task description"),
-      activeForm: tool2.schema.string().optional().describe("Spinner text when in_progress"),
-      addBlocks: tool2.schema.string().optional().describe('JSON array of task IDs this task blocks, e.g. ["3","4"]'),
-      addBlockedBy: tool2.schema.string().optional().describe('JSON array of task IDs that block this task, e.g. ["1"]'),
-      metadata: tool2.schema.string().optional().describe("JSON object of arbitrary metadata")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join5(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
-      }
-      const tasksDir = join5(dir, "tasks");
-      await ensureDir(tasksDir);
-      const tasksLockPath = join5(tasksDir, ".lock");
-      return withLock(tasksLockPath, async () => {
-        const id = await nextTaskId(tasksDir);
-        let addBlocks = [];
-        let addBlockedBy = [];
-        let metadata;
-        if (args.addBlocks) {
-          try {
-            addBlocks = JSON.parse(args.addBlocks);
-          } catch {
-            return "Error: Invalid addBlocks JSON";
-          }
+function parseStringArray(raw, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return `Error: Invalid ${label} JSON`;
+  }
+  if (!Array.isArray(parsed) || !parsed.every((v) => typeof v === "string")) {
+    return `Error: ${label} must be a JSON array of strings, e.g. ["1","2"]`;
+  }
+  return parsed;
+}
+function createTaskTools(directory) {
+  return {
+    task_create: tool2({
+      description: "Create a task with auto-increment integer ID. Supports optional dependencies (addBlocks/addBlockedBy) at creation. If blockedBy tasks are not completed, status stays pending. Returns created task.",
+      args: {
+        teamName: tool2.schema.string().describe("Team name"),
+        subject: tool2.schema.string().describe("Task subject, <60 chars, imperative"),
+        description: tool2.schema.string().describe("Task description"),
+        activeForm: tool2.schema.string().optional().describe("Spinner text when in_progress"),
+        addBlocks: tool2.schema.string().optional().describe('JSON array of task IDs this task blocks, e.g. ["3","4"]'),
+        addBlockedBy: tool2.schema.string().optional().describe('JSON array of task IDs that block this task, e.g. ["1"]'),
+        metadata: tool2.schema.string().optional().describe("JSON object of arbitrary metadata")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join5(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
         }
-        if (args.addBlockedBy) {
-          try {
-            addBlockedBy = JSON.parse(args.addBlockedBy);
-          } catch {
-            return "Error: Invalid addBlockedBy JSON";
+        const tasksDir = join5(dir, "tasks");
+        await ensureDir(tasksDir);
+        const tasksLockPath = join5(tasksDir, ".lock");
+        return withLock(tasksLockPath, async () => {
+          let addBlocks = [];
+          let addBlockedBy = [];
+          let metadata;
+          if (args.addBlocks) {
+            const result = parseStringArray(args.addBlocks, "addBlocks");
+            if (typeof result === "string")
+              return result;
+            addBlocks = result;
           }
-        }
-        if (args.metadata) {
-          try {
-            metadata = JSON.parse(args.metadata);
-          } catch {
-            return "Error: Invalid metadata JSON";
+          if (args.addBlockedBy) {
+            const result = parseStringArray(args.addBlockedBy, "addBlockedBy");
+            if (typeof result === "string")
+              return result;
+            addBlockedBy = result;
           }
-        }
-        const allTasks = await loadAllTasks(context.directory, args.teamName);
-        const taskMap = new Map(allTasks.map((t) => [t.id, t]));
-        for (const bid of addBlockedBy) {
-          if (!taskMap.has(bid))
-            return `Error: Blocker task "${bid}" not found`;
-        }
-        for (const bid of addBlocks) {
-          if (!taskMap.has(bid))
-            return `Error: Blocked task "${bid}" not found`;
-        }
-        if (addBlockedBy.length > 0 && hasCycle(id, addBlockedBy, taskMap)) {
-          return `Error: Circular dependency detected for task ${id}`;
-        }
-        const task = {
-          id,
-          subject: args.subject,
-          description: args.description,
-          ...args.activeForm && { activeForm: args.activeForm },
-          status: "pending",
-          blocks: addBlocks,
-          blockedBy: addBlockedBy,
-          ...metadata && { metadata }
-        };
-        await writeJsonAtomic(join5(tasksDir, `${id}.json`), task);
-        for (const targetId of addBlockedBy) {
-          const targetPath = taskFilePath(context.directory, args.teamName, targetId);
-          const target = await readJson(targetPath);
-          if (!target.blocks.includes(id)) {
-            target.blocks.push(id);
-            await writeJsonAtomic(targetPath, target);
+          if (args.metadata) {
+            try {
+              metadata = JSON.parse(args.metadata);
+            } catch {
+              return "Error: Invalid metadata JSON";
+            }
           }
-        }
-        for (const targetId of addBlocks) {
-          const targetPath = taskFilePath(context.directory, args.teamName, targetId);
-          const target = await readJson(targetPath);
-          if (!target.blockedBy.includes(id)) {
-            target.blockedBy.push(id);
-            await writeJsonAtomic(targetPath, target);
+          const allTasks = await loadAllTasks(directory, args.teamName);
+          const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+          for (const bid of addBlockedBy) {
+            if (!taskMap.has(bid))
+              return `Error: Blocker task "${bid}" not found`;
           }
-        }
-        return JSON.stringify(task, null, 2);
-      });
-    }
-  }),
-  task_update: tool2({
-    description: "Update task fields, manage dependencies, auto-unblock. Status transitions: pending→in_progress, pending→completed, in_progress→completed. On completion: auto-unblocks dependents. Returns {task, unblocked[]}.",
-    args: {
-      teamName: tool2.schema.string().describe("Team name"),
-      taskId: tool2.schema.string().describe("Task ID (integer string)"),
-      status: tool2.schema.enum(["pending", "in_progress", "completed"]).optional().describe("New status"),
-      subject: tool2.schema.string().optional().describe("New subject"),
-      description: tool2.schema.string().optional().describe("New description"),
-      activeForm: tool2.schema.string().optional().describe("Spinner text when in_progress"),
-      owner: tool2.schema.string().optional().describe("Agent name claiming this task"),
-      addBlocks: tool2.schema.string().optional().describe("JSON array of task IDs to add to blocks[]"),
-      addBlockedBy: tool2.schema.string().optional().describe("JSON array of task IDs to add to blockedBy[]"),
-      metadata: tool2.schema.string().optional().describe("JSON object to merge into metadata")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join5(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
-      }
-      const tasksDir = join5(dir, "tasks");
-      const tasksLockPath = join5(tasksDir, ".lock");
-      return withLock(tasksLockPath, async () => {
-        const tPath = taskFilePath(context.directory, args.teamName, args.taskId);
-        if (!await exists(tPath)) {
-          return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
-        }
-        const task = await readJson(tPath);
-        if (args.status) {
-          const validTransitions = {
-            pending: ["in_progress", "completed"],
-            in_progress: ["completed"],
-            completed: []
-          };
-          const allowed = validTransitions[task.status];
-          if (!allowed || !allowed.includes(args.status)) {
-            return `Error: Invalid transition ${task.status} → ${args.status}`;
+          for (const bid of addBlocks) {
+            if (!taskMap.has(bid))
+              return `Error: Blocked task "${bid}" not found`;
           }
-          if (args.status === "in_progress" && task.blockedBy.length > 0) {
-            const activeBlockers = [];
-            for (const bid of task.blockedBy) {
-              const blockerPath = taskFilePath(context.directory, args.teamName, bid);
-              if (await exists(blockerPath)) {
-                const blocker = await readJson(blockerPath);
-                if (blocker.status !== "completed") {
-                  activeBlockers.push(bid);
-                }
-              }
-            }
-            if (activeBlockers.length > 0) {
-              return `Error: Cannot start task with unresolved blockers: ${activeBlockers.join(", ")}`;
+          const id = await nextTaskId(tasksDir);
+          if (addBlockedBy.length > 0 && hasCycle(id, addBlockedBy, taskMap)) {
+            return `Error: Circular dependency detected for task ${id}`;
+          }
+          const task = {
+            id,
+            subject: args.subject,
+            description: args.description,
+            ...args.activeForm && { activeForm: args.activeForm },
+            status: "pending",
+            blocks: addBlocks,
+            blockedBy: addBlockedBy,
+            ...metadata && { metadata }
+          };
+          await writeJsonAtomic(join5(tasksDir, `${id}.json`), task);
+          for (const targetId of addBlockedBy) {
+            const targetPath = taskFilePath(directory, args.teamName, targetId);
+            const target = await readJson(targetPath);
+            if (!target.blocks.includes(id)) {
+              target.blocks.push(id);
+              await writeJsonAtomic(targetPath, target);
             }
           }
-          task.status = args.status;
-        }
-        if (args.subject !== undefined)
-          task.subject = args.subject;
-        if (args.description !== undefined)
-          task.description = args.description;
-        if (args.activeForm !== undefined)
-          task.activeForm = args.activeForm;
-        if (args.owner !== undefined)
-          task.owner = args.owner;
-        if (args.metadata) {
-          let newMeta;
-          try {
-            newMeta = JSON.parse(args.metadata);
-          } catch {
-            return "Error: Invalid metadata JSON";
+          for (const targetId of addBlocks) {
+            const targetPath = taskFilePath(directory, args.teamName, targetId);
+            const target = await readJson(targetPath);
+            if (!target.blockedBy.includes(id)) {
+              target.blockedBy.push(id);
+              await writeJsonAtomic(targetPath, target);
+            }
           }
-          task.metadata = { ...task.metadata, ...newMeta };
+          return JSON.stringify(task, null, 2);
+        });
+      }
+    }),
+    task_update: tool2({
+      description: "Update task fields, manage dependencies, auto-unblock. Status transitions: pending→in_progress, pending→completed, in_progress→completed. On completion: auto-unblocks dependents. Returns {task, unblocked[]}.",
+      args: {
+        teamName: tool2.schema.string().describe("Team name"),
+        taskId: tool2.schema.string().describe("Task ID (integer string)"),
+        status: tool2.schema.enum(["pending", "in_progress", "completed"]).optional().describe("New status"),
+        subject: tool2.schema.string().optional().describe("New subject"),
+        description: tool2.schema.string().optional().describe("New description"),
+        activeForm: tool2.schema.string().optional().describe("Spinner text when in_progress"),
+        owner: tool2.schema.string().optional().describe("Agent name claiming this task"),
+        addBlocks: tool2.schema.string().optional().describe("JSON array of task IDs to add to blocks[]"),
+        addBlockedBy: tool2.schema.string().optional().describe("JSON array of task IDs to add to blockedBy[]"),
+        metadata: tool2.schema.string().optional().describe("JSON object to merge into metadata")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join5(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
         }
-        if (args.addBlocks) {
-          let newBlocks;
-          try {
-            newBlocks = JSON.parse(args.addBlocks);
-          } catch {
-            return "Error: Invalid addBlocks JSON";
+        const tasksDir = join5(dir, "tasks");
+        const tasksLockPath = join5(tasksDir, ".lock");
+        return withLock(tasksLockPath, async () => {
+          const tPath = taskFilePath(directory, args.teamName, args.taskId);
+          if (!await exists(tPath)) {
+            return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
           }
-          for (const targetId of newBlocks) {
-            if (!task.blocks.includes(targetId)) {
-              task.blocks.push(targetId);
+          const task = await readJson(tPath);
+          if (args.status) {
+            const validTransitions = {
+              pending: ["in_progress", "completed"],
+              in_progress: ["completed"],
+              completed: []
+            };
+            const allowed = validTransitions[task.status];
+            if (!allowed || !allowed.includes(args.status)) {
+              return `Error: Invalid transition ${task.status} → ${args.status}`;
             }
-            const targetPath = taskFilePath(context.directory, args.teamName, targetId);
-            if (await exists(targetPath)) {
-              const target = await readJson(targetPath);
-              if (!target.blockedBy.includes(task.id)) {
-                target.blockedBy.push(task.id);
-                await writeJsonAtomic(targetPath, target);
+            if (args.status === "in_progress" && task.blockedBy.length > 0) {
+              const activeBlockers = [];
+              for (const bid of task.blockedBy) {
+                const blockerPath = taskFilePath(directory, args.teamName, bid);
+                if (await exists(blockerPath)) {
+                  const blocker = await readJson(blockerPath);
+                  if (blocker.status !== "completed") {
+                    activeBlockers.push(bid);
+                  }
+                }
+              }
+              if (activeBlockers.length > 0) {
+                return `Error: Cannot start task with unresolved blockers: ${activeBlockers.join(", ")}`;
               }
             }
+            task.status = args.status;
           }
-        }
-        if (args.addBlockedBy) {
-          let newBlockedBy;
-          try {
-            newBlockedBy = JSON.parse(args.addBlockedBy);
-          } catch {
-            return "Error: Invalid addBlockedBy JSON";
+          if (args.subject !== undefined)
+            task.subject = args.subject;
+          if (args.description !== undefined)
+            task.description = args.description;
+          if (args.activeForm !== undefined)
+            task.activeForm = args.activeForm;
+          if (args.owner !== undefined)
+            task.owner = args.owner;
+          if (args.metadata) {
+            let newMeta;
+            try {
+              newMeta = JSON.parse(args.metadata);
+            } catch {
+              return "Error: Invalid metadata JSON";
+            }
+            task.metadata = { ...task.metadata, ...newMeta };
           }
-          for (const targetId of newBlockedBy) {
-            if (!task.blockedBy.includes(targetId)) {
-              task.blockedBy.push(targetId);
+          if (args.addBlocks) {
+            const result = parseStringArray(args.addBlocks, "addBlocks");
+            if (typeof result === "string")
+              return result;
+            for (const targetId of result) {
+              if (!task.blocks.includes(targetId)) {
+                task.blocks.push(targetId);
+              }
+              const targetPath = taskFilePath(directory, args.teamName, targetId);
+              if (await exists(targetPath)) {
+                const target = await readJson(targetPath);
+                if (!target.blockedBy.includes(task.id)) {
+                  target.blockedBy.push(task.id);
+                  await writeJsonAtomic(targetPath, target);
+                }
+              }
             }
-            const targetPath = taskFilePath(context.directory, args.teamName, targetId);
-            if (await exists(targetPath)) {
-              const target = await readJson(targetPath);
-              if (!target.blocks.includes(task.id)) {
-                target.blocks.push(task.id);
-                await writeJsonAtomic(targetPath, target);
+          }
+          if (args.addBlockedBy) {
+            const result = parseStringArray(args.addBlockedBy, "addBlockedBy");
+            if (typeof result === "string")
+              return result;
+            for (const targetId of result) {
+              if (!task.blockedBy.includes(targetId)) {
+                task.blockedBy.push(targetId);
+              }
+              const targetPath = taskFilePath(directory, args.teamName, targetId);
+              if (await exists(targetPath)) {
+                const target = await readJson(targetPath);
+                if (!target.blocks.includes(task.id)) {
+                  target.blocks.push(task.id);
+                  await writeJsonAtomic(targetPath, target);
+                }
               }
             }
           }
+          await writeJsonAtomic(tPath, task);
+          let unblocked = [];
+          if (task.status === "completed") {
+            unblocked = await unblockDependents(directory, args.teamName, task.id);
+          }
+          return JSON.stringify({ task, unblocked }, null, 2);
+        });
+      }
+    }),
+    task_get: tool2({
+      description: "Get a single task by ID.",
+      args: {
+        teamName: tool2.schema.string().describe("Team name"),
+        taskId: tool2.schema.string().describe("Task ID (integer string)")
+      },
+      async execute(args) {
+        const tPath = taskFilePath(directory, args.teamName, args.taskId);
+        if (!await exists(tPath)) {
+          return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
         }
-        await writeJsonAtomic(tPath, task);
-        let unblocked = [];
-        if (task.status === "completed") {
-          unblocked = await unblockDependents(context.directory, args.teamName, task.id);
-        }
-        return JSON.stringify({ task, unblocked }, null, 2);
-      });
-    }
-  }),
-  task_get: tool2({
-    description: "Get a single task by ID.",
-    args: {
-      teamName: tool2.schema.string().describe("Team name"),
-      taskId: tool2.schema.string().describe("Task ID (integer string)")
-    },
-    async execute(args, context) {
-      const tPath = taskFilePath(context.directory, args.teamName, args.taskId);
-      if (!await exists(tPath)) {
-        return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
+        return JSON.stringify(await readJson(tPath), null, 2);
       }
-      return JSON.stringify(await readJson(tPath), null, 2);
-    }
-  }),
-  task_list: tool2({
-    description: "List all tasks in a team with full details, sorted by integer ID.",
-    args: {
-      teamName: tool2.schema.string().describe("Team name")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join5(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
+    }),
+    task_list: tool2({
+      description: "List all tasks in a team with full details, sorted by integer ID.",
+      args: {
+        teamName: tool2.schema.string().describe("Team name")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join5(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
+        }
+        const tasks = await loadAllTasks(directory, args.teamName);
+        tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+        return tasks.length > 0 ? JSON.stringify(tasks, null, 2) : "No tasks found";
       }
-      const tasks = await loadAllTasks(context.directory, args.teamName);
-      tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
-      return tasks.length > 0 ? JSON.stringify(tasks, null, 2) : "No tasks found";
-    }
-  })
-};
+    })
+  };
+}
 
 // src/tools/message-tools.ts
 import { join as join6 } from "node:path";
 import { tool as tool3 } from "@opencode-ai/plugin";
-var messageTools = {
-  message_send: tool3({
-    description: "Send a message to a recipient's inbox or broadcast to all agents. Types: message, broadcast, shutdown_request, shutdown_response, plan_approval_response. Returns {sent: true, recipients: [...]}.",
-    args: {
-      teamName: tool3.schema.string().describe("Team name"),
-      type: tool3.schema.enum([
-        "message",
-        "broadcast",
-        "shutdown_request",
-        "shutdown_response",
-        "plan_approval_response"
-      ]).describe("Message type"),
-      recipient: tool3.schema.string().optional().describe("Recipient agent name (required for non-broadcast types)"),
-      content: tool3.schema.string().describe("Message content (markdown)"),
-      summary: tool3.schema.string().optional().describe("5-10 word preview"),
-      from: tool3.schema.string().optional().describe("Sender name (defaults to team-lead)")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      const configPath = join6(dir, "config.json");
-      if (!await exists(configPath)) {
-        return `Error: Team "${args.teamName}" not found`;
-      }
-      const sender = args.from || "team-lead";
-      const inboxesDir = join6(dir, "inboxes");
-      await ensureDir(inboxesDir);
-      const inboxesLockPath = join6(inboxesDir, ".lock");
-      const message = {
-        from: sender,
-        text: args.content,
-        ...args.summary && { summary: args.summary },
-        timestamp: new Date().toISOString(),
-        read: false
-      };
-      if (args.type === "broadcast") {
-        const config = await readJson(configPath);
-        const recipients = [];
-        return withLock(inboxesLockPath, async () => {
-          for (const member of config.members) {
-            if (member.name === sender)
-              continue;
-            const inboxPath = join6(inboxesDir, `${member.name}.json`);
-            await appendToInbox(inboxPath, message);
-            recipients.push(member.name);
+function createMessageTools(directory) {
+  return {
+    message_send: tool3({
+      description: "Send a message to a recipient's inbox or broadcast to all agents. Types: message, broadcast, shutdown_request, shutdown_response, plan_approval_response. Returns {sent: true, recipients: [...]}.",
+      args: {
+        teamName: tool3.schema.string().describe("Team name"),
+        type: tool3.schema.enum([
+          "message",
+          "broadcast",
+          "shutdown_request",
+          "shutdown_response",
+          "plan_approval_response"
+        ]).describe("Message type"),
+        recipient: tool3.schema.string().optional().describe("Recipient agent name (required for non-broadcast types)"),
+        content: tool3.schema.string().describe("Message content (markdown)"),
+        summary: tool3.schema.string().optional().describe("5-10 word preview"),
+        from: tool3.schema.string().optional().describe("Sender name (defaults to team-lead)")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        const configPath = join6(dir, "config.json");
+        if (!await exists(configPath)) {
+          return `Error: Team "${args.teamName}" not found`;
+        }
+        const sender = args.from || "team-lead";
+        const inboxesDir = join6(dir, "inboxes");
+        await ensureDir(inboxesDir);
+        const inboxesLockPath = join6(inboxesDir, ".lock");
+        const message = {
+          from: sender,
+          text: args.content,
+          ...args.summary && { summary: args.summary },
+          timestamp: new Date().toISOString(),
+          read: false
+        };
+        if (args.type === "broadcast") {
+          const config = await readJson(configPath);
+          const recipients = [];
+          return withLock(inboxesLockPath, async () => {
+            for (const member of config.members) {
+              if (member.name === sender)
+                continue;
+              const inboxPath = join6(inboxesDir, `${member.name}.json`);
+              await appendToInbox(inboxPath, message);
+              recipients.push(member.name);
+            }
+            return JSON.stringify({ sent: true, recipients }, null, 2);
+          });
+        } else {
+          if (!args.recipient) {
+            return "Error: recipient is required for non-broadcast messages";
           }
-          return JSON.stringify({ sent: true, recipients }, null, 2);
-        });
-      } else {
-        if (!args.recipient) {
-          return "Error: recipient is required for non-broadcast messages";
+          return withLock(inboxesLockPath, async () => {
+            const inboxPath = join6(inboxesDir, `${args.recipient}.json`);
+            await appendToInbox(inboxPath, message);
+            return JSON.stringify({ sent: true, recipients: [args.recipient] }, null, 2);
+          });
         }
-        return withLock(inboxesLockPath, async () => {
-          const inboxPath = join6(inboxesDir, `${args.recipient}.json`);
-          await appendToInbox(inboxPath, message);
-          return JSON.stringify({ sent: true, recipients: [args.recipient] }, null, 2);
-        });
-      }
-    }
-  }),
-  message_fetch: tool3({
-    description: "Fetch messages from an agent's inbox. Optionally filter by timestamp and mark as read.",
-    args: {
-      teamName: tool3.schema.string().describe("Team name"),
-      agent: tool3.schema.string().describe("Agent name whose inbox to read"),
-      since: tool3.schema.string().optional().describe("ISO timestamp — return only messages after this time"),
-      markRead: tool3.schema.boolean().optional().describe("Mark fetched messages as read (default false)")
-    },
-    async execute(args, context) {
-      const dir = teamDir(context.directory, args.teamName);
-      if (!await exists(join6(dir, "config.json"))) {
-        return `Error: Team "${args.teamName}" not found`;
       }
-      const inboxPath = join6(dir, "inboxes", `${args.agent}.json`);
-      let messages = await readInbox(inboxPath);
-      if (args.since) {
-        const sinceDate = new Date(args.since);
-        messages = messages.filter((m) => new Date(m.timestamp) > sinceDate);
-      }
-      if (args.markRead && messages.length > 0) {
-        const allMessages = await readInbox(inboxPath);
-        const sinceDate = args.since ? new Date(args.since) : null;
-        let changed = false;
-        for (const m of allMessages) {
-          if (sinceDate && new Date(m.timestamp) <= sinceDate)
-            continue;
-          if (!m.read) {
-            m.read = true;
-            changed = true;
-          }
+    }),
+    message_fetch: tool3({
+      description: "Fetch messages from an agent's inbox. Optionally filter by timestamp and mark as read.",
+      args: {
+        teamName: tool3.schema.string().describe("Team name"),
+        agent: tool3.schema.string().describe("Agent name whose inbox to read"),
+        since: tool3.schema.string().optional().describe("ISO timestamp — return only messages after this time"),
+        markRead: tool3.schema.boolean().optional().describe("Mark fetched messages as read (default false)")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join6(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
+        }
+        const inboxPath = join6(dir, "inboxes", `${args.agent}.json`);
+        let messages = await readInbox(inboxPath);
+        if (args.since) {
+          const sinceDate = new Date(args.since);
+          messages = messages.filter((m) => new Date(m.timestamp) > sinceDate);
         }
-        if (changed) {
-          await writeJsonAtomic(inboxPath, allMessages);
+        if (args.markRead && messages.length > 0) {
+          const allMessages = await readInbox(inboxPath);
+          const sinceDate = args.since ? new Date(args.since) : null;
+          let changed = false;
+          for (const m of allMessages) {
+            if (sinceDate && new Date(m.timestamp) <= sinceDate)
+              continue;
+            if (!m.read) {
+              m.read = true;
+              changed = true;
+            }
+          }
+          if (changed) {
+            await writeJsonAtomic(inboxPath, allMessages);
+          }
         }
+        messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        return messages.length > 0 ? JSON.stringify(messages, null, 2) : "No messages found";
       }
-      messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-      return messages.length > 0 ? JSON.stringify(messages, null, 2) : "No messages found";
-    }
-  })
-};
+    })
+  };
+}
 
 // src/index.ts
 var HDTeamPlugin = async ({ directory }) => {
@@ -670,9 +685,9 @@ Use team_status(teamName) to get full details. Continue any in-progress tasks.
       }
     },
     tool: {
-      ...teamTools,
-      ...taskTools,
-      ...messageTools
+      ...createTeamTools(directory),
+      ...createTaskTools(directory),
+      ...createMessageTools(directory)
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hdwebsoft/hdcode-agent-team",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenCode plugin for multi-agent team coordination — per-agent inboxes, task management with dependency tracking, and file locking.",
   "type": "module",
   "main": "./dist/index.js",