opencode-multiagent 0.2.0 → 0.3.0-next.1

package/dist/index.js

@@ -0,0 +1,1583 @@
+// @bun
+// src/opencode-multiagent/hooks.ts
+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",
+  "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"
+]);
+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,
+    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,
+  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,
+  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 note = async (kind, payload) => {
+  try {
+    await mkdir(logDirPath, { recursive: true });
+    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 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;
+  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();
+    }
+    mcpRegistry.set(name, buildMcpPermissionRegistry(target.permission ?? {}));
+  }
+  return mcpRegistry;
+}
+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.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";
+  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/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;
+      }
+    }
+    sessionFiles.delete(sessionID);
+    return count;
+  };
+  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 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);
+    }
+  };
+};
+
+// 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: cleanupIntervalMs2 = 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(), cleanupIntervalMs2);
+    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);
+    }
+  };
+  return {
+    handleQualityEvent,
+    recordQualityEvidence,
+    trackEdit,
+    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: Boolean(flags.supervision)
+  });
+  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 (!flags.supervision || !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
+      });
+      tracker.enforceLimit();
+      await note("supervision", { event: "child_tracked", parentID, childID });
+      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;
+    }
+    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 });
+    }
+  };
+  return { handleSupervision, cleanup: tracker.cleanup };
+};
+
+// 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, ".opencode", "tasks", "taskboard.json") : undefined;
+  const persist = async () => {
+    if (!boardPath)
+      return;
+    try {
+      await mkdir2(join3(boardPath, ".."), { recursive: true });
+      await writeFile(boardPath, JSON.stringify([...tasks.values()], null, 2), "utf8");
+    } catch {}
+  };
+  const load = async () => {
+    if (!boardPath)
+      return;
+    try {
+      const raw = await readFile4(boardPath, "utf8");
+      const items = JSON.parse(raw);
+      for (const item of items)
+        tasks.set(item.id, item);
+    } catch {}
+  };
+  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);
+    persist();
+    return task;
+  };
+  const update = (taskID, input) => {
+    const task = tasks.get(taskID);
+    if (!task)
+      return { error: `Task ${taskID} not found` };
+    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();
+    persist();
+    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;
+    });
+  };
+  return { create, update, list, load };
+};
+
+// 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,
+        ...extra
+      });
+    }
+    const state = tracker.entries.get(sessionID);
+    Object.assign(state, extra);
+    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)
+        return;
+      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
+      });
+    }
+  };
+};
+
+// src/opencode-multiagent/tools.ts
+import { tool as pluginTool } from "@opencode-ai/plugin";
+var createTaskTools = (taskManager, taskManagerReady) => ({
+  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_update: pluginTool({
+    description: "Update a task's status or result on the shared task board",
+    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")
+    },
+    async execute(args) {
+      await taskManagerReady;
+      return JSON.stringify(taskManager.update(args.taskID, { status: args.status, result: args.result }));
+    }
+  }),
+  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 { handleSupervision, cleanup } = createSupervisionController({ flags, client });
+  const quality = createQualityController({ flags, client });
+  const telemetry = createTelemetryController({ flags });
+  const fileLocks = createFileLockController();
+  const sessionAgentMap = new Map;
+  const qaDispatchState = new Map;
+  let mcpDefaults = null;
+  let mcpRegistry = null;
+  const taskManager = createTaskManager(projectRoot);
+  const taskManagerReady = taskManager.load();
+  const childSessionInfo = new Map;
+  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 qa] This session has dispatched QA ${state.count} times. ` + "Reassess the brief, consider planner repair, or narrow the defect before sending QA 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) => {
+    const agentLabel = agentName ? ` (agent: ${agentName})` : "";
+    const text2 = `Child session ${childSessionID}${agentLabel} 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;
+    }
+  };
+  return {
+    cleanup() {
+      cleanup?.();
+      quality.cleanup?.();
+      telemetry.cleanup?.();
+      fileLocks.cleanup?.();
+      childSessionInfo.clear();
+    },
+    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 });
+          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);
+          sessionAgentMap.delete(sessionID);
+          qaDispatchState.delete(sessionID);
+          fileLocks.releaseAll(sessionID);
+          await telemetry.flushSession(sessionID);
+          if (childInfo?.parentID) {
+            await notifyParentOnChildCompletion(sessionID, childInfo.parentID, childInfo.agentName);
+          }
+          childSessionInfo.delete(sessionID);
+        }
+      }
+      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) {
+      if (!flags.prompt_controls || !risky(text(output.parts)))
+        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;
+      if (output.context.includes(experimentalText))
+        return;
+      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) {
+        mcpRegistry = await compileAgents(cfg, [bundledAgentsDir, globalAgentsDir, projectAgentsDir], agentSettings);
+      }
+      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 targetAgent = getTaskTarget(output.args ?? input.args ?? {});
+        if (targetAgent === "qa") {
+          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) {
+          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,
+            file: lock.filePath,
+            reason: "file_locked_by_other_session",
+            owner_sessionID: lock.ownerSessionID,
+            enforcement_layer: "plugin_hook"
+          });
+          throw new Error(`[opencode-multiagent] File lock conflict for ${lock.filePath}; active session ${lock.ownerSessionID}`);
+        }
+      }
+      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);
+        fileLocks.acquire(input.sessionID, input.args.filePath);
+      }
+      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
+        });
+      }
+      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)
+  };
+};
+
+// 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
+};