opencode-agenthub 0.1.0

package/dist/composer/package-manager.js

@@ -0,0 +1,75 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { spawnOptions } from "./platform.js";
+const execFile = promisify(execFileCallback);
+const pathExists = async (target) => {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const commandAvailable = async (command) => {
+  try {
+    await execFile(command, ["--version"], spawnOptions());
+    return true;
+  } catch {
+    return false;
+  }
+};
+const detectPackageManagerForRoot = async (targetRoot) => {
+  const packageJsonPath = path.join(targetRoot, "package.json");
+  if (await pathExists(packageJsonPath)) {
+    const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    const packageManager = pkg.packageManager?.split("@")[0];
+    if (packageManager) {
+      if (packageManager === "npm" || packageManager === "bun") {
+        if (await commandAvailable(packageManager)) return packageManager;
+        throw new Error(
+          `Package manager '${packageManager}' is declared in ${packageJsonPath} but is not available on PATH.`
+        );
+      }
+      throw new Error(
+        `Unsupported package manager '${packageManager}' declared in ${packageJsonPath}. Supported package managers: npm, bun.`
+      );
+    }
+  }
+  if (await pathExists(path.join(targetRoot, "pnpm-lock.yaml"))) {
+    throw new Error(
+      `Detected pnpm-lock.yaml in ${targetRoot}, but pnpm is not supported for MCP dependency installation.`
+    );
+  }
+  if (await pathExists(path.join(targetRoot, "yarn.lock"))) {
+    throw new Error(
+      `Detected yarn.lock in ${targetRoot}, but yarn is not supported for MCP dependency installation.`
+    );
+  }
+  if (await pathExists(path.join(targetRoot, "bun.lock"))) {
+    if (await commandAvailable("bun")) return "bun";
+    throw new Error(`Detected bun.lock in ${targetRoot} but 'bun' is not available on PATH.`);
+  }
+  if (await pathExists(path.join(targetRoot, "package-lock.json"))) {
+    if (await commandAvailable("npm")) return "npm";
+    throw new Error(`Detected package-lock.json in ${targetRoot} but 'npm' is not available on PATH.`);
+  }
+  if (await commandAvailable("npm")) return "npm";
+  throw new Error(
+    `No supported package manager found for ${targetRoot}. Tried packageManager field, lockfiles, and npm fallback.`
+  );
+};
+const installPackageDependencies = async (targetRoot) => {
+  const packageManager = await detectPackageManagerForRoot(targetRoot);
+  if (packageManager === "bun") {
+    await execFile("bun", ["install"], { cwd: targetRoot, ...spawnOptions() });
+    return packageManager;
+  }
+  await execFile("npm", ["install"], { cwd: targetRoot, ...spawnOptions() });
+  return packageManager;
+};
+export {
+  detectPackageManagerForRoot,
+  installPackageDependencies
+};

package/dist/composer/package-version.js

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const readPackageVersion = () => {
+  try {
+    const pkgPath = path.join(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "..",
+      "package.json"
+    );
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg.version) return pkg.version;
+  } catch {
+  }
+  return process.env.npm_package_version ?? "0.0.0";
+};
+export {
+  readPackageVersion
+};

package/dist/composer/platform.js

