opencode-multiagent 0.3.0-next.1 → 0.5.0

package/dist/index.js

@@ -1,5 +1,6 @@
 // @bun
 // src/opencode-multiagent/hooks.ts
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import { join as join4 } from "path";
 
 // src/opencode-multiagent/constants.ts
@@ -49,15 +50,11 @@ var trackedEventTypes = new Set([
   "session.deleted",
   "session.idle",
   "message.updated",
-  "message.part.updated",
-  "message.part.delta",
   "command.executed"
 ]);
 var supervisionEventTypes = new Set([
   "session.created",
   "message.updated",
-  "message.part.updated",
-  "message.part.delta",
   "session.idle",
   "session.deleted"
 ]);
@@ -72,67 +69,7 @@ var mcpToolPrefixes = [
   "code_index_",
   "repo_git_"
 ];
-var defaultProfiles = {
-  minimal: {
-    enforcement: true,
-    observation: false,
-    prompt_controls: false,
-    agent_compilation: true,
-    command_compilation: true,
-    mcp_compilation: true,
-    telemetry: false,
-    supervision: false,
-    quality_gate: false,
-    experimental: {
-      chat_system_transform: false,
-      chat_messages_transform: false,
-      session_compacting: false,
-      text_complete: false
-    }
-  },
-  standard: {
-    enforcement: true,
-    observation: true,
-    prompt_controls: true,
-    agent_compilation: true,
-    command_compilation: true,
-    mcp_compilation: true,
-    telemetry: true,
-    supervision: true,
-    quality_gate: true,
-    skill_sources: [
-      bundledSkillsDir,
-      join(homedir(), ".agents", "skills"),
-      join(homedir(), "skills")
-    ],
-    skill_injection: false,
-    experimental: {
-      chat_system_transform: false,
-      chat_messages_transform: false,
-      session_compacting: false,
-      text_complete: false
-    }
-  },
-  strict: {
-    enforcement: true,
-    observation: true,
-    prompt_controls: true,
-    agent_compilation: true,
-    command_compilation: true,
-    mcp_compilation: true,
-    telemetry: true,
-    supervision: true,
-    quality_gate: true,
-    experimental: {
-      chat_system_transform: true,
-      chat_messages_transform: true,
-      session_compacting: true,
-      text_complete: true
-    }
-  }
-};
 var defaultFlags = {
-  profile: "standard",
   enforcement: true,
   observation: true,
   prompt_controls: true,
@@ -142,6 +79,9 @@ var defaultFlags = {
   telemetry: true,
   supervision: true,
   quality_gate: true,
+  task_lifecycle: true,
+  quality_gate_enforcement: true,
+  concurrency_limit: 5,
   skill_sources: [
     bundledSkillsDir,
     join(homedir(), ".agents", "skills"),
@@ -152,10 +92,10 @@ var defaultFlags = {
     permission_compilation: true
   },
   experimental: {
-    chat_system_transform: false,
-    chat_messages_transform: false,
-    session_compacting: false,
-    text_complete: false
+    chat_system_transform: true,
+    chat_messages_transform: true,
+    session_compacting: true,
+    text_complete: true
   },
   supervision_config: {
     idle_timeout_ms: 180000,
@@ -212,9 +152,18 @@ var experimentalText = "[opencode-multiagent experimental] Experimental control-
 
 // src/opencode-multiagent/log.ts
 import { appendFile, mkdir } from "fs/promises";
+var _initPromise = null;
+var ensureLogDir = () => {
+  if (_initPromise === null) {
+    _initPromise = mkdir(logDirPath, { recursive: true }).then(() => {
+      return;
+    });
+  }
+  return _initPromise;
+};
 var note = async (kind, payload) => {
   try {
-    await mkdir(logDirPath, { recursive: true });
+    await ensureLogDir();
     await appendFile(logFilePath, `${JSON.stringify({ ts: Date.now(), kind, ...payload })}
 `);
   } catch {}
@@ -297,7 +246,7 @@ async function loadMarkdownDefs(dirs) {
   const defs = new Map;
   for (const dir of dedupe(dirs)) {
     const files = await readdir(dir).catch(() => []);
-    for (const file of files.filter((name) => name.endsWith(".md")).sort()) {
+    for (const file of files.filter((name) => name.endsWith(".md") && name !== name.toUpperCase()).sort()) {
       try {
         const value = await readFile(join2(dir, file), "utf8");
         const { data, body } = parseFrontmatter(value);
@@ -369,6 +318,22 @@ var normalizeDefinitionData = (data) => {
   return result;
 };
 var isMcpPermissionKey = (key) => mcpToolPrefixes.some((prefix) => key === prefix || key.startsWith(prefix));
+var buildTaskRoutingAllowSet = (permission = {}) => {
+  const allowed = new Set;
+  const taskPerm = permission.task;
+  if (taskPerm === "allow" || taskPerm === true)
+    return new Set(["*"]);
+  if (taskPerm === "deny" || taskPerm === false || !taskPerm || typeof taskPerm !== "object")
+    return allowed;
+  const taskObj = taskPerm;
+  for (const [key, value] of Object.entries(taskObj)) {
+    if (key === "*")
+      continue;
+    if (value === "allow" || value === true)
+      allowed.add(key);
+  }
+  return allowed;
+};
 var buildMcpPermissionRegistry = (permission = {}) => {
   const allowed = [];
   const denied = [];
@@ -387,6 +352,7 @@ async function compileAgents(cfg, dirs, agentSettings = {}) {
   if (!cfg.agent || typeof cfg.agent !== "object")
     cfg.agent = {};
   const mcpRegistry = new Map;
+  const taskRouting = new Map;
   for (const [name, raw] of defs.entries()) {
     const data = normalizeDefinitionData(raw.data);
     if (!own(cfg.agent, name)) {
@@ -412,10 +378,20 @@ async function compileAgents(cfg, dirs, agentSettings = {}) {
     if (!own(target, "prompt") && typeof raw.body === "string") {
       target.prompt = raw.body.trim();
     }
-    mcpRegistry.set(name, buildMcpPermissionRegistry(target.permission ?? {}));
+    const perm = target.permission ?? {};
+    mcpRegistry.set(name, buildMcpPermissionRegistry(perm));
+    taskRouting.set(name, buildTaskRoutingAllowSet(perm));
   }
-  return mcpRegistry;
+  return { mcpRegistry, taskRouting };
 }
+var isTaskRoutingAllowed = (agent, target, routing) => {
+  const allowed = routing.get(agent);
+  if (!allowed)
+    return true;
+  if (allowed.has("*"))
+    return true;
+  return allowed.has(target);
+};
 async function compileCommands(cfg, dirs) {
   const defs = await loadMarkdownDefs(dirs);
   if (!cfg.command || typeof cfg.command !== "object")
@@ -446,8 +422,8 @@ var applyBuiltInAgentPolicy = async (cfg) => {
   }
   const current = typeof cfg.default_agent === "string" ? cfg.default_agent : undefined;
   const currentAgent = current ? cfg.agent?.[current] : undefined;
-  const preferred = cfg.agent.lead && cfg.agent.lead.disable !== true ? "lead" : cfg.agent.critic && cfg.agent.critic.disable !== true ? "critic" : undefined;
-  const invalidCurrent = !current || disabledNativeAgents.includes(current) || !currentAgent || currentAgent.disable === true || currentAgent.hidden === true || currentAgent.mode === "subagent" || currentAgent.mode === "sub" || preferred === "lead" && current !== "lead";
+  const preferred = cfg.agent.planner && cfg.agent.planner.disable !== true ? "planner" : cfg.agent.executor && cfg.agent.executor.disable !== true ? "executor" : undefined;
+  const invalidCurrent = !current || disabledNativeAgents.includes(current) || !currentAgent || currentAgent.disable === true || currentAgent.hidden === true || currentAgent.mode === "subagent" || currentAgent.mode === "sub" || preferred === "planner" && current !== "planner";
   if (invalidCurrent && preferred) {
     const previous = current;
     cfg.default_agent = preferred;
@@ -493,67 +469,72 @@ var matchesMcpPermission = (tool, registry) => {
   return registry.fallback === "allow";
 };
 
-// src/opencode-multiagent/file-lock.ts
-var cleanupIntervalMs = 5 * 60 * 1000;
-var staleLockTtlMs = 30 * 60 * 1000;
-var normalizeFilePath = (filePath) => typeof filePath === "string" ? filePath.replace(/\\/g, "/") : undefined;
-var createFileLockController = () => {
-  const locks = new Map;
-  const sessionFiles = new Map;
-  const trackSessionFile = (sessionID, filePath) => {
-    if (!sessionFiles.has(sessionID))
-      sessionFiles.set(sessionID, new Set);
-    sessionFiles.get(sessionID)?.add(filePath);
-  };
-  const releaseAll = (sessionID) => {
-    const files = sessionFiles.get(sessionID);
-    if (!files)
-      return 0;
-    let count = 0;
-    for (const filePath of files) {
-      const existing = locks.get(filePath);
-      if (existing?.sessionID === sessionID) {
-        locks.delete(filePath);
-        count += 1;
-      }
+// src/opencode-multiagent/correlation.ts
+var INTENT_TTL_MS = 60000;
+var createCorrelationController = () => {
+  const intentQueues = new Map;
+  const links = new Map;
+  const taskIndex = new Map;
+  const recordIntent = (parentSessionID, taskID, targetAgent) => {
+    if (!intentQueues.has(parentSessionID)) {
+      intentQueues.set(parentSessionID, []);
     }
-    sessionFiles.delete(sessionID);
-    return count;
+    intentQueues.get(parentSessionID).push({
+      taskID,
+      parentSessionID,
+      targetAgent,
+      createdAt: Date.now()
+    });
   };
-  const cleanupStaleLocks = (now = Date.now()) => {
-    for (const [filePath, info] of locks.entries()) {
-      if (now - info.lastTouchedAt <= staleLockTtlMs)
-        continue;
-      locks.delete(filePath);
-      const files = sessionFiles.get(info.sessionID);
-      if (files) {
-        files.delete(filePath);
-        if (files.size === 0)
-          sessionFiles.delete(info.sessionID);
-      }
+  const tryCorrelate = (parentSessionID, childSessionID, agentHint) => {
+    const queue = intentQueues.get(parentSessionID);
+    if (!queue || queue.length === 0)
+      return;
+    const now = Date.now();
+    const fresh = queue.filter((i) => now - i.createdAt < INTENT_TTL_MS);
+    if (fresh.length === 0) {
+      intentQueues.delete(parentSessionID);
+      return;
     }
-  };
-  const interval = setInterval(() => cleanupStaleLocks(), cleanupIntervalMs);
-  interval.unref?.();
-  return {
-    acquire(sessionID, filePath) {
-      const normalized = normalizeFilePath(filePath);
-      if (!sessionID || !normalized)
-        return { ok: true, filePath: normalized };
-      const existing = locks.get(normalized);
-      if (existing && existing.sessionID !== sessionID) {
-        return { ok: false, filePath: normalized, ownerSessionID: existing.sessionID };
-      }
-      locks.set(normalized, { sessionID, lastTouchedAt: Date.now() });
-      trackSessionFile(sessionID, normalized);
-      return { ok: true, filePath: normalized };
-    },
-    releaseAll,
-    cleanup() {
-      cleanupStaleLocks();
-      clearInterval(interval);
+    intentQueues.set(parentSessionID, fresh);
+    let matchIdx = -1;
+    if (agentHint) {
+      matchIdx = fresh.findIndex((i) => i.targetAgent === agentHint);
+    }
+    if (matchIdx < 0) {
+      matchIdx = 0;
     }
+    const intent = fresh.splice(matchIdx, 1)[0];
+    if (fresh.length === 0)
+      intentQueues.delete(parentSessionID);
+    const link = {
+      taskID: intent.taskID,
+      childSessionID,
+      parentSessionID,
+      linkedAt: now
+    };
+    links.set(childSessionID, link);
+    taskIndex.set(intent.taskID, childSessionID);
+    return link;
+  };
+  const getLink = (childSessionID) => {
+    return links.get(childSessionID);
   };
+  const getLinkByTask = (taskID) => {
+    const childID = taskIndex.get(taskID);
+    if (!childID)
+      return;
+    return links.get(childID);
+  };
+  const removeLink = (childSessionID) => {
+    const link = links.get(childSessionID);
+    if (!link)
+      return;
+    links.delete(childSessionID);
+    taskIndex.delete(link.taskID);
+    return link;
+  };
+  return { recordIntent, tryCorrelate, getLink, getLinkByTask, removeLink };
 };
 
 // src/opencode-multiagent/defaults.ts
@@ -653,7 +634,7 @@ function createSessionTracker(config) {
   const {
     getActivityTime,
     onRemove,
-    cleanupIntervalMs: cleanupIntervalMs2 = 5 * 60 * 1000,
+    cleanupIntervalMs = 5 * 60 * 1000,
     staleTtlMs = 30 * 60 * 1000,
     maxTracked = 200,
     evictionFraction = 0.2,
@@ -679,7 +660,7 @@ function createSessionTracker(config) {
   };
   let interval = null;
   if (enabled) {
-    interval = setInterval(() => cleanupStale(), cleanupIntervalMs2);
+    interval = setInterval(() => cleanupStale(), cleanupIntervalMs);
     interval.unref?.();
   }
   const cleanup = () => {
@@ -779,10 +760,22 @@ var createQualityController = ({
         tracker.entries.delete(sessionID);
     }
   };
+  const hasQualityEvidence = (sessionID) => {
+    const state = tracker.entries.get(sessionID);
+    if (!state || state.editedFiles.size === 0)
+      return { passed: true };
+    if (state.lastQualityEvidenceAt >= state.lastEditAt)
+      return { passed: true };
+    return {
+      passed: false,
+      reason: `${state.editedFiles.size} file(s) edited, no verification evidence found`
+    };
+  };
   return {
     handleQualityEvent,
     recordQualityEvidence,
     trackEdit,
+    hasQualityEvidence,
     cleanup: tracker.cleanup
   };
 };
@@ -808,7 +801,7 @@ var createSupervisionController = ({
     getActivityTime: (entry) => entry.lastActivity,
     maxTracked: 100,
     onRemove: cleanupChildMap,
-    enabled: Boolean(flags.supervision)
+    enabled: true
   });
   const removeChild = (childID) => {
     const info = tracker.entries.get(childID);
@@ -824,7 +817,7 @@ var createSupervisionController = ({
     return true;
   };
   const handleSupervision = async (event) => {
-    if (!flags.supervision || !supervisionEventTypes.has(event?.type ?? ""))
+    if (!supervisionEventTypes.has(event?.type ?? ""))
       return;
     const props = event.properties ?? {};
     if (event.type === "session.created") {
@@ -840,12 +833,23 @@ var createSupervisionController = ({
         parentID,
         agentName: null,
         lastActivity: Date.now(),
-        remindedAt: 0
+        remindedAt: 0,
+        lastToolErrorAt: 0,
+        hasUnverifiedEdits: false
       });
       tracker.enforceLimit();
       await note("supervision", { event: "child_tracked", parentID, childID });
       return;
     }
+    if (event.type === "session.deleted") {
+      const sessionID = typeof props.info?.id === "string" ? props.info.id : typeof props.sessionID === "string" ? props.sessionID : undefined;
+      if (!sessionID || !removeChild(sessionID))
+        return;
+      await note("supervision", { event: "child_removed", sessionID });
+      return;
+    }
+    if (!flags.supervision)
+      return;
     if (["message.updated", "message.part.updated", "message.part.delta"].includes(event.type ?? "")) {
       const sessionID = event.type === "message.updated" ? typeof props.info?.sessionID === "string" ? props.info.sessionID : undefined : event.type === "message.part.updated" ? typeof props.part?.sessionID === "string" ? props.part.sessionID : undefined : typeof props.sessionID === "string" ? props.sessionID : undefined;
       if (!sessionID || !tracker.entries.has(sessionID))
@@ -885,14 +889,33 @@ var createSupervisionController = ({
       });
       return;
     }
-    if (event.type === "session.deleted") {
-      const sessionID = typeof props.info?.id === "string" ? props.info.id : undefined;
-      if (!sessionID || !removeChild(sessionID))
-        return;
-      await note("supervision", { event: "child_removed", sessionID });
+  };
+  const recordToolError = (sessionID) => {
+    const info = tracker.entries.get(sessionID);
+    if (info)
+      info.lastToolErrorAt = Date.now();
+  };
+  const recordVerification = (sessionID) => {
+    const info = tracker.entries.get(sessionID);
+    if (info)
+      info.hasUnverifiedEdits = false;
+  };
+  const getActiveChildCount = (parentID) => {
+    return childMap.get(parentID)?.size ?? 0;
+  };
+  return {
+    handleSupervision,
+    cleanup: tracker.cleanup,
+    recordToolError,
+    recordVerification,
+    getActiveChildCount,
+    getChildInfo(sessionID) {
+      return tracker.entries.get(sessionID);
+    },
+    getParentID(sessionID) {
+      return tracker.entries.get(sessionID)?.parentID;
     }
   };
-  return { handleSupervision, cleanup: tracker.cleanup };
 };
 
 // src/opencode-multiagent/task-manager.ts
@@ -905,24 +928,83 @@ var createTaskManager = (projectRoot) => {
     return `T-${Date.now()}-${taskCounter.toString().padStart(4, "0")}`;
   };
   const tasks = new Map;
-  const boardPath = projectRoot ? join3(projectRoot, ".opencode", "tasks", "taskboard.json") : undefined;
-  const persist = async () => {
+  const boardPath = projectRoot ? join3(projectRoot, ".magent", "board.json") : undefined;
+  const legacyBoardPath = projectRoot ? join3(projectRoot, ".opencode", "tasks", "taskboard.json") : undefined;
+  let persistTimer = null;
+  let persistInFlight = false;
+  let persistQueued = false;
+  const doPersist = async () => {
     if (!boardPath)
       return;
+    if (persistInFlight) {
+      persistQueued = true;
+      return;
+    }
+    persistInFlight = true;
     try {
       await mkdir2(join3(boardPath, ".."), { recursive: true });
       await writeFile(boardPath, JSON.stringify([...tasks.values()], null, 2), "utf8");
-    } catch {}
+    } catch {} finally {
+      persistInFlight = false;
+      if (persistQueued) {
+        persistQueued = false;
+        doPersist();
+      }
+    }
+  };
+  const schedulePersist = () => {
+    if (persistTimer)
+      clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      doPersist();
+    }, 100);
   };
   const load = async () => {
     if (!boardPath)
       return;
+    let loaded = false;
     try {
       const raw = await readFile4(boardPath, "utf8");
       const items = JSON.parse(raw);
       for (const item of items)
         tasks.set(item.id, item);
+      loaded = true;
     } catch {}
+    if (!loaded && legacyBoardPath) {
+      try {
+        const raw = await readFile4(legacyBoardPath, "utf8");
+        const items = JSON.parse(raw);
+        for (const item of items)
+          tasks.set(item.id, item);
+        loaded = true;
+        schedulePersist();
+      } catch {}
+    }
+    if (loaded) {
+      for (const task of tasks.values()) {
+        if (task.status === "in_progress" || task.status === "claimed") {
+          task.status = "pending";
+          task.updatedAt = Date.now();
+          task.result = (task.result ? task.result + " | " : "") + "Reset from stale state on load";
+        }
+      }
+      if (tasks.size > 0)
+        schedulePersist();
+    }
+  };
+  const areDependenciesMet = (taskID) => {
+    const task = tasks.get(taskID);
+    if (!task || task.dependencies.length === 0)
+      return { met: true, unmet: [] };
+    const unmet = [];
+    for (const depID of task.dependencies) {
+      const dep = tasks.get(depID);
+      if (!dep || dep.status !== "completed") {
+        unmet.push(depID);
+      }
+    }
+    return { met: unmet.length === 0, unmet };
   };
   const create = (input) => {
     const task = {
@@ -938,13 +1020,21 @@ var createTaskManager = (projectRoot) => {
       updatedAt: Date.now()
     };
     tasks.set(task.id, task);
-    persist();
+    schedulePersist();
     return task;
   };
   const update = (taskID, input) => {
     const task = tasks.get(taskID);
     if (!task)
       return { error: `Task ${taskID} not found` };
+    if (input.status && (input.status === "in_progress" || input.status === "claimed") && task.dependencies.length > 0) {
+      const { met, unmet } = areDependenciesMet(taskID);
+      if (!met) {
+        return {
+          error: `Cannot transition ${taskID} to ${input.status}: unmet dependencies [${unmet.join(", ")}]`
+        };
+      }
+    }
     if (input.status !== undefined)
       task.status = input.status;
     if (input.result !== undefined)
@@ -952,7 +1042,13 @@ var createTaskManager = (projectRoot) => {
     if (input.assignedAgent !== undefined)
       task.assignedAgent = input.assignedAgent;
     task.updatedAt = Date.now();
-    persist();
+    schedulePersist();
+    return task;
+  };
+  const get = (taskID) => {
+    const task = tasks.get(taskID);
+    if (!task)
+      return { error: `Task ${taskID} not found` };
     return task;
   };
   const list = (filter) => {
@@ -967,7 +1063,25 @@ var createTaskManager = (projectRoot) => {
       return true;
     });
   };
-  return { create, update, list, load };
+  const getActiveSummary = () => {
+    const active = [...tasks.values()].filter((t) => t.status === "pending" || t.status === "claimed" || t.status === "in_progress");
+    if (active.length === 0)
+      return "";
+    const lines = active.slice(0, 10).map((t) => `- [${t.status}] ${t.title}${t.assignedAgent ? ` (${t.assignedAgent})` : ""}`);
+    return `Active tasks (${active.length}):
+${lines.join(`
+`)}`;
+  };
+  const linkSession = (taskID, sessionID) => {
+    const task = tasks.get(taskID);
+    if (!task)
+      return false;
+    task.sessionID = sessionID;
+    task.updatedAt = Date.now();
+    schedulePersist();
+    return true;
+  };
+  return { create, update, get, list, load, getActiveSummary, linkSession };
 };
 
 // src/opencode-multiagent/telemetry.ts
@@ -992,11 +1106,13 @@ var createTelemetryController = ({ flags }) => {
         filesEdited: 0,
         tasksDispatched: 0,
         permissionDenied: 0,
+        flushed: false,
         ...extra
       });
     }
     const state = tracker.entries.get(sessionID);
-    Object.assign(state, extra);
+    const safeExtra = Object.fromEntries(Object.entries(extra).filter(([, v]) => v !== undefined));
+    Object.assign(state, safeExtra);
     state.lastActivityAt = now;
     return state;
   };
@@ -1038,8 +1154,9 @@ var createTelemetryController = ({ flags }) => {
     },
     async flushSession(sessionID, reason = "session_deleted") {
       const state = tracker.entries.get(sessionID);
-      if (!state)
+      if (!state || state.flushed)
         return;
+      state.flushed = true;
       tracker.entries.delete(sessionID);
       await note("session_metrics", {
         observation: true,
@@ -1054,13 +1171,19 @@ var createTelemetryController = ({ flags }) => {
         permission_denied: state.permissionDenied,
         reason
       });
+    },
+    async flushAll() {
+      const ids = [...tracker.entries.keys()];
+      for (const id of ids) {
+        await this.flushSession(id, "cleanup");
+      }
     }
   };
 };
 
 // src/opencode-multiagent/tools.ts
 import { tool as pluginTool } from "@opencode-ai/plugin";
-var createTaskTools = (taskManager, taskManagerReady) => ({
+var createTaskTools = (taskManager, taskManagerReady, correlation, quality, flags) => ({
   task_create: pluginTool({
     description: "Create a new task on the shared task board",
     args: {
@@ -1075,18 +1198,84 @@ var createTaskTools = (taskManager, taskManagerReady) => ({
       return JSON.stringify(taskManager.create({ ...args, createdBy: ctx.agent }));
     }
   }),
+  task_dispatch: pluginTool({
+    description: "Record a dispatch intent linking a task board entry to the next child session. " + "Call this immediately before dispatching work via the task tool. " + "Sets the task status to in_progress and records the correlation intent.",
+    args: {
+      taskID: pluginTool.schema.string().describe("ID of the task being dispatched"),
+      notes: pluginTool.schema.string().optional().describe("Optional dispatch notes or context")
+    },
+    async execute(args, ctx) {
+      await taskManagerReady;
+      const task = taskManager.get(args.taskID);
+      if ("error" in task)
+        return JSON.stringify(task);
+      const updated = taskManager.update(args.taskID, { status: "in_progress" });
+      if ("error" in updated)
+        return JSON.stringify(updated);
+      if (correlation) {
+        const parentSessionID = ctx.sessionID ?? "";
+        const targetAgent = task.assignedAgent ?? "unknown";
+        correlation.recordIntent(parentSessionID, args.taskID, targetAgent);
+      }
+      await note("task_dispatch_intent", {
+        taskID: args.taskID,
+        agent: ctx.agent,
+        notes: args.notes
+      });
+      return JSON.stringify({
+        ...updated,
+        dispatch: "intent_recorded",
+        notes: args.notes
+      });
+    }
+  }),
   task_update: pluginTool({
-    description: "Update a task's status or result on the shared task board",
+    description: "Update a task's status or result on the shared task board. " + "Dependency enforcement: transitions to in_progress or claimed are blocked if dependencies are not completed.",
     args: {
       taskID: pluginTool.schema.string().describe("ID of the task to update"),
       status: pluginTool.schema.enum(["pending", "claimed", "in_progress", "completed", "failed", "blocked"]).describe("New status for the task"),
-      result: pluginTool.schema.string().optional().describe("Result summary or notes")
+      result: pluginTool.schema.string().optional().describe("Result summary or notes"),
+      force: pluginTool.schema.boolean().optional().describe("Force completion even without quality evidence (bypass quality gate)")
     },
-    async execute(args) {
+    async execute(args, ctx) {
       await taskManagerReady;
+      if (flags?.quality_gate_enforcement && args.status === "completed" && !args.force && quality) {
+        const link = correlation?.getLinkByTask(args.taskID);
+        if (link) {
+          const evidence = quality.hasQualityEvidence(link.childSessionID);
+          if (!evidence.passed) {
+            await note("quality_gate_blocked", {
+              taskID: args.taskID,
+              sessionID: link.childSessionID,
+              reason: evidence.reason
+            });
+            return JSON.stringify({
+              error: `Quality gate: ${evidence.reason}. Run verification commands (test/lint/build) before completing, or pass force: true to bypass.`,
+              taskID: args.taskID,
+              quality_gate: "blocked"
+            });
+          }
+        }
+      }
+      if (args.force && args.status === "completed") {
+        await note("quality_gate_bypassed", {
+          taskID: args.taskID,
+          agent: ctx.agent
+        });
+      }
       return JSON.stringify(taskManager.update(args.taskID, { status: args.status, result: args.result }));
     }
   }),
+  task_get: pluginTool({
+    description: "Get a single task by ID from the shared task board",
+    args: {
+      taskID: pluginTool.schema.string().describe("ID of the task to retrieve")
+    },
+    async execute(args) {
+      await taskManagerReady;
+      return JSON.stringify(taskManager.get(args.taskID));
+    }
+  }),
   task_list: pluginTool({
     description: "List tasks on the shared task board with optional filters",
     args: {
@@ -1119,17 +1308,18 @@ var createPluginHooks = ({
 }) => {
   const projectAgentsDir = projectRoot ? join4(projectRoot, ".opencode", "agents") : undefined;
   const projectCommandsDir = projectRoot ? join4(projectRoot, ".opencode", "commands") : undefined;
-  const { handleSupervision, cleanup } = createSupervisionController({ flags, client });
+  const supervision = createSupervisionController({ flags, client });
+  const { handleSupervision, cleanup, getChildInfo } = supervision;
   const quality = createQualityController({ flags, client });
   const telemetry = createTelemetryController({ flags });
-  const fileLocks = createFileLockController();
+  const correlation = createCorrelationController();
   const sessionAgentMap = new Map;
   const qaDispatchState = new Map;
   let mcpDefaults = null;
   let mcpRegistry = null;
+  let taskRoutingRegistry = null;
   const taskManager = createTaskManager(projectRoot);
   const taskManagerReady = taskManager.load();
-  const childSessionInfo = new Map;
   const rememberSession = (sessionID, extra = {}) => {
     if (!sessionID)
       return;
@@ -1158,7 +1348,7 @@ var createPluginHooks = ({
           parts: [
             {
               type: "text",
-              text: `[opencode-multiagent qa] This session has dispatched QA ${state.count} times. ` + "Reassess the brief, consider planner repair, or narrow the defect before sending QA again."
+              text: `[opencode-multiagent review] This session has dispatched reviewer ${state.count} times. ` + "Reassess the brief, consider planner repair, or narrow the defect before sending reviewer again."
             }
           ]
         }
@@ -1174,9 +1364,10 @@ var createPluginHooks = ({
       qa_dispatch_count: state.count
     });
   };
-  const notifyParentOnChildCompletion = async (childSessionID, parentSessionID, agentName) => {
+  const notifyParentOnChildCompletion = async (childSessionID, parentSessionID, agentName, taskLabel) => {
     const agentLabel = agentName ? ` (agent: ${agentName})` : "";
-    const text2 = `Child session ${childSessionID}${agentLabel} has completed. ` + "Review its output and proceed with the next task.";
+    const taskInfo = taskLabel ? `, task ${taskLabel}` : "";
+    const text2 = `Child session ${childSessionID}${agentLabel}${taskInfo} has completed. ` + "Review its output and proceed with the next task.";
     try {
       if (client.session?.prompt) {
         await client.session.prompt({
@@ -1202,13 +1393,31 @@ var createPluginHooks = ({
       return;
     }
   };
+  const loadActivePlanSummary = async () => {
+    if (!projectRoot)
+      return "";
+    const plansDir = join4(projectRoot, ".magent", "plans");
+    try {
+      const entries = await readdir2(plansDir);
+      const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
+      if (mdFiles.length === 0)
+        return "";
+      const lastPlan = mdFiles[mdFiles.length - 1];
+      const content = await readFile5(join4(plansDir, lastPlan), "utf8");
+      const objectiveMatch = content.match(/##\s+Objective\s*\n([\s\S]*?)(?=\n##|\s*$)/);
+      const objective = objectiveMatch ? objectiveMatch[1].trim().split(`
+`)[0].slice(0, 200) : "";
+      return objective ? `Active plan: ${lastPlan} \u2014 ${objective}` : `Active plan: ${lastPlan}`;
+    } catch {
+      return "";
+    }
+  };
   return {
-    cleanup() {
+    async cleanup() {
+      await telemetry.flushAll();
       cleanup?.();
       quality.cleanup?.();
       telemetry.cleanup?.();
-      fileLocks.cleanup?.();
-      childSessionInfo.clear();
     },
     async event(input) {
       const type = input.event?.type;
@@ -1233,35 +1442,65 @@ var createPluginHooks = ({
         if (parentID && childID) {
           const parent = sessionAgentMap.get(parentID) ?? {};
           telemetry.trackTaskDispatch(parentID, { agent: parent.agent, model: parent.model });
+          const agentHint = typeof props.info?.agent === "string" ? props.info.agent : undefined;
+          const link = correlation.tryCorrelate(parentID, childID, agentHint);
+          if (link) {
+            taskManager.linkSession(link.taskID, childID);
+            await note("task_correlation", {
+              observation: true,
+              taskID: link.taskID,
+              parentSessionID: parentID,
+              childSessionID: childID,
+              agentHint
+            });
+          }
           await note("task_dispatch", {
             observation: true,
             parent_sessionID: parentID,
             parent_agent: parent.agent,
             child_sessionID: childID
           });
-          childSessionInfo.set(childID, { parentID, agentName: null });
         }
       } else if (type === "message.updated") {
         const sessionID = typeof props.info?.sessionID === "string" ? props.info.sessionID : undefined;
         const agent = typeof props.info?.agent === "string" ? props.info.agent : undefined;
         if (sessionID && agent) {
           rememberSession(sessionID, { agent });
-          const childInfo = childSessionInfo.get(sessionID);
-          if (childInfo)
-            childInfo.agentName = agent;
         }
       } else if (type === "session.deleted") {
         const sessionID = typeof props.info?.id === "string" ? props.info.id : typeof props.sessionID === "string" ? props.sessionID : undefined;
         if (sessionID) {
-          const childInfo = childSessionInfo.get(sessionID);
+          const childInfo = getChildInfo(sessionID);
           sessionAgentMap.delete(sessionID);
           qaDispatchState.delete(sessionID);
-          fileLocks.releaseAll(sessionID);
           await telemetry.flushSession(sessionID);
+          let taskLabel;
+          const link = correlation.getLink(sessionID);
+          if (link && flags.task_lifecycle) {
+            const recentErrorMs = 30000;
+            const hasRecentError = childInfo?.lastToolErrorAt != null && childInfo.lastToolErrorAt > 0 && Date.now() - childInfo.lastToolErrorAt < recentErrorMs;
+            const autoStatus = hasRecentError ? "failed" : "completed";
+            const autoResult = hasRecentError ? "Auto-failed: tool error detected near session end" : "Auto-completed: session ended without recent errors";
+            await taskManagerReady;
+            taskManager.update(link.taskID, { status: autoStatus, result: autoResult });
+            taskLabel = link.taskID;
+            await note("task_lifecycle_auto", {
+              observation: true,
+              taskID: link.taskID,
+              childSessionID: sessionID,
+              autoStatus
+            });
+          }
+          if (link)
+            correlation.removeLink(sessionID);
           if (childInfo?.parentID) {
-            await notifyParentOnChildCompletion(sessionID, childInfo.parentID, childInfo.agentName);
+            await notifyParentOnChildCompletion(sessionID, childInfo.parentID, childInfo.agentName, taskLabel);
           }
-          childSessionInfo.delete(sessionID);
+        }
+      } else if (type === "session.idle") {
+        const sessionID = typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.id === "string" ? props.info.id : undefined;
+        if (sessionID) {
+          await telemetry.flushSession(sessionID, "session_idle");
         }
       }
       await handleSupervision(input.event);
@@ -1319,12 +1558,13 @@ var createPluginHooks = ({
         return;
       Object.assign(output.headers, {
         "x-opencode-multiagent": "1",
-        "x-opencode-multiagent-profile": flags.profile ?? "standard",
+        "x-opencode-multiagent-profile": pluginMode,
         "x-opencode-agent": label(input.agent) ?? "unknown"
       });
     },
     async "chat.message"(input, output) {
-      if (!flags.prompt_controls || !risky(text(output.parts)))
+      const userParts = Array.isArray(output.parts) ? output.parts.filter((p) => p?.type === "text" && p?.role !== "tool") : output.parts;
+      if (!flags.prompt_controls || !risky(text(userParts)))
         return;
       await note("chat_risk", compact({
         observation: true,
@@ -1363,9 +1603,22 @@ var createPluginHooks = ({
     async "experimental.session.compacting"(_input, output) {
       if (flags.experimental?.session_compacting !== true)
         return;
-      if (output.context.includes(experimentalText))
-        return;
-      output.context.push(experimentalText);
+      const parts = [];
+      const planSummary = await loadActivePlanSummary();
+      if (planSummary)
+        parts.push(planSummary);
+      await taskManagerReady;
+      const taskSummary = taskManager.getActiveSummary();
+      if (taskSummary)
+        parts.push(taskSummary);
+      if (parts.length > 0) {
+        output.context.push(`[opencode-multiagent workflow state]
+${parts.join(`
+
+`)}`);
+      } else if (!output.context.includes(experimentalText)) {
+        output.context.push(experimentalText);
+      }
     },
     async "experimental.text.complete"(_input, output) {
       if (flags.experimental?.text_complete !== true)
@@ -1378,7 +1631,9 @@ ${experimentalText}`;
     async config(sdkCfg) {
       const cfg = sdkCfg;
       if (flags.agent_compilation) {
-        mcpRegistry = await compileAgents(cfg, [bundledAgentsDir, globalAgentsDir, projectAgentsDir], agentSettings);
+        const result = await compileAgents(cfg, [bundledAgentsDir, globalAgentsDir, projectAgentsDir], agentSettings);
+        mcpRegistry = result.mcpRegistry;
+        taskRoutingRegistry = result.taskRouting;
       }
       if (flags.command_compilation) {
         await compileCommands(cfg, [bundledCommandsDir, globalCommandsDir, projectCommandsDir]);
@@ -1396,23 +1651,24 @@ ${experimentalText}`;
       const agentInfo = sessionAgentMap.get(input.sessionID) ?? {};
       const agentName = agentInfo.agent;
       if (input.tool === "task") {
+        const limit = flags.concurrency_limit;
+        if (typeof limit === "number" && limit > 0 && input.sessionID) {
+          const activeCount = supervision.getActiveChildCount(input.sessionID);
+          if (activeCount >= limit) {
+            await note("concurrency_blocked", {
+              observation: true,
+              sessionID: input.sessionID,
+              activeCount,
+              limit
+            });
+            throw new Error(`[opencode-multiagent] Concurrency limit reached: ${activeCount}/${limit} active child sessions. ` + "Wait for existing sessions to complete before dispatching new work.");
+          }
+        }
         const targetAgent = getTaskTarget(output.args ?? input.args ?? {});
-        if (targetAgent === "qa") {
+        if (targetAgent === "reviewer") {
           await trackQaDispatch(input.sessionID, agentInfo);
         }
-      }
-      if (input.tool === "webfetch" && typeof output.args?.url === "string" && output.args.url.startsWith("http://")) {
-        output.args.url = output.args.url.replace("http://", "https://");
-      }
-      if (flags.enforcement && ["read", "edit"].includes(input.tool) && typeof output.args?.filePath === "string" && blocked(output.args.filePath)) {
-        throw new Error("[opencode-multiagent] blocked sensitive path access");
-      }
-      if (flags.enforcement && input.tool === "bash" && typeof output.args?.command === "string" && tokenizedBashBlocked(output.args.command)) {
-        throw new Error("[opencode-multiagent] blocked destructive bash command");
-      }
-      if (input.tool === "edit" && typeof output.args?.filePath === "string") {
-        const lock = fileLocks.acquire(input.sessionID, output.args.filePath);
-        if (!lock.ok) {
+        if (flags.enforcement && agentName && targetAgent && taskRoutingRegistry && !isTaskRoutingAllowed(agentName, targetAgent, taskRoutingRegistry)) {
           telemetry.trackPermissionDenied(input.sessionID, {
             agent: agentName,
             model: agentInfo.model
@@ -1422,15 +1678,23 @@ ${experimentalText}`;
             sessionID: input.sessionID,
             agent: agentName,
             model: agentInfo.model,
-            tool: input.tool,
-            file: lock.filePath,
-            reason: "file_locked_by_other_session",
-            owner_sessionID: lock.ownerSessionID,
+            tool: "task",
+            target: targetAgent,
+            reason: "task_routing_not_allowed",
             enforcement_layer: "plugin_hook"
           });
-          throw new Error(`[opencode-multiagent] File lock conflict for ${lock.filePath}; active session ${lock.ownerSessionID}`);
+          throw new Error(`[opencode-multiagent] Agent ${agentName} is not allowed to delegate to ${targetAgent}`);
         }
       }
+      if (input.tool === "webfetch" && typeof output.args?.url === "string" && output.args.url.startsWith("http://")) {
+        output.args.url = output.args.url.replace("http://", "https://");
+      }
+      if (flags.enforcement && ["read", "edit"].includes(input.tool) && typeof output.args?.filePath === "string" && blocked(output.args.filePath)) {
+        throw new Error("[opencode-multiagent] blocked sensitive path access");
+      }
+      if (flags.enforcement && input.tool === "bash" && typeof output.args?.command === "string" && tokenizedBashBlocked(output.args.command)) {
+        throw new Error("[opencode-multiagent] blocked destructive bash command");
+      }
       if (!flags.enforcement)
         return;
       if (isMcpTool(input.tool) && agentName && mcpRegistry?.has(agentName)) {
@@ -1483,7 +1747,7 @@ ${experimentalText}`;
       Object.assign(output.env, {
         OPENCODE_MULTIAGENT: "1",
         OPENCODE_MULTIAGENT_MODE: pluginMode,
-        OPENCODE_MULTIAGENT_PROFILE: flags.profile ?? "standard",
+        OPENCODE_MULTIAGENT_PROFILE: pluginMode,
         OPENCODE_CONTROL_PLANE: "1"
       });
     },
@@ -1491,7 +1755,6 @@ ${experimentalText}`;
       if (input.tool === "edit" && typeof input.args?.filePath === "string") {
         quality.trackEdit(input.sessionID, input.args.filePath);
         telemetry.trackEdit(input.sessionID);
-        fileLocks.acquire(input.sessionID, input.args.filePath);
       }
       if (input.tool === "bash" && typeof input.args?.command === "string") {
         quality.recordQualityEvidence(input.sessionID, input.args.command);
@@ -1504,6 +1767,7 @@ ${experimentalText}`;
           agent: agentInfo.agent,
           model: agentInfo.model
         });
+        supervision.recordToolError(input.sessionID);
       }
       if (!flags.observation)
         return;
@@ -1525,37 +1789,26 @@ ${String(output.output ?? "")}`.toLowerCase();
         ...isNonzeroExit ? { exit_code: output.metadata.exit, error_type: "nonzero_exit" } : {}
       }));
     },
-    tool: createTaskTools(taskManager, taskManagerReady)
+    tool: createTaskTools(taskManager, taskManagerReady, correlation, quality, flags)
   };
 };
 
 // src/opencode-multiagent/runtime.ts
-var readSettingsSection = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value;
-};
 async function loadRuntimeSettings() {
-  const [bundledDefaults, unifiedUserSettings] = await Promise.all([
+  const [bundledDefaults, userSettings] = await Promise.all([
     loadBundledDefaults().catch(() => ({})),
     readJSON(settingsPath, {})
   ]);
   const defaultAgentSettings = readBundledDefaultsSection(bundledDefaults, "agentSettings", {});
-  const userFlags = readSettingsSection(unifiedUserSettings.flags);
-  const userAgentSettings = readSettingsSection(unifiedUserSettings.agentSettings);
-  const userProfiles = readSettingsSection(unifiedUserSettings.profiles);
-  const profiles = merge(defaultProfiles, userProfiles);
-  const profileName = typeof userFlags.profile === "string" ? userFlags.profile : defaultFlags.profile;
-  const profile = profiles[profileName] ?? {};
-  if (!(profileName in profiles)) {
-    await note("config_warning", {
-      observation: true,
-      warning: "unknown_profile",
-      profile: profileName
-    });
+  const userFlagOverrides = {};
+  if (typeof userSettings.telemetry === "boolean") {
+    userFlagOverrides.telemetry = userSettings.telemetry;
+  }
+  if (typeof userSettings.concurrency_limit === "number") {
+    userFlagOverrides.concurrency_limit = userSettings.concurrency_limit;
   }
-  const flags = merge(merge(defaultFlags, profile), userFlags);
+  const flags = merge(defaultFlags, userFlagOverrides);
+  const userAgentSettings = userSettings.agentSettings ?? {};
   const agentSettings = merge(defaultAgentSettings, userAgentSettings);
   return { flags, agentSettings };
 }