@hdwebsoft/hdcode-agent-team 0.1.0

package/dist/index.js

@@ -0,0 +1,681 @@
+// src/teams.ts
+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 { join } from "node:path";
+var TEAM_ROOT = ".team";
+var SAFE_NAME = /^[a-z0-9-]+$/;
+var LOCK_TIMEOUT_MS = 1e4;
+var LOCK_RETRY_MS = 50;
+var LOCK_MAX_RETRIES = 100;
+function validateName(name, label) {
+  if (!SAFE_NAME.test(name)) {
+    throw new Error(`Invalid ${label}: "${name}" (must be lowercase alphanumeric + hyphens)`);
+  }
+}
+function teamDir(base, teamName) {
+  validateName(teamName, "teamName");
+  return join(base, TEAM_ROOT, teamName);
+}
+async function exists(path) {
+  return Bun.file(path).exists();
+}
+async function writeJsonAtomic(path, data) {
+  const tmp = path + ".tmp";
+  await Bun.write(tmp, JSON.stringify(data, null, 2));
+  await rename(tmp, path);
+}
+async function readJson(path) {
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    throw new Error(`File not found: ${path}`);
+  }
+  return file.json();
+}
+async function listJsonFiles(dir) {
+  if (!await exists(dir))
+    return [];
+  const entries = await readdir(dir);
+  return entries.filter((e) => e.endsWith(".json")).map((e) => join(dir, e));
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function withLock(lockPath, fn) {
+  let acquired = false;
+  for (let i = 0;i < LOCK_MAX_RETRIES; i++) {
+    if (await exists(lockPath)) {
+      const content = await Bun.file(lockPath).text().catch(() => "0");
+      const lockTime = parseInt(content, 10) || 0;
+      if (Date.now() - lockTime > LOCK_TIMEOUT_MS) {
+        await Bun.write(lockPath, Date.now().toString());
+        acquired = true;
+        break;
+      }
+      await Bun.sleep(LOCK_RETRY_MS);
+    } else {
+      await Bun.write(lockPath, Date.now().toString());
+      acquired = true;
+      break;
+    }
+  }
+  if (!acquired) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (timed out after ${LOCK_MAX_RETRIES * LOCK_RETRY_MS}ms)`);
+  }
+  try {
+    return await fn();
+  } finally {
+    await unlink(lockPath).catch(() => {});
+  }
+}
+
+// src/tasks.ts
+import { join as join2 } from "node:path";
+function taskFilePath(base, teamName, taskId) {
+  return join2(teamDir(base, teamName), "tasks", `${taskId}.json`);
+}
+async function nextTaskId(tasksDir) {
+  const counterPath = join2(tasksDir, ".counter");
+  let counter = 0;
+  if (await exists(counterPath)) {
+    const content = await Bun.file(counterPath).text();
+    counter = parseInt(content, 10) || 0;
+  }
+  counter++;
+  await Bun.write(counterPath, counter.toString());
+  return counter.toString();
+}
+async function loadAllTasks(base, teamName) {
+  const dir = join2(teamDir(base, teamName), "tasks");
+  const files = await listJsonFiles(dir);
+  const tasks = [];
+  for (const f of files) {
+    tasks.push(await readJson(f));
+  }
+  return tasks;
+}
+function hasCycle(taskId, blockedBy, allTasks) {
+  const visited = new Set;
+  const queue = [...blockedBy];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === taskId)
+      return true;
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const task = allTasks.get(current);
+    if (task)
+      queue.push(...task.blockedBy);
+  }
+  return false;
+}
+async function unblockDependents(base, teamName, completedTaskId) {
+  const unblocked = [];
+  const allTasks = await loadAllTasks(base, teamName);
+  for (const t of allTasks) {
+    if (t.id === completedTaskId)
+      continue;
+    if (!t.blockedBy.includes(completedTaskId))
+      continue;
+    t.blockedBy = t.blockedBy.filter((bid) => bid !== completedTaskId);
+    if (t.blockedBy.length === 0 && t.status === "pending") {
+      unblocked.push(t.id);
+    }
+    await writeJsonAtomic(taskFilePath(base, teamName, t.id), t);
+  }
+  return unblocked;
+}
+
+// src/teams.ts
+async function getActiveTeamsSummary(base) {
+  const root = join3(base, TEAM_ROOT);
+  if (!await exists(root))
+    return null;
+  const entries = await readdir2(root, { withFileTypes: true });
+  const summaries = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const configPath = join3(root, entry.name, "config.json");
+    if (!await exists(configPath))
+      continue;
+    try {
+      const config = await readJson(configPath);
+      const tasks = await loadAllTasks(base, 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 members = config.members.filter((m) => m.isActive).length;
+      if (pending > 0 || inProgress > 0) {
+        summaries.push(`- Team "${config.name}" (${config.description}): ${members} active members, ${inProgress} in_progress, ${pending} pending, ${completed} completed`);
+      }
+    } catch {}
+  }
+  return summaries.length > 0 ? summaries.join(`
+`) : null;
+}
+
+// src/tools/team-tools.ts
+import { readdir as readdir3, rm } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+
+// src/messages.ts
+async function readInbox(inboxPath) {
+  if (!await exists(inboxPath))
+    return [];
+  return readJson(inboxPath);
+}
+async function appendToInbox(inboxPath, message) {
+  const messages = await readInbox(inboxPath);
+  messages.push(message);
+  await writeJsonAtomic(inboxPath, messages);
+}
+
+// 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`;
+      }
+      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]++;
+        }
+      }
+      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);
+    }
+  }),
+  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
+        });
+      }
+      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";
+          }
+        }
+        if (args.addBlockedBy) {
+          try {
+            addBlockedBy = JSON.parse(args.addBlockedBy);
+          } catch {
+            return "Error: Invalid addBlockedBy JSON";
+          }
+        }
+        if (args.metadata) {
+          try {
+            metadata = JSON.parse(args.metadata);
+          } catch {
+            return "Error: Invalid metadata JSON";
+          }
+        }
+        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);
+          }
+        }
+        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);
+          }
+        }
+        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}`;
+          }
+          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(", ")}`;
+            }
+          }
+          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";
+          }
+          task.metadata = { ...task.metadata, ...newMeta };
+        }
+        if (args.addBlocks) {
+          let newBlocks;
+          try {
+            newBlocks = JSON.parse(args.addBlocks);
+          } catch {
+            return "Error: Invalid addBlocks JSON";
+          }
+          for (const targetId of newBlocks) {
+            if (!task.blocks.includes(targetId)) {
+              task.blocks.push(targetId);
+            }
+            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.addBlockedBy) {
+          let newBlockedBy;
+          try {
+            newBlockedBy = JSON.parse(args.addBlockedBy);
+          } catch {
+            return "Error: Invalid addBlockedBy JSON";
+          }
+          for (const targetId of newBlockedBy) {
+            if (!task.blockedBy.includes(targetId)) {
+              task.blockedBy.push(targetId);
+            }
+            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);
+              }
+            }
+          }
+        }
+        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);
+    }
+  }),
+  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`;
+      }
+      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);
+          }
+          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);
+        });
+      }
+    }
+  }),
+  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;
+          }
+        }
+        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";
+    }
+  })
+};
+
+// src/index.ts
+var HDTeamPlugin = async ({ directory }) => {
+  return {
+    "experimental.session.compacting": async (_input, output) => {
+      const teamSummary = await getActiveTeamsSummary(directory);
+      if (teamSummary) {
+        output.context.push(`
+## Active Agent Teams
+
+The following teams are currently active with pending work:
+
+${teamSummary}
+
+Use team_status(teamName) to get full details. Continue any in-progress tasks.
+`);
+      }
+    },
+    tool: {
+      ...teamTools,
+      ...taskTools,
+      ...messageTools
+    }
+  };
+};
+export {
+  HDTeamPlugin
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@hdwebsoft/hdcode-agent-team",
+  "version": "0.1.0",
+  "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",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --external @opencode-ai/plugin",
+    "prepublishOnly": "bun run build",
+    "test": "bun test"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "agent",
+    "team",
+    "multi-agent",
+    "task-management",
+    "inbox",
+    "coordination"
+  ],
+  "author": "HDWebSoft",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hdwebsoft/hdcode-agent-team.git"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.15.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^0.15.0",
+    "@types/bun": "^1.3.1",
+    "typescript": "^5.9.3"
+  }
+}