@@ -0,0 +1,48 @@
+const detectWindows = () => process.platform === "win32";
+const isWindows = (win) => win ?? detectWindows();
+const symlinkType = (win) => isWindows(win) ? "junction" : "dir";
+const shouldChmod = (win) => !isWindows(win);
+const shouldOfferEnvrc = (win) => !isWindows(win);
+const resolvePythonCommand = (win) => isWindows(win) ? "python" : "python3";
+const spawnOptions = (win) => isWindows(win) ? { shell: true } : {};
+const generateRunScript = () => `#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+export XDG_CONFIG_HOME="$SCRIPT_DIR/xdg"
+export OPENCODE_DISABLE_PROJECT_CONFIG=true
+export OPENCODE_CONFIG_DIR="$SCRIPT_DIR"
+
+exec opencode "$@"
+`;
+const generateRunCmd = () => `@echo off
+set "SCRIPT_DIR=%~dp0"
+set "XDG_CONFIG_HOME=%SCRIPT_DIR%xdg"
+set "OPENCODE_DISABLE_PROJECT_CONFIG=true"
+set "OPENCODE_CONFIG_DIR=%SCRIPT_DIR%"
+
+opencode %*
+`;
+const windowsStartupNotice = (win = detectWindows()) => {
+  if (!isWindows(win)) return null;
+  return [
+    "[agenthub] Notice: native Windows detected.",
+    "Windows users should use WSL 2 for the best experience; native Windows remains best-effort in alpha.",
+    "Install WSL: https://learn.microsoft.com/en-us/windows/wsl/install"
+  ].join("\n");
+};
+const resolveHomeConfigRoot = (homeDir, appName, win) => isWindows(win) ? `${homeDir}\\.config\\${appName}` : `${homeDir}/.config/${appName}`;
+const displayHomeConfigPath = (appName, subpaths = [], win) => isWindows(win) ? ["%USERPROFILE%", ".config", appName, ...subpaths].join("\\") : ["~", ".config", appName, ...subpaths].join("/");
+export {
+  displayHomeConfigPath,
+  generateRunCmd,
+  generateRunScript,
+  isWindows,
+  resolveHomeConfigRoot,
+  resolvePythonCommand,
+  shouldChmod,
+  shouldOfferEnvrc,
+  spawnOptions,
+  symlinkType,
+  windowsStartupNotice
+};

package/dist/composer/query.js

