opencode-agenthub 0.1.0

package/dist/composer/compose.js

@@ -0,0 +1,824 @@
+import { existsSync } from "node:fs";
+import {
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  symlink,
+  writeFile
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  normalizeModelSelection,
+  pickModelSelection
+} from "./model-utils.js";
+import {
+  loadNativeOpenCodeConfig,
+  readAgentHubSettings,
+  readNativePluginEntries,
+  readWorkflowInjectionConfig
+} from "./settings.js";
+import {
+  generateRunCmd,
+  generateRunScript,
+  resolveHomeConfigRoot,
+  symlinkType
+} from "./platform.js";
+const isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const deepMergeRecords = (base, override) => {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const existing = result[key];
+    result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMergeRecords(existing, value) : value;
+  }
+  return result;
+};
+const activeRuntimeDirName = "current";
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const repoSrcRoot = path.resolve(currentDir, "..");
+const repoRoot = path.resolve(repoSrcRoot, "..");
+const builtInLibraryRoot = path.join(currentDir, "library");
+const templateRepoRoot = "${REPO_ROOT}";
+const templateRepoSrcRoot = "${REPO_SRC_ROOT}";
+const templateLibraryRoot = "${LIBRARY_ROOT}";
+const OPENCODE_BUILTIN_AGENTS = ["general", "explore", "plan", "build"];
+const unique = (values) => [...new Set(values)];
+const resolveNativeAgentPolicy = (profile) => {
+  if (profile.nativeAgentPolicy) return profile.nativeAgentPolicy;
+  if (profile.inheritNativeAgents === false) return "override";
+  return "inherit";
+};
+const isDisabledAgentEntry = (value) => isPlainObject(value) && value.disable === true;
+const validateProfileDefaultAgent = ({
+  profile,
+  bundles,
+  agentConfig,
+  nativeAgentPolicy
+}) => {
+  if (nativeAgentPolicy === "team-only" && !profile.defaultAgent?.trim()) {
+    throw new Error(
+      `Team-only profile '${profile.name}' must set defaultAgent explicitly so the runtime has a stable primary agent when built-ins are disabled.`
+    );
+  }
+  if (!profile.defaultAgent) return void 0;
+  const configuredDefaultAgent = profile.defaultAgent.trim();
+  if (!configuredDefaultAgent) return void 0;
+  const bundleMatch = bundles.find((bundle) => bundle.name === configuredDefaultAgent);
+  if (bundleMatch && bundleMatch.agent.name !== configuredDefaultAgent) {
+    const availableAgents2 = Object.entries(agentConfig).filter(([, entry]) => !isDisabledAgentEntry(entry)).map(([name]) => name).sort();
+    throw new Error(
+      `Profile '${profile.name}' sets defaultAgent '${configuredDefaultAgent}', but that matches bundle '${bundleMatch.name}' instead of its bundle agent.name '${bundleMatch.agent.name}'. Set defaultAgent to '${bundleMatch.agent.name}'. Available agent names: ${availableAgents2.join(", ") || "(none)"}.`
+    );
+  }
+  const matchedAgent = agentConfig[configuredDefaultAgent];
+  if (matchedAgent && !isDisabledAgentEntry(matchedAgent)) {
+    return configuredDefaultAgent;
+  }
+  const bundleHint = bundleMatch ? ` Bundle '${bundleMatch.name}' uses bundle agent.name '${bundleMatch.agent.name}'. Set defaultAgent to that value instead.` : "";
+  const disabledHint = matchedAgent && isDisabledAgentEntry(matchedAgent) ? ` Agent '${configuredDefaultAgent}' exists in the composed runtime but is disabled under nativeAgentPolicy '${nativeAgentPolicy}'.` : "";
+  const availableAgents = Object.entries(agentConfig).filter(([, entry]) => !isDisabledAgentEntry(entry)).map(([name]) => name).sort();
+  throw new Error(
+    `Profile '${profile.name}' sets defaultAgent '${configuredDefaultAgent}', but no enabled generated agent matches that name.${bundleHint}${disabledHint} Available agent names: ${availableAgents.join(", ") || "(none)"}.`
+  );
+};
+const workflowInjectionMatchesBundles = (workflowInjection, bundleNames = []) => {
+  if (!workflowInjection?.enabled) return false;
+  if (!workflowInjection.bundles || workflowInjection.bundles.length === 0) {
+    return true;
+  }
+  return workflowInjection.bundles.some((bundleName) => bundleNames.includes(bundleName));
+};
+const resolveRuntimeInjectionConfig = ({
+  planDetection,
+  workflowInjection,
+  bundleNames = []
+}) => {
+  if (workflowInjection) {
+    const matchedWorkflowInjection = workflowInjectionMatchesBundles(workflowInjection, bundleNames) ? workflowInjection : void 0;
+    return {
+      ...matchedWorkflowInjection ? { workflowInjection: matchedWorkflowInjection } : {},
+      ...matchedWorkflowInjection && planDetection?.enabled ? { planDetection } : {}
+    };
+  }
+  return {
+    planDetection: planDetection?.enabled ? planDetection : void 0
+  };
+};
+const readJson = async (filePath) => {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+};
+const ensureDir = async (dirPath) => {
+  await mkdir(dirPath, { recursive: true });
+};
+const pathExists = async (targetPath) => {
+  try {
+    await lstat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const getAgentHubHome = () => process.env.OPENCODE_AGENTHUB_HOME || resolveHomeConfigRoot(os.homedir(), "opencode-agenthub");
+const resolveLibraryRoot = (homeRoot = getAgentHubHome()) => {
+  const agentHubHome = homeRoot;
+  if (existsSync(path.join(agentHubHome, "profiles")) && existsSync(path.join(agentHubHome, "bundles"))) {
+    return agentHubHome;
+  }
+  return builtInLibraryRoot;
+};
+const resolveCandidateLibraryRoots = (libraryRoot) => unique([libraryRoot, builtInLibraryRoot]);
+const firstExistingPath = async (paths) => {
+  for (const candidate of paths) {
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+const loadProfile = async (libraryRoot, profileName) => {
+  for (const root of resolveCandidateLibraryRoots(libraryRoot)) {
+    const profilePath = path.join(root, "profiles", `${profileName}.json`);
+    const profile = await readJsonIfExists(profilePath);
+    if (profile) {
+      return profile;
+    }
+  }
+  throw new Error(
+    `Profile '${profileName}' not found in ${path.join(libraryRoot, "profiles")} or ${path.join(builtInLibraryRoot, "profiles")}. Create that profile or re-run bootstrap with a starter kit.`
+  );
+};
+const loadBundle = async (libraryRoot, bundleName) => {
+  let raw = null;
+  for (const root of resolveCandidateLibraryRoots(libraryRoot)) {
+    raw = await readJsonIfExists(
+      path.join(root, "bundles", `${bundleName}.json`)
+    );
+    if (raw) break;
+  }
+  if (!raw) {
+    throw new Error(
+      `Bundle '${bundleName}' not found in ${path.join(libraryRoot, "bundles")} or ${path.join(builtInLibraryRoot, "bundles")}.`
+    );
+  }
+  const soul = raw.soul || raw.prompt;
+  if (!soul) {
+    throw new Error(`Bundle '${bundleName}' is missing required 'soul' field.`);
+  }
+  return {
+    ...raw,
+    soul
+  };
+};
+const readJsonIfExists = async (filePath) => {
+  try {
+    return await readJson(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+const replaceTemplateTokens = (value, libraryRoot) => value.replaceAll(templateRepoRoot, repoRoot).replaceAll(templateRepoSrcRoot, repoSrcRoot).replaceAll(templateLibraryRoot, libraryRoot);
+const resolveTemplateValue = (value, libraryRoot) => {
+  if (typeof value === "string") {
+    return replaceTemplateTokens(value, libraryRoot);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveTemplateValue(item, libraryRoot));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(
+        ([key, entryValue]) => [
+          key,
+          resolveTemplateValue(entryValue, libraryRoot)
+        ]
+      )
+    );
+  }
+  return value;
+};
+const loadMcpEntry = async (libraryRoot, mcpName) => {
+  const candidateRoots = unique([libraryRoot, builtInLibraryRoot]);
+  for (const root of candidateRoots) {
+    const entry = await readJsonIfExists(
+      path.join(root, "mcp", `${mcpName}.json`)
+    );
+    if (entry) {
+      return resolveTemplateValue(entry, root);
+    }
+  }
+  throw new Error(
+    `Unknown MCP entry '${mcpName}'. Add ${mcpName}.json under ${path.join(libraryRoot, "mcp")} or ${path.join(builtInLibraryRoot, "mcp")}.`
+  );
+};
+const loadAllMcpEntries = async (libraryRoot) => {
+  const mcpNames = unique(
+    (await Promise.all(
+      resolveCandidateLibraryRoots(libraryRoot).map(async (root) => {
+        const mcpDir = path.join(root, "mcp");
+        if (!await pathExists(mcpDir)) return [];
+        const entries = await readdir(mcpDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isFile() && path.extname(entry.name) === ".json").map((entry) => path.basename(entry.name, ".json"));
+      })
+    )).flat()
+  ).sort();
+  if (mcpNames.length === 0) return {};
+  return Object.fromEntries(
+    await Promise.all(
+      mcpNames.map(async (name) => [
+        name,
+        await loadMcpEntry(libraryRoot, name)
+      ])
+    )
+  );
+};
+const resetGeneratedDir = async (dirPath) => {
+  await rm(dirPath, { recursive: true, force: true });
+  await ensureDir(dirPath);
+};
+const listAgentHubSoulNames = async (libraryRoot) => {
+  return unique(
+    (await Promise.all(
+      resolveCandidateLibraryRoots(libraryRoot).map(async (root) => {
+        const soulsRoot = path.join(root, "souls");
+        if (!await pathExists(soulsRoot)) return [];
+        const entries = await readdir(soulsRoot, { withFileTypes: true });
+        return entries.filter((entry) => entry.isFile() && path.extname(entry.name) === ".md").map((entry) => path.basename(entry.name, ".md"));
+      })
+    )).flat()
+  ).sort();
+};
+const listAgentHubSkillNames = async (libraryRoot) => {
+  return unique(
+    (await Promise.all(
+      resolveCandidateLibraryRoots(libraryRoot).map(async (root) => {
+        const skillsRoot = path.join(root, "skills");
+        if (!await pathExists(skillsRoot)) return [];
+        const entries = await readdir(skillsRoot, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      })
+    )).flat()
+  ).sort();
+};
+const readWorkflowInjectionConfigWithFallback = async (libraryRoot, fallbackRoot) => {
+  for (const root of unique([libraryRoot, fallbackRoot, builtInLibraryRoot]).filter(Boolean)) {
+    const config = await readWorkflowInjectionConfig(root);
+    if (config) {
+      return config;
+    }
+  }
+  return null;
+};
+const resetWorkspaceRuntimeRoot = async (workspace, outputRoot) => {
+  const workspaceRuntimeRoot = path.join(workspace, ".opencode-agenthub");
+  if (path.resolve(path.dirname(outputRoot)) !== path.resolve(workspaceRuntimeRoot)) {
+    await ensureDir(outputRoot);
+    return;
+  }
+  await rm(workspaceRuntimeRoot, { recursive: true, force: true });
+  await ensureDir(outputRoot);
+  await writeFile(
+    path.join(workspaceRuntimeRoot, "active-runtime.json"),
+    `${JSON.stringify({ active: path.basename(outputRoot) }, null, 2)}
+`,
+    "utf-8"
+  );
+};
+const resolveSoulSource = async (libraryRoot, soulName) => {
+  const source = await firstExistingPath([
+    path.join(libraryRoot, "souls", `${soulName}.md`),
+    path.join(libraryRoot, "agents", `${soulName}.md`),
+    path.join(builtInLibraryRoot, "souls", `${soulName}.md`),
+    path.join(builtInLibraryRoot, "agents", `${soulName}.md`),
+    path.join(repoSrcRoot, "agents", `${soulName}.md`)
+  ]);
+  if (!source) {
+    throw new Error(
+      `Unknown soul '${soulName}'. Add ${soulName}.md under ${path.join(libraryRoot, "souls")} or provide a repo source file.`
+    );
+  }
+  return source;
+};
+const resolveSkillSource = async (libraryRoot, skillName) => {
+  const source = await firstExistingPath([
+    path.join(libraryRoot, "skills", skillName),
+    path.join(builtInLibraryRoot, "skills", skillName),
+    path.join(repoSrcRoot, "skills", skillName)
+  ]);
+  if (!source) {
+    throw new Error(
+      `Unknown skill '${skillName}'. Add ${skillName} under ${path.join(libraryRoot, "skills")} or provide a repo source directory.`
+    );
+  }
+  return source;
+};
+const resolveInstructionSource = async (libraryRoot, instructionName) => {
+  const source = await firstExistingPath([
+    path.join(libraryRoot, "instructions", `${instructionName}.md`),
+    path.join(builtInLibraryRoot, "instructions", `${instructionName}.md`),
+    path.join(repoSrcRoot, "instructions", `${instructionName}.md`)
+  ]);
+  if (!source) {
+    throw new Error(
+      `Unknown instruction '${instructionName}'. Add ${instructionName}.md under ${path.join(libraryRoot, "instructions")} or provide a repo source file.`
+    );
+  }
+  return source;
+};
+const mergeAgentPrompt = async (libraryRoot, bundle) => {
+  const soulSource = await resolveSoulSource(libraryRoot, bundle.soul);
+  const soulText = await readFile(soulSource, "utf-8");
+  const instructionTexts = await Promise.all(
+    (bundle.instructions || []).map(async (instructionName) => {
+      const source = await resolveInstructionSource(libraryRoot, instructionName);
+      const content = await readFile(source, "utf-8");
+      return {
+        instructionName,
+        content: content.trim()
+      };
+    })
+  );
+  const sections = [soulText.trim()];
+  for (const instruction of instructionTexts) {
+    if (!instruction.content) continue;
+    sections.push(`## Attached Instruction: ${instruction.instructionName}
+
+${instruction.content}`);
+  }
+  return `${sections.filter(Boolean).join("\n\n")}
+`;
+};
+const mountBundleArtifacts = async (outputRoot, libraryRoot, bundles) => {
+  const agentsDir = path.join(outputRoot, "agents");
+  const skillsDir = path.join(outputRoot, "skills");
+  await Promise.all([
+    resetGeneratedDir(agentsDir),
+    resetGeneratedDir(skillsDir)
+  ]);
+  const mountedAgentNames = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    if (mountedAgentNames.has(bundle.agent.name)) continue;
+    const mergedPrompt = await mergeAgentPrompt(libraryRoot, bundle);
+    await writeFile(path.join(agentsDir, `${bundle.agent.name}.md`), mergedPrompt, "utf-8");
+    mountedAgentNames.add(bundle.agent.name);
+  }
+  const skillNames = unique(bundles.flatMap((bundle) => bundle.skills));
+  for (const skillName of skillNames) {
+    const source = await resolveSkillSource(libraryRoot, skillName);
+    await symlink(source, path.join(skillsDir, skillName), symlinkType());
+  }
+};
+const toGeneratedHeader = (source) => `// GENERATED BY opencode-agenthub. DO NOT EDIT.
+// Source: ${source}
+`;
+const phaseDescription = (category) => `${category} phase worker generated from workflow bundle`;
+const loadOmoBaseline = async () => {
+  const baselinePath = path.join(
+    resolveHomeConfigRoot(os.homedir(), "opencode"),
+    "oh-my-opencode.json"
+  );
+  return readJsonIfExists(baselinePath);
+};
+const writeGeneratedRuntimeFiles = async ({
+  outputRoot,
+  source,
+  opencodeConfig,
+  lock,
+  omoConfig,
+  planDetection,
+  workflowInjection
+}) => {
+  const opencodeConfigText = `${toGeneratedHeader(source)}${JSON.stringify(opencodeConfig, null, 2)}
+`;
+  await writeFile(
+    path.join(outputRoot, "opencode.jsonc"),
+    opencodeConfigText,
+    "utf-8"
+  );
+  if (omoConfig && Object.keys(omoConfig).length > 0) {
+    const omoConfigText = `${toGeneratedHeader(source)}${JSON.stringify(omoConfig, null, 2)}
+`;
+    await writeFile(
+      path.join(outputRoot, "oh-my-opencode.json"),
+      omoConfigText,
+      "utf-8"
+    );
+  }
+  const xdgConfigText = `${toGeneratedHeader(source)}${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    plugin: Array.isArray(opencodeConfig.plugin) ? opencodeConfig.plugin : []
+  }, null, 2)}
+`;
+  await writeFile(
+    path.join(outputRoot, "xdg", "opencode", "opencode.json"),
+    xdgConfigText,
+    "utf-8"
+  );
+  await writeFile(
+    path.join(outputRoot, "agenthub-lock.json"),
+    `${toGeneratedHeader(source)}${JSON.stringify(lock, null, 2)}
+`,
+    "utf-8"
+  );
+  if (lock.runtimeInfo) {
+    const runtimeConfig = {
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      agents: lock.runtimeInfo,
+      ...planDetection?.enabled ? { planDetection } : {},
+      ...workflowInjection?.enabled ? { workflowInjection } : {}
+    };
+    await writeFile(
+      path.join(outputRoot, "agenthub-runtime.json"),
+      `${toGeneratedHeader(source)}${JSON.stringify(runtimeConfig, null, 2)}
+`,
+      "utf-8"
+    );
+  }
+  await writeFile(path.join(outputRoot, "run.sh"), generateRunScript(), "utf-8");
+  await writeFile(path.join(outputRoot, "run.cmd"), generateRunCmd(), "utf-8");
+};
+const resolveGuard = (guardName, guardRegistry, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(guardName)) {
+    const chain = Array.from(visited).concat(guardName);
+    const error = new Error(
+      `Circular guard dependency detected: ${chain.join(" -> ")}`
+    );
+    error.name = "GuardResolutionError";
+    error.guardName = guardName;
+    error.chain = chain;
+    throw error;
+  }
+  const guardDef = guardRegistry[guardName];
+  if (!guardDef) {
+    console.warn(`\u26A0\uFE0F  Warning: Guard '${guardName}' not found in registry. Skipping.`);
+    return { permission: {}, blockedTools: [] };
+  }
+  const newVisited = new Set(visited);
+  newVisited.add(guardName);
+  const parentGuards = [];
+  if (guardDef.extends && guardDef.extends.length > 0) {
+    for (const parentName of guardDef.extends) {
+      parentGuards.push(resolveGuard(parentName, guardRegistry, newVisited));
+    }
+  }
+  const mergedPermission = {};
+  const mergedBlockedTools = [];
+  for (const parent of parentGuards) {
+    Object.assign(mergedPermission, parent.permission);
+    mergedBlockedTools.push(...parent.blockedTools);
+  }
+  if (guardDef.permission) {
+    Object.assign(mergedPermission, guardDef.permission);
+  }
+  if (guardDef.blockedTools) {
+    mergedBlockedTools.push(...guardDef.blockedTools);
+  }
+  return {
+    permission: mergedPermission,
+    blockedTools: unique(mergedBlockedTools)
+  };
+};
+const resolveGuards = (guardNames, guardRegistry) => {
+  if (!guardNames || guardNames.length === 0) {
+    return { permission: {}, blockedTools: [] };
+  }
+  const resolvedGuards = guardNames.map(
+    (name) => resolveGuard(name, guardRegistry)
+  );
+  const mergedPermission = {};
+  const mergedBlockedTools = [];
+  for (const resolved of resolvedGuards) {
+    Object.assign(mergedPermission, resolved.permission);
+    mergedBlockedTools.push(...resolved.blockedTools);
+  }
+  return {
+    permission: mergedPermission,
+    blockedTools: unique(mergedBlockedTools)
+  };
+};
+const composeWorkspace = async (workspace, profileName, configRoot, options = {}) => {
+  const libraryRoot = resolveLibraryRoot(options.homeRoot);
+  const settingsRoot = options.settingsRoot || libraryRoot;
+  const profile = await loadProfile(libraryRoot, profileName);
+  const bundles = await Promise.all(
+    profile.bundles.map((bundleName) => loadBundle(libraryRoot, bundleName))
+  );
+  const outputRoot = configRoot || path.join(workspace, ".opencode-agenthub", activeRuntimeDirName);
+  await resetWorkspaceRuntimeRoot(workspace, outputRoot);
+  await ensureDir(path.join(outputRoot, "xdg", "opencode"));
+  await mountBundleArtifacts(outputRoot, libraryRoot, bundles);
+  const allMcpNames = unique(bundles.flatMap((bundle) => bundle.mcp || []));
+  const mcpEntries = Object.fromEntries(
+    await Promise.all(
+      allMcpNames.map(async (name) => [
+        name,
+        await loadMcpEntry(libraryRoot, name)
+      ])
+    )
+  );
+  const settings = await readAgentHubSettings(libraryRoot) || (settingsRoot !== libraryRoot ? await readAgentHubSettings(settingsRoot) : null);
+  const workflowInjectionConfig = await readWorkflowInjectionConfigWithFallback(
+    libraryRoot,
+    settingsRoot
+  );
+  const runtimeInjectionConfig = resolveRuntimeInjectionConfig({
+    planDetection: settings?.planDetection,
+    workflowInjection: workflowInjectionConfig,
+    bundleNames: bundles.map((bundle) => bundle.name)
+  });
+  const agentConfig = {};
+  const omoCategories = {};
+  const runtimeInfo = {};
+  const guardRegistry = settings?.guards || {};
+  const hasOmoBundle = bundles.some((b) => b.runtime === "omo");
+  const nativeBundles = bundles.filter((b) => b.runtime === "native" || !b.runtime);
+  if (hasOmoBundle && nativeBundles.length > 0) {
+    for (const bundle of nativeBundles) {
+      if (!bundle.guards?.includes("no_omo")) {
+        bundle.guards = [...bundle.guards || [], "no_omo"];
+      }
+    }
+  }
+  for (const bundle of bundles) {
+    const bundleGuards = bundle.guards || [];
+    const settingsGuards = settings?.agents?.[bundle.agent.name]?.guards || [];
+    const allGuards = unique([...bundleGuards, ...settingsGuards]);
+    const resolvedGuard = resolveGuards(allGuards, guardRegistry);
+    const settingsPermission = settings?.agents?.[bundle.agent.name]?.permission;
+    const permission = {
+      ...bundle.agent.permission || {},
+      ...resolvedGuard.permission,
+      // Apply resolved guard permissions
+      ...settingsPermission || {}
+      // Settings override everything
+    };
+    const blockedTools = [...resolvedGuard.blockedTools];
+    const finalSkills = unique(bundle.skills || []);
+    if (bundle.runtime === "omo" && bundle.categories) {
+      permission.task = { "*": "deny" };
+      for (const category of Object.keys(bundle.categories)) {
+        permission.task[category] = "allow";
+        omoCategories[category] = { model: bundle.categories[category] };
+        agentConfig[category] = {
+          mode: "subagent",
+          hidden: true,
+          description: phaseDescription(category)
+        };
+      }
+      permission.question = "allow";
+    }
+    runtimeInfo[bundle.agent.name] = {
+      runtime: bundle.runtime,
+      blockedTools,
+      guards: allGuards,
+      skills: finalSkills
+    };
+    const resolvedModel = pickModelSelection(
+      normalizeModelSelection(
+        settings?.agents?.[bundle.agent.name]?.model,
+        settings?.agents?.[bundle.agent.name]?.variant
+      ),
+      normalizeModelSelection(bundle.agent.model, bundle.agent.variant),
+      normalizeModelSelection(settings?.opencode?.model)
+    );
+    agentConfig[bundle.agent.name] = {
+      mode: bundle.agent.mode,
+      hidden: bundle.agent.hidden,
+      ...resolvedModel.model ? { model: resolvedModel.model } : {},
+      ...resolvedModel.variant ? { variant: resolvedModel.variant } : {},
+      ...typeof bundle.agent.steps === "number" ? { steps: bundle.agent.steps } : {},
+      description: bundle.agent.description,
+      ...finalSkills.length > 0 ? { skills: finalSkills } : {},
+      ...Object.keys(permission).length > 0 ? { permission } : {}
+    };
+  }
+  const nativeConfig = await loadNativeOpenCodeConfig();
+  const nativePluginEntries = await readNativePluginEntries();
+  const nativeAgents = nativeConfig?.agent || {};
+  const nativeAgentPolicy = resolveNativeAgentPolicy(profile);
+  if (nativeAgentPolicy === "inherit") {
+    for (const [agentName, nativeAgent] of Object.entries(nativeAgents)) {
+      if (!nativeAgent || typeof nativeAgent !== "object") continue;
+      if (agentConfig[agentName]) continue;
+      const settingsAgent = settings?.agents?.[agentName];
+      const resolvedModel = pickModelSelection(
+        normalizeModelSelection(settingsAgent?.model, settingsAgent?.variant),
+        normalizeModelSelection(
+          typeof nativeAgent.model === "string" ? nativeAgent.model : void 0,
+          typeof nativeAgent.variant === "string" ? nativeAgent.variant : void 0
+        )
+      );
+      const nativePermission = nativeAgent.permission && typeof nativeAgent.permission === "object" ? nativeAgent.permission : void 0;
+      const mergedPermission = deepMergeRecords(
+        nativePermission || {},
+        settingsAgent?.permission || {}
+      );
+      agentConfig[agentName] = {
+        ...nativeAgent,
+        ...resolvedModel.model ? { model: resolvedModel.model } : {},
+        ...resolvedModel.variant ? { variant: resolvedModel.variant } : {},
+        ...settingsAgent?.prompt ? { prompt: settingsAgent.prompt } : {},
+        ...Object.keys(mergedPermission).length > 0 ? { permission: mergedPermission } : {}
+      };
+    }
+  }
+  if (nativeAgentPolicy === "team-only") {
+    for (const builtInName of OPENCODE_BUILTIN_AGENTS) {
+      if (!agentConfig[builtInName]) {
+        agentConfig[builtInName] = { disable: true };
+      }
+    }
+  }
+  const resolvedDefaultAgent = validateProfileDefaultAgent({
+    profile,
+    bundles,
+    agentConfig,
+    nativeAgentPolicy
+  });
+  const omoBaseline = Object.keys(omoCategories).length > 0 ? await loadOmoBaseline() : null;
+  const omoConfig = Object.keys(omoCategories).length > 0 ? {
+    ...omoBaseline || {},
+    categories: {
+      ...omoBaseline?.categories || {},
+      ...omoCategories
+    }
+  } : void 0;
+  const resolvedGlobalModel = normalizeModelSelection(settings?.opencode?.model);
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    ...settings?.opencode?.provider ? { provider: settings.opencode.provider } : {},
+    ...resolvedGlobalModel.model ? { model: resolvedGlobalModel.model } : {},
+    ...settings?.opencode?.small_model ? { small_model: settings.opencode.small_model } : {},
+    plugin: unique([...profile.plugins, ...nativePluginEntries]),
+    ...Object.keys(mcpEntries).length > 0 ? { mcp: mcpEntries } : {},
+    ...resolvedDefaultAgent ? { default_agent: resolvedDefaultAgent } : {},
+    agent: agentConfig
+  };
+  const lock = {
+    profile: profile.name,
+    nativeAgentPolicy,
+    libraryRoot,
+    ...settingsRoot !== libraryRoot ? { settingsRoot } : {},
+    workspace,
+    configRoot: outputRoot,
+    bundles: bundles.map((bundle) => ({
+      name: bundle.name,
+      runtime: bundle.runtime,
+      soul: bundle.soul,
+      instructions: bundle.instructions || [],
+      skills: bundle.skills,
+      mcp: bundle.mcp || [],
+      guards: bundle.guards || []
+    })),
+    runtimeInfo
+    // Add runtime info for plugin
+  };
+  await writeGeneratedRuntimeFiles({
+    outputRoot,
+    source: `profile:${profile.name}`,
+    opencodeConfig,
+    lock,
+    omoConfig,
+    planDetection: runtimeInjectionConfig.planDetection,
+    workflowInjection: runtimeInjectionConfig.workflowInjection
+  });
+  return { workspace, configRoot: outputRoot, profile, bundles };
+};
+const composeToolInjection = async (workspace, configRoot, options = {}) => {
+  const libraryRoot = resolveLibraryRoot(options.homeRoot);
+  const settingsRoot = options.settingsRoot || libraryRoot;
+  const outputRoot = configRoot || path.join(workspace, ".opencode-agenthub", activeRuntimeDirName);
+  await resetWorkspaceRuntimeRoot(workspace, outputRoot);
+  await ensureDir(path.join(outputRoot, "xdg", "opencode"));
+  await resetGeneratedDir(path.join(outputRoot, "agents"));
+  await resetGeneratedDir(path.join(outputRoot, "skills"));
+  const mcpEntries = await loadAllMcpEntries(libraryRoot);
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    ...Object.keys(mcpEntries).length > 0 ? { mcp: mcpEntries } : {}
+  };
+  const lock = {
+    mode: "tool-injection",
+    libraryRoot,
+    workspace,
+    configRoot: outputRoot,
+    mcp: Object.keys(mcpEntries)
+  };
+  const workflowInjectionConfig = await readWorkflowInjectionConfigWithFallback(
+    libraryRoot,
+    settingsRoot
+  );
+  await writeGeneratedRuntimeFiles({
+    outputRoot,
+    source: "mode:tool-injection",
+    opencodeConfig,
+    lock,
+    workflowInjection: workflowInjectionMatchesBundles(workflowInjectionConfig) ? workflowInjectionConfig : void 0
+  });
+  return {
+    workspace,
+    configRoot: outputRoot,
+    mcpNames: Object.keys(mcpEntries)
+  };
+};
+const composeCustomizedAgent = async (workspace, configRoot, options = {}) => {
+  const libraryRoot = resolveLibraryRoot(options.homeRoot);
+  const settingsRoot = options.settingsRoot || libraryRoot;
+  const outputRoot = configRoot || path.join(workspace, ".opencode-agenthub", activeRuntimeDirName);
+  const souls = await listAgentHubSoulNames(libraryRoot);
+  if (souls.length === 0) {
+    throw new Error(
+      `customized-agent mode requires at least one soul in ${path.join(libraryRoot, "souls")}`
+    );
+  }
+  const selectedSoul = souls[0];
+  const skills = await listAgentHubSkillNames(libraryRoot);
+  const mcpEntries = await loadAllMcpEntries(libraryRoot);
+  const mcpNames = Object.keys(mcpEntries).sort();
+  const agentName = selectedSoul;
+  await resetWorkspaceRuntimeRoot(workspace, outputRoot);
+  await ensureDir(path.join(outputRoot, "xdg", "opencode"));
+  await mountBundleArtifacts(outputRoot, libraryRoot, [
+    {
+      name: "customized-agent",
+      runtime: "native",
+      soul: selectedSoul,
+      instructions: [],
+      skills,
+      mcp: mcpNames,
+      guards: ["no_task"],
+      agent: {
+        name: agentName,
+        mode: "primary",
+        hidden: false,
+        model: "github-copilot/claude-haiku-4.5",
+        description: "Auto-generated native agent from imported Agent Hub assets"
+      }
+    }
+  ]);
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    plugin: ["opencode-agenthub"],
+    ...mcpNames.length > 0 ? { mcp: mcpEntries } : {},
+    agent: {
+      [agentName]: {
+        mode: "primary",
+        hidden: false,
+        model: "github-copilot/claude-haiku-4.5",
+        description: "Auto-generated native agent from imported Agent Hub assets",
+        permission: {
+          task: { "*": "deny" }
+        }
+      }
+    }
+  };
+  const lock = {
+    mode: "customized-agent",
+    libraryRoot,
+    workspace,
+    configRoot: outputRoot,
+    soul: selectedSoul,
+    skills,
+    mcp: mcpNames
+  };
+  const workflowInjectionConfig = await readWorkflowInjectionConfigWithFallback(
+    libraryRoot,
+    settingsRoot
+  );
+  await writeGeneratedRuntimeFiles({
+    outputRoot,
+    source: "mode:customized-agent",
+    opencodeConfig,
+    lock,
+    workflowInjection: workflowInjectionMatchesBundles(workflowInjectionConfig) ? workflowInjectionConfig : void 0
+  });
+  return {
+    workspace,
+    configRoot: outputRoot,
+    soul: selectedSoul,
+    skills,
+    mcpNames
+  };
+};
+const getDefaultConfigRoot = (workspace, _profileName) => path.join(workspace, ".opencode-agenthub", activeRuntimeDirName);
+const getWorkspaceRuntimeRoot = (workspace) => path.join(workspace, ".opencode-agenthub", activeRuntimeDirName);
+const getAgentHubPaths = () => ({
+  repoRoot,
+  repoSrcRoot,
+  builtInLibraryRoot,
+  agentHubHome: getAgentHubHome()
+});
+export {
+  composeCustomizedAgent,
+  composeToolInjection,
+  composeWorkspace,
+  getAgentHubPaths,
+  getDefaultConfigRoot,
+  getWorkspaceRuntimeRoot
+};