opencode-multiagent 0.2.1 → 0.4.0

package/dist/index.js

@@ -0,0 +1,1916 @@
+// @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
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var hasBundledAssets = (directory) => {
+  return ["package.json", "agents", "commands", "defaults", "skills"].every((entry) => {
+    return existsSync(join(directory, entry));
+  });
+};
+var detectPackageRoot = () => {
+  let current = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    if (hasBundledAssets(current)) {
+      return current;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+    }
+    current = parent;
+  }
+};
+var pluginName = "opencode-multiagent";
+var pluginMode = "stable";
+var opencodeDir = join(homedir(), ".config", "opencode");
+var pluginDir = join(opencodeDir, "plugins");
+var globalAgentsDir = join(opencodeDir, "agents");
+var globalCommandsDir = join(opencodeDir, "commands");
+var logDirPath = join(opencodeDir, "logs");
+var logFilePath = join(logDirPath, `${pluginName}.jsonl`);
+var settingsPath = join(pluginDir, `${pluginName}.json`);
+var packageRoot = detectPackageRoot();
+var bundledDefaultsPath = join(packageRoot, "defaults", "opencode-multiagent.json");
+var bundledAgentsDir = join(packageRoot, "agents");
+var bundledCommandsDir = join(packageRoot, "commands");
+var bundledSkillsDir = join(packageRoot, "skills");
+var trackedEventTypes = new Set([
+  "permission.updated",
+  "permission.replied",
+  "session.created",
+  "session.status",
+  "session.diff",
+  "file.edited",
+  "session.deleted",
+  "session.idle",
+  "message.updated",
+  "command.executed"
+]);
+var supervisionEventTypes = new Set([
+  "session.created",
+  "message.updated",
+  "session.idle",
+  "session.deleted"
+]);
+var qualityEventTypes = new Set(["file.edited", "session.idle", "session.deleted"]);
+var suspiciousTerms = ["blocked", "failed", "error", "permission", "refused"];
+var qualitySignalRegex = /\b(test|tests|lint|typecheck|tsc|build|pytest|vitest|jest|cargo test|go test|ruff|mypy|eslint|biome|prettier)\b/i;
+var mcpToolPrefixes = [
+  "exa_",
+  "context7_",
+  "gh_grep_",
+  "github_",
+  "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,
+    task_lifecycle: false,
+    quality_gate_enforcement: false,
+    concurrency_limit: 0,
+    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,
+    task_lifecycle: true,
+    quality_gate_enforcement: false,
+    concurrency_limit: 5,
+    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,
+    task_lifecycle: true,
+    quality_gate_enforcement: true,
+    concurrency_limit: 5,
+    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,
+  agent_compilation: true,
+  command_compilation: true,
+  mcp_compilation: true,
+  telemetry: true,
+  supervision: true,
+  quality_gate: true,
+  task_lifecycle: true,
+  quality_gate_enforcement: false,
+  concurrency_limit: 5,
+  skill_sources: [
+    bundledSkillsDir,
+    join(homedir(), ".agents", "skills"),
+    join(homedir(), "skills")
+  ],
+  skill_injection: false,
+  compiler: {
+    permission_compilation: true
+  },
+  experimental: {
+    chat_system_transform: false,
+    chat_messages_transform: false,
+    session_compacting: false,
+    text_complete: false
+  },
+  supervision_config: {
+    idle_timeout_ms: 180000,
+    cooldown_ms: 300000
+  },
+  quality_config: {
+    reminder_idle_ms: 120000,
+    reminder_cooldown_ms: 300000
+  }
+};
+var disabledNativeAgents = ["build", "plan", "general", "explore"];
+var blockedPathPrefixRegex = /^(\/etc|\/root|\/boot|\/proc|\/sys|\/dev)(?:\/|$)/;
+var blockedPathFragments = [
+  "/.ssh/",
+  "/credentials",
+  "/secrets",
+  "/.aws/",
+  "/.gcloud/",
+  "/.kube/"
+];
+var blockedPathSuffixes = ["/.ssh", "/credentials"];
+var destructiveBashFragments = [
+  "git reset --" + "hard",
+  "git che" + "ckout --",
+  "r" + "m -rf /",
+  "r" + "m -rf ~",
+  "su" + "do ",
+  "shut" + "down",
+  "re" + "boot",
+  "mk" + "fs",
+  "dd i" + "f=",
+  "cu" + "rl | ba" + "sh",
+  "cu" + "rl | sh",
+  "wg" + "et | ba" + "sh",
+  "wg" + "et | sh",
+  "ev" + "al $(",
+  "> /de" + "v/",
+  ":" + "(){",
+  "ch" + "mod 777",
+  "ki" + "ll -9 -1",
+  "no" + "hup "
+];
+var sensitiveMentions = [
+  "/etc",
+  "/root",
+  "/boot",
+  "/proc",
+  "/sys",
+  "/dev",
+  "/.ssh",
+  "~/.ssh"
+];
+var experimentalText = "[opencode-multiagent experimental] Experimental control-plane transforms are active for this session.";
+
+// 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 ensureLogDir();
+    await appendFile(logFilePath, `${JSON.stringify({ ts: Date.now(), kind, ...payload })}
+`);
+  } catch {}
+};
+
+// src/opencode-multiagent/markdown.ts
+import { readFile, readdir } from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
+var unquote = (value) => {
+  if (typeof value !== "string" || value.length < 2)
+    return value;
+  const first = value[0];
+  const last = value[value.length - 1];
+  if (first === '"' && last === '"' || first === "'" && last === "'") {
+    return value.slice(1, -1);
+  }
+  return value;
+};
+var parseScalar = (value) => {
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return "";
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return unquote(trimmed);
+  }
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+    return Number(trimmed);
+  return trimmed;
+};
+function parseFrontmatter(value) {
+  if (typeof value !== "string" || !value.startsWith("---")) {
+    return { data: {}, body: value };
+  }
+  const openingMatch = value.match(/^---\r?\n/);
+  if (!openingMatch)
+    return { data: {}, body: value };
+  const rest = value.slice(openingMatch[0].length);
+  const closingIndex = rest.search(/\r?\n---(?:\r?\n|$)/);
+  if (closingIndex < 0)
+    return { data: {}, body: value };
+  const rawFrontmatter = rest.slice(0, closingIndex);
+  const closingSlice = rest.slice(closingIndex);
+  const closingMatch = closingSlice.match(/^\r?\n---(?:\r?\n|$)/);
+  if (!closingMatch)
+    return { data: {}, body: value };
+  const body = closingSlice.slice(closingMatch[0].length);
+  const data = {};
+  const stack = [{ indent: -1, obj: data }];
+  for (const line of rawFrontmatter.split(/\r?\n/)) {
+    if (!line.trim())
+      continue;
+    const indent = line.match(/^ */)?.[0].length ?? 0;
+    const trimmed = line.trim();
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex < 0)
+      continue;
+    const key = String(unquote(trimmed.slice(0, colonIndex).trim()));
+    const rawValue = trimmed.slice(colonIndex + 1).trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].obj;
+    if (rawValue === "") {
+      parent[key] = {};
+      stack.push({ indent, obj: parent[key] });
+      continue;
+    }
+    parent[key] = parseScalar(rawValue);
+  }
+  return { data, body };
+}
+var dedupe = (values) => [
+  ...new Set(values.filter(Boolean).map((value) => resolve2(value)))
+];
+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()) {
+      try {
+        const value = await readFile(join2(dir, file), "utf8");
+        const { data, body } = parseFrontmatter(value);
+        defs.set(file.slice(0, -3), { data, body, source: join2(dir, file) });
+      } catch {}
+    }
+  }
+  return defs;
+}
+
+// src/opencode-multiagent/utils.ts
+import { readFile as readFile2 } from "fs/promises";
+var compact = (value) => Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+var clip = (value, size = 240) => {
+  if (typeof value !== "string")
+    return;
+  if (value.length <= size)
+    return value;
+  return `${value.slice(0, size)}...`;
+};
+var text = (parts) => Array.isArray(parts) ? parts.filter((part) => Boolean(part) && part?.type === "text" && typeof part?.text === "string").map((part) => part.text).join(`
+`) : "";
+var label = (value, keys = ["name", "id", "modelID", "providerID"]) => {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object")
+    return;
+  const objectValue = value;
+  for (const key of keys) {
+    if (typeof objectValue[key] === "string")
+      return objectValue[key];
+  }
+  return;
+};
+var own = (value, key) => Boolean(value) && Object.prototype.hasOwnProperty.call(value, key);
+var clone = (value) => {
+  if (value === undefined)
+    return value;
+  return JSON.parse(JSON.stringify(value));
+};
+var readJSON = async (path, fallback) => {
+  try {
+    return JSON.parse(await readFile2(path, "utf8"));
+  } catch {
+    return clone(fallback);
+  }
+};
+var merge = (base, extra) => {
+  if (!extra || typeof extra !== "object" || Array.isArray(extra)) {
+    return clone(extra !== undefined ? extra : base);
+  }
+  const result = {
+    ...base && typeof base === "object" && !Array.isArray(base) ? base : {}
+  };
+  for (const [key, value] of Object.entries(extra)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      result[key] = value;
+      continue;
+    }
+    result[key] = merge(result[key], value);
+  }
+  return result;
+};
+
+// src/opencode-multiagent/compiler.ts
+var normalizeDefinitionData = (data) => {
+  const result = clone(data) ?? {};
+  delete result.variant;
+  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 = [];
+  for (const [key, value] of Object.entries(permission)) {
+    if (!isMcpPermissionKey(key))
+      continue;
+    if (value === "allow")
+      allowed.push(key);
+    if (value === "deny")
+      denied.push(key);
+  }
+  return { allowed, denied, fallback: permission["*"] === "allow" ? "allow" : "deny" };
+};
+async function compileAgents(cfg, dirs, agentSettings = {}) {
+  const defs = await loadMarkdownDefs(dirs);
+  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)) {
+      cfg.agent[name] = {};
+    } else if (!cfg.agent[name] || typeof cfg.agent[name] !== "object") {
+      continue;
+    }
+    const target = cfg.agent[name];
+    const explicitFields = new Set(Object.keys(target));
+    for (const [field, value] of Object.entries(data)) {
+      if (own(target, field))
+        continue;
+      target[field] = clone(value);
+    }
+    const overrides = agentSettings?.[name];
+    if (overrides && typeof overrides === "object") {
+      for (const [field, value] of Object.entries(overrides)) {
+        if (["model", "temperature", "steps"].includes(field) && !explicitFields.has(field)) {
+          target[field] = clone(value);
+        }
+      }
+    }
+    if (!own(target, "prompt") && typeof raw.body === "string") {
+      target.prompt = raw.body.trim();
+    }
+    const perm = target.permission ?? {};
+    mcpRegistry.set(name, buildMcpPermissionRegistry(perm));
+    taskRouting.set(name, buildTaskRoutingAllowSet(perm));
+  }
+  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")
+    cfg.command = {};
+  for (const [name, raw] of defs.entries()) {
+    const data = normalizeDefinitionData(raw.data);
+    if (!own(cfg.command, name)) {
+      cfg.command[name] = {};
+    } else if (!cfg.command[name] || typeof cfg.command[name] !== "object") {
+      continue;
+    }
+    const target = cfg.command[name];
+    for (const [field, value] of Object.entries(data)) {
+      if (own(target, field))
+        continue;
+      target[field] = clone(value);
+    }
+    if (!own(target, "template") && typeof raw.body === "string") {
+      target.template = raw.body.trim();
+    }
+  }
+}
+var applyBuiltInAgentPolicy = async (cfg) => {
+  if (!cfg.agent || typeof cfg.agent !== "object")
+    cfg.agent = {};
+  for (const name of disabledNativeAgents) {
+    cfg.agent[name] = merge(cfg.agent[name], { disable: true });
+  }
+  const current = typeof cfg.default_agent === "string" ? cfg.default_agent : undefined;
+  const currentAgent = current ? cfg.agent?.[current] : undefined;
+  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;
+    await note("config_warning", compact({
+      observation: true,
+      warning: "default_agent_reset",
+      previous,
+      next: preferred
+    }));
+  }
+};
+var applyPermissionDefaults = (cfg) => {
+  if (!cfg.permission || typeof cfg.permission !== "object")
+    cfg.permission = {};
+  for (const [key, value] of Object.entries({
+    bash: "allow",
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow"
+  })) {
+    if (!own(cfg.permission, key)) {
+      cfg.permission[key] = value;
+    }
+  }
+};
+var matchesMcpPermission = (tool, registry) => {
+  if (!registry)
+    return true;
+  for (const pattern of registry.denied ?? []) {
+    if (pattern.endsWith("*") && tool.startsWith(pattern.slice(0, -1)))
+      return false;
+    if (pattern === tool)
+      return false;
+  }
+  for (const pattern of registry.allowed ?? []) {
+    if (pattern.endsWith("*") && tool.startsWith(pattern.slice(0, -1)))
+      return true;
+    if (pattern === tool)
+      return true;
+  }
+  return registry.fallback === "allow";
+};
+
+// 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, []);
+    }
+    intentQueues.get(parentSessionID).push({
+      taskID,
+      parentSessionID,
+      targetAgent,
+      createdAt: Date.now()
+    });
+  };
+  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;
+    }
+    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
+import { readFile as readFile3 } from "fs/promises";
+var asRecord = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+};
+var cachedDefaults;
+var loadBundledDefaults = async () => {
+  if (cachedDefaults) {
+    return clone(cachedDefaults);
+  }
+  const parsed = JSON.parse(await readFile3(bundledDefaultsPath, "utf8"));
+  cachedDefaults = asRecord(parsed);
+  return clone(cachedDefaults);
+};
+var readBundledDefaultsSection = (defaults, section, fallback) => {
+  const value = defaults[section];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return clone(fallback);
+  }
+  return clone(value);
+};
+
+// src/opencode-multiagent/mcp.ts
+var cachedDefaults2;
+async function loadMcpDefaults() {
+  if (cachedDefaults2)
+    return clone(cachedDefaults2);
+  try {
+    const defaults = await loadBundledDefaults();
+    cachedDefaults2 = readBundledDefaultsSection(defaults, "mcpDefaults", {});
+  } catch {
+    cachedDefaults2 = {};
+    await note("config_warning", {
+      observation: true,
+      warning: "mcp_defaults_unreadable",
+      path: bundledDefaultsPath
+    });
+  }
+  return clone(cachedDefaults2);
+}
+function applyMcpDefaults(cfg, defaults) {
+  if (!cfg.mcp || typeof cfg.mcp !== "object")
+    cfg.mcp = {};
+  const mcp = cfg.mcp;
+  for (const [name, definition] of Object.entries(defaults ?? {})) {
+    if (own(mcp, name))
+      continue;
+    mcp[name] = clone(definition);
+  }
+}
+
+// src/opencode-multiagent/policy.ts
+var normalize = (value) => String(value ?? "").toLowerCase();
+var hasBlockedEnvName = (value) => {
+  const name = value.split("/").pop() ?? "";
+  if (name === ".env.example")
+    return false;
+  return name.endsWith(".env") || name.includes(".env.");
+};
+var blocked = (value) => {
+  const normalized = normalize(value);
+  return blockedPathPrefixRegex.test(normalized) || blockedPathFragments.some((fragment) => normalized.includes(fragment)) || blockedPathSuffixes.some((suffix) => normalized.endsWith(suffix)) || hasBlockedEnvName(normalized);
+};
+var tokenizedBashBlocked = (command) => {
+  const normalized = normalize(command).replace(/\s+/g, " ").trim();
+  if (normalized.length === 0)
+    return false;
+  const forkBombPattern = /(?:^|[;&|])\s*(?::|[a-z_][a-z0-9_]*)\s*\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;?\s*(?::|[a-z_][a-z0-9_]*)\s*(?:$|[;&|])/;
+  if (forkBombPattern.test(normalized))
+    return true;
+  const segments = normalized.split(/&&|\||;/).map((segment) => segment.trim()).filter(Boolean);
+  if (segments.some((segment) => destructiveBashFragments.some((fragment) => segment.includes(fragment)))) {
+    return true;
+  }
+  for (let index = 0;index < segments.length - 1; index += 1) {
+    if (!/^(curl|wget)(?:\s|$)/.test(segments[index]))
+      continue;
+    if (/\b(?:bash|sh)\b/.test(segments[index + 1]))
+      return true;
+  }
+  return false;
+};
+var mentions = (value) => sensitiveMentions.some((fragment) => value.includes(fragment));
+var flagged = (value) => suspiciousTerms.filter((term) => value.includes(term));
+var risky = (value) => {
+  const lower = normalize(value);
+  return mentions(lower) || blocked(lower) || tokenizedBashBlocked(lower);
+};
+
+// src/opencode-multiagent/session-tracker.ts
+function createSessionTracker(config) {
+  const {
+    getActivityTime,
+    onRemove,
+    cleanupIntervalMs = 5 * 60 * 1000,
+    staleTtlMs = 30 * 60 * 1000,
+    maxTracked = 200,
+    evictionFraction = 0.2,
+    enabled
+  } = config;
+  const entries = new Map;
+  const remove = (key) => {
+    entries.delete(key);
+    onRemove?.(key);
+  };
+  const cleanupStale = (now = Date.now()) => {
+    for (const [key, entry] of entries.entries()) {
+      if (now - getActivityTime(entry) > staleTtlMs)
+        remove(key);
+    }
+  };
+  const enforceLimit = () => {
+    if (entries.size <= maxTracked)
+      return;
+    const toEvict = [...entries.entries()].sort((a, b) => getActivityTime(a[1]) - getActivityTime(b[1])).slice(0, Math.max(1, Math.ceil(entries.size * evictionFraction)));
+    for (const [key] of toEvict)
+      remove(key);
+  };
+  let interval = null;
+  if (enabled) {
+    interval = setInterval(() => cleanupStale(), cleanupIntervalMs);
+    interval.unref?.();
+  }
+  const cleanup = () => {
+    if (!interval)
+      return;
+    clearInterval(interval);
+    interval = null;
+  };
+  return { entries, cleanupStale, enforceLimit, cleanup };
+}
+
+// src/opencode-multiagent/quality.ts
+var createQualityController = ({
+  flags,
+  client
+}) => {
+  const tracker = createSessionTracker({
+    getActivityTime: (entry) => entry.lastActivityAt,
+    enabled: Boolean(flags.quality_gate)
+  });
+  const getSessionState = (sessionID) => {
+    if (!tracker.entries.has(sessionID)) {
+      tracker.entries.set(sessionID, {
+        editedFiles: new Set,
+        lastEditAt: 0,
+        qualityRemindedAt: 0,
+        lastQualityEvidenceAt: 0,
+        lastActivityAt: Date.now()
+      });
+    }
+    return tracker.entries.get(sessionID);
+  };
+  const trackEdit = (sessionID, filePath) => {
+    if (!sessionID || !filePath)
+      return;
+    const state = getSessionState(sessionID);
+    state.editedFiles.add(filePath);
+    state.lastEditAt = Date.now();
+    state.lastActivityAt = Date.now();
+    tracker.enforceLimit();
+  };
+  const recordQualityEvidence = (sessionID, command) => {
+    if (!sessionID || typeof command !== "string")
+      return;
+    if (!qualitySignalRegex.test(command))
+      return;
+    const state = getSessionState(sessionID);
+    state.lastQualityEvidenceAt = Date.now();
+    state.lastActivityAt = Date.now();
+  };
+  const handleQualityEvent = async (event) => {
+    if (!flags.quality_gate || !qualityEventTypes.has(event?.type ?? ""))
+      return;
+    const props = event.properties ?? {};
+    if (event.type === "file.edited") {
+      const sessionID = typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.sessionID === "string" ? props.info.sessionID : undefined;
+      const file = typeof props.file === "string" ? props.file : typeof props.info?.file === "string" ? props.info.file : undefined;
+      trackEdit(sessionID, file);
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = typeof props.sessionID === "string" ? props.sessionID : undefined;
+      if (!sessionID || !client?.session?.prompt)
+        return;
+      const state = tracker.entries.get(sessionID);
+      if (!state || state.editedFiles.size === 0)
+        return;
+      state.lastActivityAt = Date.now();
+      if (state.lastQualityEvidenceAt >= state.lastEditAt)
+        return;
+      const now = Date.now();
+      const idleMs = flags.quality_config?.reminder_idle_ms ?? 120000;
+      const cooldownMs = flags.quality_config?.reminder_cooldown_ms ?? 300000;
+      if (now - state.lastEditAt < idleMs || now - state.qualityRemindedAt < cooldownMs)
+        return;
+      state.qualityRemindedAt = now;
+      const files = [...state.editedFiles].slice(0, 6).join(", ");
+      const reminder = "[opencode-multiagent quality] This session edited files and no later verification signal was observed. " + "Run `/quality` or equivalent repo-native checks before treating the work as done." + (files ? ` Tracked files: ${files}` : "");
+      try {
+        await client.session.prompt({
+          path: { id: sessionID },
+          body: { parts: [{ type: "text", text: reminder }], noReply: true }
+        });
+      } catch {
+        return;
+      }
+      await note("quality_gate", {
+        event: "idle_reminder",
+        sessionID,
+        files: [...state.editedFiles].slice(0, 12)
+      });
+      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)
+        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
+  };
+};
+
+// src/opencode-multiagent/supervision.ts
+var createSupervisionController = ({
+  flags,
+  client
+}) => {
+  const childMap = new Map;
+  const cleanupChildMap = (childID) => {
+    const info = tracker.entries.get(childID);
+    if (!info)
+      return;
+    const children = childMap.get(info.parentID);
+    if (!children)
+      return;
+    children.delete(childID);
+    if (children.size === 0)
+      childMap.delete(info.parentID);
+  };
+  const tracker = createSessionTracker({
+    getActivityTime: (entry) => entry.lastActivity,
+    maxTracked: 100,
+    onRemove: cleanupChildMap,
+    enabled: true
+  });
+  const removeChild = (childID) => {
+    const info = tracker.entries.get(childID);
+    if (!info)
+      return false;
+    const children = childMap.get(info.parentID);
+    if (children) {
+      children.delete(childID);
+      if (children.size === 0)
+        childMap.delete(info.parentID);
+    }
+    tracker.entries.delete(childID);
+    return true;
+  };
+  const handleSupervision = async (event) => {
+    if (!supervisionEventTypes.has(event?.type ?? ""))
+      return;
+    const props = event.properties ?? {};
+    if (event.type === "session.created") {
+      const parentID = typeof props.info?.parentID === "string" ? props.info.parentID : undefined;
+      const childID = typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.id === "string" ? props.info.id : undefined;
+      if (!parentID || !childID)
+        return;
+      removeChild(childID);
+      if (!childMap.has(parentID))
+        childMap.set(parentID, new Set);
+      childMap.get(parentID)?.add(childID);
+      tracker.entries.set(childID, {
+        parentID,
+        agentName: null,
+        lastActivity: Date.now(),
+        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))
+        return;
+      const info = tracker.entries.get(sessionID);
+      info.lastActivity = Date.now();
+      if (event.type === "message.updated" && props.info?.role === "assistant" && typeof props.info?.agent === "string") {
+        info.agentName = props.info.agent;
+      }
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = typeof props.sessionID === "string" ? props.sessionID : undefined;
+      if (!sessionID || !tracker.entries.has(sessionID) || !client?.session?.prompt)
+        return;
+      const info = tracker.entries.get(sessionID);
+      const now = Date.now();
+      const idleTimeout = flags.supervision_config?.idle_timeout_ms ?? 180000;
+      const cooldown = flags.supervision_config?.cooldown_ms ?? 300000;
+      if (now - info.lastActivity < idleTimeout || now - info.remindedAt < cooldown)
+        return;
+      info.remindedAt = now;
+      const reminderText = `[opencode-multiagent supervision] Child session ${sessionID} ` + `(agent: ${info.agentName ?? "unknown"}) has been idle. Check status or resume if needed.`;
+      try {
+        await client.session.prompt({
+          path: { id: info.parentID },
+          body: { parts: [{ type: "text", text: reminderText }], noReply: true }
+        });
+      } catch {
+        return;
+      }
+      await note("supervision", {
+        event: "idle_reminder",
+        parentID: info.parentID,
+        childID: sessionID,
+        agentName: info.agentName
+      });
+      return;
+    }
+  };
+  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;
+    }
+  };
+};
+
+// src/opencode-multiagent/task-manager.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+var createTaskManager = (projectRoot) => {
+  let taskCounter = 0;
+  const generateTaskID = () => {
+    taskCounter += 1;
+    return `T-${Date.now()}-${taskCounter.toString().padStart(4, "0")}`;
+  };
+  const tasks = new Map;
+  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 {} 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 = {
+      id: generateTaskID(),
+      title: input.title,
+      description: input.description,
+      status: "pending",
+      priority: input.priority ?? "medium",
+      assignedAgent: input.assignedAgent,
+      createdBy: input.createdBy,
+      dependencies: input.dependencies ?? [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    tasks.set(task.id, task);
+    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)
+      task.result = input.result;
+    if (input.assignedAgent !== undefined)
+      task.assignedAgent = input.assignedAgent;
+    task.updatedAt = Date.now();
+    schedulePersist();
+    return task;
+  };
+  const get = (taskID) => {
+    const task = tasks.get(taskID);
+    if (!task)
+      return { error: `Task ${taskID} not found` };
+    return task;
+  };
+  const list = (filter) => {
+    const all = [...tasks.values()];
+    if (!filter)
+      return all;
+    return all.filter((task) => {
+      if (filter.status && task.status !== filter.status)
+        return false;
+      if (filter.assignedAgent && task.assignedAgent !== filter.assignedAgent)
+        return false;
+      return true;
+    });
+  };
+  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
+var createTelemetryController = ({ flags }) => {
+  const tracker = createSessionTracker({
+    getActivityTime: (entry) => entry.lastActivityAt,
+    enabled: Boolean(flags.telemetry)
+  });
+  const ensureSession = (sessionID, extra = {}) => {
+    if (!sessionID)
+      return null;
+    const now = Date.now();
+    if (!tracker.entries.has(sessionID)) {
+      tracker.entries.set(sessionID, {
+        sessionID,
+        agent: undefined,
+        model: undefined,
+        startedAt: now,
+        lastActivityAt: now,
+        toolCalls: 0,
+        toolErrors: 0,
+        filesEdited: 0,
+        tasksDispatched: 0,
+        permissionDenied: 0,
+        flushed: false,
+        ...extra
+      });
+    }
+    const state = tracker.entries.get(sessionID);
+    const safeExtra = Object.fromEntries(Object.entries(extra).filter(([, v]) => v !== undefined));
+    Object.assign(state, safeExtra);
+    state.lastActivityAt = now;
+    return state;
+  };
+  return {
+    cleanup: tracker.cleanup,
+    rememberSession(sessionID, extra = {}) {
+      ensureSession(sessionID, extra);
+      tracker.enforceLimit();
+    },
+    trackEdit(sessionID) {
+      const state = ensureSession(sessionID);
+      if (!state)
+        return;
+      state.filesEdited += 1;
+    },
+    trackToolCall(sessionID, extra = {}) {
+      const state = ensureSession(sessionID, extra);
+      if (!state)
+        return;
+      state.toolCalls += 1;
+    },
+    trackToolError(sessionID, extra = {}) {
+      const state = ensureSession(sessionID, extra);
+      if (!state)
+        return;
+      state.toolErrors += 1;
+    },
+    trackTaskDispatch(sessionID, extra = {}) {
+      const state = ensureSession(sessionID, extra);
+      if (!state)
+        return;
+      state.tasksDispatched += 1;
+    },
+    trackPermissionDenied(sessionID, extra = {}) {
+      const state = ensureSession(sessionID, extra);
+      if (!state)
+        return;
+      state.permissionDenied += 1;
+    },
+    async flushSession(sessionID, reason = "session_deleted") {
+      const state = tracker.entries.get(sessionID);
+      if (!state || state.flushed)
+        return;
+      state.flushed = true;
+      tracker.entries.delete(sessionID);
+      await note("session_metrics", {
+        observation: true,
+        sessionID,
+        agent: state.agent,
+        model: state.model,
+        duration_ms: Math.max(0, Date.now() - state.startedAt),
+        tool_calls: state.toolCalls,
+        tool_errors: state.toolErrors,
+        files_edited: state.filesEdited,
+        tasks_dispatched: state.tasksDispatched,
+        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, correlation, quality, flags) => ({
+  task_create: pluginTool({
+    description: "Create a new task on the shared task board",
+    args: {
+      title: pluginTool.schema.string().describe("Short title for the task"),
+      description: pluginTool.schema.string().describe("Detailed description of what needs to be done"),
+      assignedAgent: pluginTool.schema.string().optional().describe("Name of the agent to assign this task to"),
+      dependencies: pluginTool.schema.array(pluginTool.schema.string()).optional().describe("IDs of tasks this task depends on"),
+      priority: pluginTool.schema.enum(["high", "medium", "low"]).optional().describe("Task priority: high, medium, or low")
+    },
+    async execute(args, ctx) {
+      await 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. " + "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"),
+      force: pluginTool.schema.boolean().optional().describe("Force completion even without quality evidence (bypass quality gate)")
+    },
+    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: {
+      status: pluginTool.schema.string().optional().describe("Filter by task status"),
+      assignedAgent: pluginTool.schema.string().optional().describe("Filter by assigned agent name")
+    },
+    async execute(args) {
+      await taskManagerReady;
+      return JSON.stringify(taskManager.list(args));
+    }
+  })
+});
+
+// src/opencode-multiagent/hooks.ts
+var isMcpTool = (tool) => typeof tool === "string" && mcpToolPrefixes.some((prefix) => tool.startsWith(prefix));
+var qaWarningThreshold = 3;
+var qaWarningCooldownMs = 5 * 60 * 1000;
+var getTaskTarget = (args = {}) => {
+  for (const key of ["subagent_type", "agent", "subagent", "type", "name"]) {
+    if (typeof args?.[key] === "string")
+      return args[key];
+  }
+  return;
+};
+var createPluginHooks = ({
+  client,
+  flags,
+  agentSettings,
+  projectRoot
+}) => {
+  const projectAgentsDir = projectRoot ? join4(projectRoot, ".opencode", "agents") : undefined;
+  const projectCommandsDir = projectRoot ? join4(projectRoot, ".opencode", "commands") : undefined;
+  const supervision = createSupervisionController({ flags, client });
+  const { handleSupervision, cleanup, getChildInfo } = supervision;
+  const quality = createQualityController({ flags, client });
+  const telemetry = createTelemetryController({ flags });
+  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 rememberSession = (sessionID, extra = {}) => {
+    if (!sessionID)
+      return;
+    const current = sessionAgentMap.get(sessionID) ?? {};
+    const next = { ...current, ...extra };
+    sessionAgentMap.set(sessionID, next);
+    telemetry.rememberSession(sessionID, next);
+  };
+  const trackQaDispatch = async (sessionID, agentInfo = {}) => {
+    if (!sessionID)
+      return;
+    const state = qaDispatchState.get(sessionID) ?? { count: 0, remindedAt: 0 };
+    state.count += 1;
+    qaDispatchState.set(sessionID, state);
+    if (state.count < qaWarningThreshold || !client?.session?.prompt)
+      return;
+    const now = Date.now();
+    if (now - state.remindedAt < qaWarningCooldownMs)
+      return;
+    state.remindedAt = now;
+    try {
+      await client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          noReply: true,
+          parts: [
+            {
+              type: "text",
+              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."
+            }
+          ]
+        }
+      });
+    } catch {
+      return;
+    }
+    await note("qa_counter_warning", {
+      observation: true,
+      sessionID,
+      agent: agentInfo.agent,
+      model: agentInfo.model,
+      qa_dispatch_count: state.count
+    });
+  };
+  const notifyParentOnChildCompletion = async (childSessionID, parentSessionID, agentName, taskLabel) => {
+    const agentLabel = agentName ? ` (agent: ${agentName})` : "";
+    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({
+          path: { id: parentSessionID },
+          body: { parts: [{ type: "text", text: text2 }], noReply: false }
+        });
+      } else if (client.session?.promptAsync) {
+        await client.session.promptAsync({
+          sessionID: parentSessionID,
+          noReply: false,
+          parts: [{ type: "text", text: text2 }]
+        });
+      } else {
+        return;
+      }
+      await note("child_completion_notify", {
+        observation: true,
+        childSessionID,
+        parentSessionID,
+        agentName
+      });
+    } catch {
+      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 {
+    async cleanup() {
+      await telemetry.flushAll();
+      cleanup?.();
+      quality.cleanup?.();
+      telemetry.cleanup?.();
+    },
+    async event(input) {
+      const type = input.event?.type;
+      const props = input.event?.properties ?? {};
+      if (flags.observation && trackedEventTypes.has(type)) {
+        await note("event", compact({
+          event: type,
+          data: compact({
+            sessionID: typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.sessionID === "string" ? props.info.sessionID : undefined,
+            messageID: typeof props.messageID === "string" ? props.messageID : undefined,
+            partID: typeof props.partID === "string" ? props.partID : undefined,
+            permissionID: typeof props.permissionID === "string" ? props.permissionID : undefined,
+            response: typeof props.response === "string" ? props.response : undefined,
+            file: typeof props.file === "string" ? clip(props.file) : undefined,
+            error: typeof props.error?.message === "string" ? clip(props.error.message) : undefined
+          })
+        }));
+      }
+      if (type === "session.created") {
+        const parentID = typeof props.info?.parentID === "string" ? props.info.parentID : undefined;
+        const childID = typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.id === "string" ? props.info.id : undefined;
+        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
+          });
+        }
+      } 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 });
+        }
+      } 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 = getChildInfo(sessionID);
+          sessionAgentMap.delete(sessionID);
+          qaDispatchState.delete(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, taskLabel);
+          }
+        }
+      } 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);
+      await quality.handleQualityEvent(input.event);
+    },
+    async "permission.ask"(input, output) {
+      if (!flags.enforcement)
+        return;
+      const patternValue = Array.isArray(input.pattern) ? input.pattern.join(" ") : String(input.pattern ?? "");
+      if (["read", "edit", "external_directory"].includes(input.type) && blocked(patternValue)) {
+        output.status = "deny";
+        return;
+      }
+      if (input.type === "bash" && tokenizedBashBlocked(patternValue)) {
+        output.status = "deny";
+      }
+    },
+    async "chat.params"(input, output) {
+      rememberSession(input.sessionID, {
+        agent: label(input.agent),
+        model: label(input.model, ["id", "name", "modelID"])
+      });
+      if (!flags.observation)
+        return;
+      const marks = [];
+      if (typeof output.temperature === "number" && output.temperature > 1)
+        marks.push("high_temperature");
+      if (typeof output.topK === "number" && output.topK > 0)
+        marks.push("nonzero_top_k");
+      if (Object.keys(output.options ?? {}).length > 0)
+        marks.push("non_empty_options");
+      await note("chat_params", compact({
+        observation: true,
+        sessionID: input.sessionID,
+        agent: label(input.agent),
+        provider: compact({
+          source: input.provider?.source,
+          id: label(input.provider?.info, ["id", "name", "providerID"])
+        }),
+        model: compact({
+          id: label(input.model, ["id", "name", "modelID"]),
+          providerID: label(input.model, ["providerID"])
+        }),
+        params: compact({
+          temperature: output.temperature,
+          topP: output.topP,
+          topK: output.topK,
+          optionKeys: Object.keys(output.options ?? {})
+        }),
+        heuristic: marks.length > 0 ? marks : undefined
+      }));
+    },
+    async "chat.headers"(input, output) {
+      if (!flags.prompt_controls)
+        return;
+      Object.assign(output.headers, {
+        "x-opencode-multiagent": "1",
+        "x-opencode-multiagent-profile": flags.profile ?? "standard",
+        "x-opencode-agent": label(input.agent) ?? "unknown"
+      });
+    },
+    async "chat.message"(input, output) {
+      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,
+        sessionID: input.sessionID,
+        agent: label(input.agent),
+        text: clip(text(output.parts))
+      }));
+    },
+    async "command.execute.before"(input) {
+      if (!flags.prompt_controls || !risky(input.arguments))
+        return;
+      await note("command_risk", compact({
+        observation: true,
+        sessionID: input.sessionID,
+        command: input.command,
+        arguments: clip(input.arguments)
+      }));
+    },
+    async "experimental.chat.system.transform"(_input, output) {
+      if (flags.experimental?.chat_system_transform !== true)
+        return;
+      if (output.system.includes(experimentalText))
+        return;
+      output.system.push(experimentalText);
+    },
+    async "experimental.chat.messages.transform"(_input, output) {
+      if (flags.experimental?.chat_messages_transform !== true)
+        return;
+      const last = [...output.messages].reverse().find((message) => message.info?.role === "user");
+      if (!last)
+        return;
+      if (text(last.parts).includes(experimentalText))
+        return;
+      last.parts.push({ type: "text", text: experimentalText });
+    },
+    async "experimental.session.compacting"(_input, output) {
+      if (flags.experimental?.session_compacting !== true)
+        return;
+      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)
+        return;
+      if (output.text.includes(experimentalText))
+        return;
+      output.text += `
+${experimentalText}`;
+    },
+    async config(sdkCfg) {
+      const cfg = sdkCfg;
+      if (flags.agent_compilation) {
+        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]);
+      }
+      if (flags.mcp_compilation !== false) {
+        mcpDefaults ??= await loadMcpDefaults();
+        applyMcpDefaults(cfg, mcpDefaults);
+      }
+      await applyBuiltInAgentPolicy(cfg);
+      if (flags.compiler?.permission_compilation === true) {
+        applyPermissionDefaults(cfg);
+      }
+    },
+    async "tool.execute.before"(input, output) {
+      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 === "reviewer") {
+          await trackQaDispatch(input.sessionID, agentInfo);
+        }
+        if (flags.enforcement && agentName && targetAgent && taskRoutingRegistry && !isTaskRoutingAllowed(agentName, targetAgent, taskRoutingRegistry)) {
+          telemetry.trackPermissionDenied(input.sessionID, {
+            agent: agentName,
+            model: agentInfo.model
+          });
+          await note("permission_denied", {
+            observation: true,
+            sessionID: input.sessionID,
+            agent: agentName,
+            model: agentInfo.model,
+            tool: "task",
+            target: targetAgent,
+            reason: "task_routing_not_allowed",
+            enforcement_layer: "plugin_hook"
+          });
+          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)) {
+        const allowed = matchesMcpPermission(input.tool, mcpRegistry.get(agentName));
+        if (!allowed) {
+          telemetry.trackPermissionDenied(input.sessionID, {
+            agent: agentName,
+            model: agentInfo.model
+          });
+          await note("permission_denied", {
+            observation: true,
+            sessionID: input.sessionID,
+            agent: agentName,
+            model: agentInfo.model,
+            tool: input.tool,
+            reason: "mcp_tool_not_allowed",
+            enforcement_layer: "plugin_hook"
+          });
+          throw new Error(`[opencode-multiagent] MCP tool ${input.tool} not allowed for agent ${agentName}`);
+        }
+      }
+    },
+    async "tool.definition"(input, output) {
+      if (!flags.enforcement)
+        return;
+      if (input.toolID === "bash") {
+        output.description += `
+
+[Policy] Commands matching destructive patterns (rm -rf /, sudo, shutdown, reboot, git reset --hard, etc.) are blocked by opencode-multiagent.`;
+      }
+      if (input.toolID === "read") {
+        output.description += `
+
+[Policy] Reads targeting sensitive system paths (/etc, /root, /proc, /sys, /dev, /boot, .ssh) are blocked.`;
+      }
+      if (input.toolID === "edit") {
+        output.description += `
+
+[Policy] Edits targeting sensitive system paths (/etc, /root, /proc, /sys, /dev, /boot, .ssh) are blocked.`;
+      }
+      if (input.toolID === "webfetch") {
+        output.description += `
+
+[Policy] http:// URLs are automatically upgraded to https://.`;
+      }
+    },
+    async "shell.env"(_input, output) {
+      if (!flags.enforcement)
+        return;
+      Object.assign(output.env, {
+        OPENCODE_MULTIAGENT: "1",
+        OPENCODE_MULTIAGENT_MODE: pluginMode,
+        OPENCODE_MULTIAGENT_PROFILE: flags.profile ?? "standard",
+        OPENCODE_CONTROL_PLANE: "1"
+      });
+    },
+    async "tool.execute.after"(input, output) {
+      if (input.tool === "edit" && typeof input.args?.filePath === "string") {
+        quality.trackEdit(input.sessionID, input.args.filePath);
+        telemetry.trackEdit(input.sessionID);
+      }
+      if (input.tool === "bash" && typeof input.args?.command === "string") {
+        quality.recordQualityEvidence(input.sessionID, input.args.command);
+      }
+      const agentInfo = sessionAgentMap.get(input.sessionID) ?? {};
+      telemetry.trackToolCall(input.sessionID, { agent: agentInfo.agent, model: agentInfo.model });
+      const isNonzeroExit = typeof output.metadata?.exit === "number" && output.metadata.exit !== 0;
+      if (isNonzeroExit) {
+        telemetry.trackToolError(input.sessionID, {
+          agent: agentInfo.agent,
+          model: agentInfo.model
+        });
+        supervision.recordToolError(input.sessionID);
+      }
+      if (!flags.observation)
+        return;
+      const lower = `${String(output.title ?? "")}
+${String(output.output ?? "")}`.toLowerCase();
+      const marks = flagged(lower);
+      if (isNonzeroExit)
+        marks.push("nonzero_exit");
+      await note("tool_after", compact({
+        observation: true,
+        tool: input.tool,
+        sessionID: input.sessionID,
+        callID: input.callID,
+        title: clip(output.title),
+        args: input.args,
+        suspicious: marks.length > 0,
+        flags: marks,
+        output: clip(output.output),
+        ...isNonzeroExit ? { exit_code: output.metadata.exit, error_type: "nonzero_exit" } : {}
+      }));
+    },
+    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([
+    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 flags = merge(merge(defaultFlags, profile), userFlags);
+  const agentSettings = merge(defaultAgentSettings, userAgentSettings);
+  return { flags, agentSettings };
+}
+
+// src/control-plane.ts
+var OpenCodeMultiAgentPlugin = async (context) => {
+  const client = context.client;
+  const projectRoot = context.worktree || context.directory;
+  const { flags, agentSettings } = await loadRuntimeSettings();
+  return createPluginHooks({
+    client,
+    flags,
+    agentSettings,
+    projectRoot
+  });
+};
+var control_plane_default = OpenCodeMultiAgentPlugin;
+
+// src/index.ts
+var plugin = control_plane_default;
+var src_default = plugin;
+export {
+  src_default as default,
+  plugin as OpenCodeMultiAgentPlugin
+};