@@ -0,0 +1,133 @@
+import { access, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const libraryRoot = path.join(currentDir, "library");
+const pathExists = async (p) => {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const readJsonIfExists = async (filePath) => {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+};
+const listSouls = async (targetRoot) => {
+  const dir = path.join(targetRoot, "souls");
+  if (!await pathExists(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, "")).sort();
+};
+const listSkills = async (targetRoot) => {
+  const dir = path.join(targetRoot, "skills");
+  if (!await pathExists(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+};
+const listBundles = async (targetRoot) => {
+  const dir = path.join(targetRoot, "bundles");
+  if (!await pathExists(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name.replace(/\.json$/, "")).sort();
+};
+const listProfiles = async (targetRoot) => {
+  const dir = path.join(targetRoot, "profiles");
+  if (!await pathExists(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name.replace(/\.json$/, "")).sort();
+};
+const listInstructions = async (targetRoot) => {
+  const dir = path.join(targetRoot, "instructions");
+  if (!await pathExists(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, "")).sort();
+};
+const readLibraryNames = async (subdir, ext) => {
+  const dir = path.join(libraryRoot, subdir);
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return new Set(
+      entries.filter((e) => e.isFile() && e.name.endsWith(ext)).map((e) => e.name.slice(0, -ext.length))
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+};
+const readLibrarySkillNames = async () => {
+  return /* @__PURE__ */ new Set([
+    "hr-staffing",
+    "hr-review",
+    "hr-assembly",
+    "hr-final-check"
+  ]);
+};
+const labelSouls = async (targetRoot) => {
+  const [names, builtIns] = await Promise.all([
+    listSouls(targetRoot),
+    readLibraryNames("souls", ".md")
+  ]);
+  return names.map((name) => ({
+    name,
+    source: builtIns.has(name) ? "built-in" : "custom"
+  }));
+};
+const labelBundles = async (targetRoot) => {
+  const [names, builtIns] = await Promise.all([
+    listBundles(targetRoot),
+    readLibraryNames("bundles", ".json")
+  ]);
+  return names.map((name) => ({
+    name,
+    source: builtIns.has(name) ? "built-in" : "custom"
+  }));
+};
+const labelProfiles = async (targetRoot) => {
+  const [names, builtIns] = await Promise.all([
+    listProfiles(targetRoot),
+    readLibraryNames("profiles", ".json")
+  ]);
+  return names.map((name) => ({
+    name,
+    source: builtIns.has(name) ? "built-in" : "custom"
+  }));
+};
+const labelSkills = async (targetRoot) => {
+  const [names, builtIns] = await Promise.all([
+    listSkills(targetRoot),
+    readLibrarySkillNames()
+  ]);
+  return names.map((name) => ({
+    name,
+    source: builtIns.has(name) ? "built-in" : "custom"
+  }));
+};
+const labelInstructions = async (targetRoot) => {
+  const [names, builtIns] = await Promise.all([
+    listInstructions(targetRoot),
+    readLibraryNames("instructions", ".md")
+  ]);
+  return names.map((name) => ({
+    name,
+    source: builtIns.has(name) ? "built-in" : "custom"
+  }));
+};
+export {
+  labelBundles,
+  labelInstructions,
+  labelProfiles,
+  labelSkills,
+  labelSouls,
+  listBundles,
+  listInstructions,
+  listProfiles,
+  listSkills,
+  listSouls,
+  readJsonIfExists
+};

package/dist/composer/settings.js

@@ -0,0 +1,400 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { normalizeModelSelection, pickModelSelection } from "./model-utils.js";
+import { buildBuiltinVersionManifest } from "./builtin-assets.js";
+import { getDefaultProfilePlugins } from "./defaults.js";
+import { readPackageVersion } from "./package-version.js";
+import { resolveHomeConfigRoot } from "./platform.js";
+const hrPrimaryAgentName = "hr";
+const recommendedHrBootstrapModel = "openai/gpt-5.4-mini";
+const recommendedHrBootstrapVariant = "high";
+const hrSubagentNames = [
+  "hr-planner",
+  "hr-sourcer",
+  "hr-evaluator",
+  "hr-cto",
+  "hr-adapter",
+  "hr-verifier"
+];
+const hrAgentNames = [hrPrimaryAgentName, ...hrSubagentNames];
+const readJson = async (filePath) => {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+};
+const titleCaseMode = (modeId) => modeId.length > 0 ? `${modeId[0]?.toUpperCase() ?? ""}${modeId.slice(1)}` : modeId;
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const workflowClassificationTrigger = (label) => ({
+  type: "regex",
+  value: `(?:^|\\n)\\s*(?:#{1,6}\\s*)?(?:\\*\\*)?Classification(?:\\s*:|:)(?:\\*\\*)?\\s*(?:\\[\\s*${escapeRegex(label)}\\s*\\]|${escapeRegex(label)})(?=[\\s:;,.!?-]|$)`,
+  confidence: "high"
+});
+const workflowIDetectTriggers = (label) => [
+  {
+    type: "regex",
+    value: `(?:^|\\n)\\s*I\\s+detect\\s+(?:\\[\\s*${escapeRegex(label)}\\s*\\]|${escapeRegex(label)})(?=[\\s:;,.!?-]|$)`,
+    confidence: "medium"
+  }
+];
+const joinWorkflowLines = (...groups) => groups.flatMap((group) => group ?? []).map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+const hasRuleArray = (config) => Array.isArray(config.rules);
+const normalizeWorkflowMode = (modeId, mode, defaults) => {
+  const label = mode.label?.trim() || titleCaseMode(modeId);
+  const useIDetectFallback = defaults?.useIDetectFallback ?? true;
+  const triggers = mode.triggers && mode.triggers.length > 0 ? mode.triggers : [
+    workflowClassificationTrigger(label),
+    ...useIDetectFallback ? workflowIDetectTriggers(label) : []
+  ];
+  return {
+    id: modeId,
+    description: mode.description,
+    enabled: mode.enabled,
+    match: mode.match ?? defaults?.match ?? "any",
+    triggers,
+    reminderTemplate: joinWorkflowLines(
+      mode.reminderPrefix,
+      defaults?.reminderPrefix,
+      mode.reminder,
+      defaults?.reminderSuffix,
+      mode.reminderSuffix
+    ),
+    queueVisibleReminderTemplate: mode.queueVisibleReminderTemplate
+  };
+};
+const normalizeWorkflowInjectionConfig = (config) => {
+  if (hasRuleArray(config)) {
+    return config;
+  }
+  const entries = Object.entries(config.modes ?? {}).filter(
+    ([modeId]) => modeId.trim().length > 0
+  );
+  if (entries.length === 0) {
+    throw new Error("Workflow injection authoring config must define at least one mode.");
+  }
+  return {
+    enabled: config.enabled,
+    bundles: config.bundles,
+    debugLog: config.debugLog,
+    queueVisibleReminder: config.queueVisibleReminder,
+    queueVisibleReminderTemplate: config.queueVisibleReminderTemplate,
+    scanLineLimit: config.scanLineLimit,
+    scanCharLimit: config.scanCharLimit,
+    maxInjectionsPerSession: config.maxInjectionsPerSession,
+    rules: entries.map(
+      ([modeId, mode]) => normalizeWorkflowMode(modeId, mode, config.defaults)
+    )
+  };
+};
+const formatNativeConfigError = (filePath, error) => {
+  const reason = error instanceof Error ? error.message : String(error);
+  return [
+    `Failed to load native OpenCode config: ${filePath}`,
+    `Reason: ${reason}`,
+    "What you can do:",
+    "  1. Fix the JSON or file permissions in that config file",
+    "  2. Run with 'agenthub setup minimal' to keep setup minimal",
+    "  3. Or set OPENCODE_AGENTHUB_NATIVE_CONFIG to another valid config"
+  ].join("\n");
+};
+const settingsPathForRoot = (targetRoot) => path.join(targetRoot, "settings.json");
+const workflowInjectionPathForRoot = (targetRoot, name = "auto-mode") => path.join(targetRoot, "workflow", `${name}.json`);
+const readAgentHubSettings = async (targetRoot) => {
+  try {
+    return await readJson(settingsPathForRoot(targetRoot));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+const writeAgentHubSettings = async (targetRoot, settings) => {
+  await writeFile(
+    settingsPathForRoot(targetRoot),
+    `${JSON.stringify(settings, null, 2)}
+`,
+    "utf-8"
+  );
+};
+const readWorkflowInjectionConfig = async (targetRoot, name = "auto-mode") => {
+  try {
+    const sourceConfig = await readJson(
+      workflowInjectionPathForRoot(targetRoot, name)
+    );
+    return normalizeWorkflowInjectionConfig(sourceConfig);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+const defaultOpenCodeConfigPath = path.join(
+  resolveHomeConfigRoot(os.homedir(), "opencode"),
+  "opencode.json"
+);
+const defaultPlanDetectionSettings = () => ({
+  enabled: true,
+  queueVisibleReminder: true,
+  queueVisibleReminderTemplate: "[agenthub] Plan reminder injected for this turn."
+});
+const mergeAgentHubSettingsDefaults = (settings) => ({
+  ...settings,
+  preferences: settings.preferences ? { ...settings.preferences } : void 0,
+  meta: {
+    ...settings.meta,
+    builtinVersion: settings.meta?.builtinVersion && Object.keys(settings.meta.builtinVersion).length > 0 ? settings.meta.builtinVersion : void 0
+  },
+  planDetection: settings.planDetection ? { ...defaultPlanDetectionSettings(), ...settings.planDetection } : defaultPlanDetectionSettings()
+});
+const nativeOpenCodeConfigPath = () => process.env.OPENCODE_AGENTHUB_NATIVE_CONFIG || defaultOpenCodeConfigPath;
+const loadNativeOpenCodeConfig = async () => {
+  const filePath = nativeOpenCodeConfigPath();
+  try {
+    return await readJson(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(formatNativeConfigError(filePath, error), {
+      cause: error
+    });
+  }
+};
+const readNativePluginEntries = async () => {
+  const config = await loadNativeOpenCodeConfig();
+  return Array.isArray(config?.plugin) ? config.plugin.filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0
+  ) : [];
+};
+const loadNativeOpenCodePreferences = async () => {
+  try {
+    const config = await loadNativeOpenCodeConfig();
+    if (!config) return null;
+    const safe = {};
+    if (config.provider && typeof config.provider === "object") {
+      safe.provider = config.provider;
+    }
+    if (typeof config.model === "string" && config.model.trim()) {
+      safe.model = config.model;
+    }
+    if (typeof config.small_model === "string" && config.small_model.trim()) {
+      safe.small_model = config.small_model;
+    }
+    return Object.keys(safe).length > 0 ? safe : null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+};
+const readNativeAgentOverrides = async () => {
+  const config = await loadNativeOpenCodeConfig();
+  if (!config?.agent || typeof config.agent !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(config.agent).filter(([name, agent]) => {
+      if (!name.trim() || !agent || typeof agent !== "object") return false;
+      return typeof agent.model === "string" && agent.model.trim().length > 0 || typeof agent.variant === "string" && agent.variant.trim().length > 0 || agent.permission && typeof agent.permission === "object";
+    }).map(([name, agent]) => [
+      name,
+      {
+        ...normalizeModelSelection(
+          typeof agent.model === "string" ? agent.model : void 0,
+          typeof agent.variant === "string" ? agent.variant : void 0
+        ),
+        ...agent.permission && typeof agent.permission === "object" ? { permission: agent.permission } : {}
+      }
+    ])
+  );
+};
+const modePrimaryAgentName = (mode) => {
+  if (mode === "auto") return "auto";
+  if (mode === "hr-office") return "hr";
+  return void 0;
+};
+const readInstalledBundleModels = async (targetRoot) => {
+  const bundlesDir = path.join(targetRoot, "bundles");
+  try {
+    const entries = await readdir(bundlesDir, { withFileTypes: true });
+    const bundleFiles = entries.filter(
+      (entry) => entry.isFile() && path.extname(entry.name) === ".json"
+    );
+    const specs = await Promise.all(
+      bundleFiles.map(
+        (entry) => readJson(path.join(bundlesDir, entry.name))
+      )
+    );
+    return Object.fromEntries(
+      specs.filter(
+        (spec) => typeof spec.agent?.name === "string" && typeof spec.agent?.model === "string" && spec.agent.name.trim() && spec.agent.model.trim()
+      ).map((spec) => {
+        const agent = spec.agent;
+        if (!agent)
+          throw new Error(`Missing agent config for bundle ${spec.name}`);
+        const modelSelection = normalizeModelSelection(agent.model, agent.variant);
+        return [
+          agent.name,
+          {
+            ...modelSelection.model ? { model: modelSelection.model } : {},
+            ...modelSelection.variant ? { variant: modelSelection.variant } : {}
+          }
+        ];
+      })
+    );
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+};
+const normalizeConfiguredModel = (value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+const fallbackInstalledModel = (installedModels, nativeModel) => installedModels[hrPrimaryAgentName]?.model || installedModels.auto?.model || Object.values(installedModels)[0]?.model || nativeModel;
+const resolveHrBootstrapAgentModels = async ({
+  targetRoot,
+  selection
+}) => {
+  const imported = await loadNativeOpenCodePreferences();
+  const installedModels = await readInstalledBundleModels(targetRoot);
+  const nativeModel = normalizeModelSelection(imported?.model);
+  const fallbackModel = recommendedHrBootstrapModel || fallbackInstalledModel(installedModels, nativeModel.model);
+  if (!fallbackModel) {
+    throw new Error(`Unable to resolve an initial HR model for ${targetRoot}`);
+  }
+  const requestedStrategy = selection?.subagentStrategy || "auto";
+  const effectiveStrategy = requestedStrategy === "auto" ? "recommended" : requestedStrategy === "native" && !nativeModel ? "recommended" : requestedStrategy;
+  const explicitConsoleModel = normalizeModelSelection(selection?.consoleModel);
+  const explicitSharedModel = normalizeModelSelection(selection?.sharedSubagentModel);
+  const recommendedModel = {
+    model: recommendedHrBootstrapModel,
+    variant: recommendedHrBootstrapVariant
+  };
+  const fallbackSelection = { model: fallbackModel };
+  const sharedAgentModel = pickModelSelection(
+    explicitSharedModel,
+    explicitConsoleModel,
+    effectiveStrategy === "native" ? nativeModel : void 0,
+    recommendedModel,
+    fallbackSelection
+  );
+  const consoleModel = pickModelSelection(explicitConsoleModel, sharedAgentModel);
+  const subagentModels = Object.fromEntries(
+    hrSubagentNames.map((agentName) => [
+      agentName,
+      effectiveStrategy === "custom" || effectiveStrategy === "free" || effectiveStrategy === "recommended" ? sharedAgentModel : effectiveStrategy === "native" ? pickModelSelection(nativeModel, sharedAgentModel) : sharedAgentModel
+    ])
+  );
+  return {
+    agentModels: {
+      [hrPrimaryAgentName]: consoleModel,
+      ...subagentModels
+    },
+    strategy: effectiveStrategy
+  };
+};
+const buildInitialAgentHubSettings = async ({
+  targetRoot,
+  mode,
+  hrResolvedModels
+}) => {
+  const shouldImportNativeBasics = mode !== "minimal";
+  const shouldImportNativeAgents = mode !== "minimal";
+  const imported = shouldImportNativeBasics ? await loadNativeOpenCodePreferences() : null;
+  const installedModels = await readInstalledBundleModels(targetRoot);
+  const nativeAgentOverrides = shouldImportNativeAgents ? await readNativeAgentOverrides() : {};
+  const primaryAgentName = modePrimaryAgentName(mode);
+  const fallbackModel = primaryAgentName && installedModels[primaryAgentName]?.model || installedModels.auto?.model || Object.values(installedModels)[0]?.model;
+  const sharedModel = imported?.model || fallbackModel;
+  const agentOverrides = { ...nativeAgentOverrides };
+  if (mode === "hr-office") {
+    const resolvedHrModels = hrResolvedModels || await resolveHrBootstrapAgentModels({
+      targetRoot
+    });
+    for (const [agentName, modelSelection] of Object.entries(resolvedHrModels.agentModels)) {
+      agentOverrides[agentName] = {
+        ...agentOverrides[agentName] || {},
+        model: modelSelection.model,
+        ...modelSelection.variant ? { variant: modelSelection.variant } : {}
+      };
+    }
+  }
+  const guardDefinitions = {
+    read_only: {
+      description: "Read-only access - no file modifications",
+      permission: {
+        edit: "deny",
+        write: "deny",
+        bash: "deny"
+      }
+    },
+    no_subagent: {
+      description: "Legacy alias for no_task",
+      blockedTools: ["task"],
+      permission: {
+        task: { "*": "deny" }
+      }
+    },
+    no_task: {
+      description: "Block task tool",
+      blockedTools: ["task"],
+      permission: {
+        task: { "*": "deny" }
+      }
+    },
+    no_omo: {
+      description: "Block OMO (Oh-My-OpenCode) multi-agent calls - for native agents in OMO profiles",
+      blockedTools: ["call_omo_agent"],
+      permission: {
+        call_omo_agent: "deny"
+      }
+    }
+  };
+  const settings = {
+    ...imported?.provider || imported?.model || imported?.small_model || sharedModel ? {
+      opencode: {
+        ...imported?.provider ? { provider: imported.provider } : {},
+        ...sharedModel ? { model: sharedModel } : {},
+        ...imported?.small_model ? { small_model: imported.small_model } : {}
+      }
+    } : {},
+    agents: agentOverrides,
+    guards: guardDefinitions,
+    planDetection: defaultPlanDetectionSettings(),
+    meta: {
+      onboarding: {
+        mode,
+        ...mode === "hr-office" && hrResolvedModels ? { modelStrategy: hrResolvedModels.strategy } : {},
+        importedNativeBasics: shouldImportNativeBasics,
+        importedNativeAgents: shouldImportNativeAgents,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      builtinVersion: buildBuiltinVersionManifest(mode, readPackageVersion())
+    }
+  };
+  return settings;
+};
+export {
+  buildInitialAgentHubSettings,
+  defaultPlanDetectionSettings,
+  getDefaultProfilePlugins,
+  hrAgentNames,
+  hrPrimaryAgentName,
+  hrSubagentNames,
+  loadNativeOpenCodeConfig,
+  loadNativeOpenCodePreferences,
+  mergeAgentHubSettingsDefaults,
+  nativeOpenCodeConfigPath,
+  readAgentHubSettings,
+  readNativeAgentOverrides,
+  readNativePluginEntries,
+  readWorkflowInjectionConfig,
+  recommendedHrBootstrapModel,
+  recommendedHrBootstrapVariant,
+  resolveHrBootstrapAgentModels,
+  settingsPathForRoot,
+  workflowInjectionPathForRoot,
+  writeAgentHubSettings
+};