opencode-agenthub 0.1.0

package/dist/composer/opencode-profile.js

@@ -0,0 +1,2299 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { chmod, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+import {
+  agentHubHomeInitialized,
+  defaultAgentHubHome,
+  defaultHrHome,
+  hrHomeInitialized,
+  installAgentHubHome,
+  installHrOfficeHomeWithOptions,
+  promptHubInitAnswers,
+  syncBuiltInAgentHubAssets
+} from "./bootstrap.js";
+import {
+  getBuiltInManifestKeysForMode,
+  listBuiltInAssetNames
+} from "./builtin-assets.js";
+import {
+  composeCustomizedAgent,
+  composeToolInjection,
+  composeWorkspace,
+  getDefaultConfigRoot,
+  getWorkspaceRuntimeRoot
+} from "./compose.js";
+import { expandProfileAddSelections, listProfileAddCapabilityNames } from "./capabilities.js";
+import {
+  exportAgentHubHome,
+  importAgentHubHome
+} from "./home-transfer.js";
+import {
+  inspectRuntimeConfig,
+  resolvePluginConfigRoot,
+  summarizeRuntimeFeatureState
+} from "../plugins/runtime-config.js";
+import { readPackageVersion } from "./package-version.js";
+import {
+  mergeAgentHubSettingsDefaults,
+  hrPrimaryAgentName,
+  hrSubagentNames,
+  recommendedHrBootstrapModel,
+  recommendedHrBootstrapVariant,
+  readAgentHubSettings,
+  writeAgentHubSettings
+} from "./settings.js";
+import {
+  displayHomeConfigPath,
+  resolvePythonCommand,
+  shouldChmod,
+  shouldOfferEnvrc,
+  spawnOptions,
+  windowsStartupNotice
+} from "./platform.js";
+const cliCommand = "agenthub";
+const compatibilityCliCommand = "opencode-agenthub";
+const printHelp = () => {
+  const agentHubHomePath = displayHomeConfigPath("opencode-agenthub");
+  const hrHomePath = displayHomeConfigPath("opencode-agenthub-hr");
+  const hrSettingsPath = displayHomeConfigPath("opencode-agenthub-hr", ["settings.json"]);
+  const hrStagingPath = displayHomeConfigPath("opencode-agenthub-hr", ["staging"]);
+  process.stdout.write(`${cliCommand} \u2014 Agent Hub for opencode (requires Node \u2265 18.0.0)
+
+USAGE
+  ${cliCommand} <command> [options]
+
+ALIAS
+  ${compatibilityCliCommand} <command> [options]
+
+COMMANDS (everyday)
+  start          Start My Team (default profile > last profile > auto)
+  hr [profile]   Enter HR Office or test an HR profile in this workspace
+  promote        Promote an approved staged HR package into My Team
+
+COMMANDS (maintenance)
+  backup         Back up My Team (personal home only)
+  restore        Restore My Team from a backup bundle
+  upgrade        Preview or sync built-in managed assets
+
+COMMANDS (advanced)
+  setup          Initialize the Agent Hub home directory
+  list           List installed assets (souls, bundles, profiles, skills, more)
+  new            Create new souls, skills, bundles, profiles, and advanced assets
+  plugin         Inspect plugin-only runtime health
+  doctor         Inspect and fix Agent Hub home assets
+  compose        Create a new profile or bundle scaffold (alias for new profile/bundle)
+
+COMMANDS (compatibility aliases)
+  run            Alias for 'start'
+  hub-doctor     Alias for 'doctor'
+  hub-export     Advanced: export a chosen Agent Hub home to a portable directory
+  hub-import     Advanced: import a previously-exported Agent Hub home
+
+BUILT-IN PROFILES (for use with 'start' / 'run')
+  auto           Default coding agent (Auto + Plan + Build)
+  hr             HR console with staffing subagents
+
+EXAMPLES
+  ${cliCommand} start
+  ${cliCommand} start last
+  ${cliCommand} start set reviewer-team
+  ${cliCommand} hr
+  ${cliCommand} hr last
+  ${cliCommand} hr recruiter-team
+  ${cliCommand} promote
+  ${cliCommand} backup --output ./my-team-backup
+  ${cliCommand} restore --source ./my-team-backup
+  ${cliCommand} start auto --workspace /path/to/project
+  ${cliCommand} list
+  ${cliCommand} list bundles
+  ${cliCommand} new soul reviewer
+  ${cliCommand} new profile my-team --from auto --add hr-suite
+  ${cliCommand} upgrade
+  ${cliCommand} upgrade --force
+  ${cliCommand} plugin doctor
+  ${cliCommand} doctor --fix-all
+  ${cliCommand} hub-export --output ./agenthub-backup
+  ${cliCommand} hub-import --source ./agenthub-backup
+
+FLAGS (global)
+  --help, -h     Show this help message
+  --version, -v  Print version
+
+FLAGS (setup)
+  setup [auto|minimal]           Setup mode (default: auto)
+  --target-root <path>           Override Agent Hub home location
+  --import-souls <path>          Import existing soul/agent prompt folder
+  --import-instructions <path>   Import existing instructions folder
+  --import-skills <path>         Import existing skills folder
+  --import-mcp-servers <path>    Import existing MCP server folder
+
+FLAGS (start / run)
+  --workspace <path>   Target workspace (default: cwd)
+  --config-root <path> Override .opencode config directory
+  --assemble-only      Write config files but do not launch opencode
+  --mode <tools-only|customized-agent>
+                        Advanced: launch with a built-in bundle mode instead of a profile
+  start last           Reuse the last profile used in this workspace (fallback: auto)
+  start set <profile>  Save the default personal profile for future bare 'start'
+  -- <args>            Pass remaining args to opencode
+
+FLAGS (hr)
+  hr                   Enter the isolated HR Office (bootstraps it on first use)
+  hr <profile>         Test an HR-home profile in the current workspace
+  hr last              Reuse the last HR profile tested in this workspace
+  hr set <profile>     Unsupported (use explicit '${cliCommand} hr <profile>' each time)
+  first bootstrap      Interactive terminals can choose recommended / free / custom
+                       defaults to openai/gpt-5.4-mini when left blank
+
+FLAGS (new / compose profile)
+  --from <profile>      Seed bundles/plugins from an existing profile
+  --add <bundle|cap>    Add bundle(s) or capability shorthand (repeatable)
+  --reserved-ok         Allow names that collide with built-in asset names
+
+FLAGS (upgrade)
+  --target-root <path>  Agent Hub home to inspect/sync
+  --dry-run             Preview managed file changes (default)
+  --force               Overwrite built-in managed files
+
+FLAGS (plugin doctor)
+  --config-root <path>  Inspect a specific opencode config root
+
+FLAGS (doctor / hub-doctor)
+  --target-root <path>   Agent Hub home to inspect (default: ${agentHubHomePath})
+  --fix-all              Apply all safe automatic fixes
+  --dry-run              Preview fixes without writing
+  --agent <name>         Target a specific agent
+  --model <model>        Override the agent's model
+  --clear-model          Remove the agent's model override
+  --prompt-file <path>   Set the agent's soul/prompt from a file
+  --clear-prompt         Remove the agent's soul/prompt override
+
+FLAGS (hub-export)
+  --output <path>        Destination directory (required)
+  --source-root <path>   Agent Hub home to export (default: ${agentHubHomePath})
+
+FLAGS (hub-import)
+  --source <path>        Exported Agent Hub directory to import (required)
+  --target-root <path>   Destination Agent Hub home (default: ${agentHubHomePath})
+  --overwrite            Overwrite matching entries
+  --settings <preserve|replace>  How to handle settings (default: preserve)
+
+FLAGS (backup)
+  --output <path>        Destination directory (required; personal home only)
+
+FLAGS (restore)
+  --source <path>        Backup directory to restore from (required; personal home only)
+  --overwrite            Overwrite matching entries
+  --settings <preserve|replace>  How to handle settings (default: preserve)
+
+FLAGS (promote)
+  [package-id]           Staged package id under ${hrStagingPath}
+
+PLUGIN-ONLY MODE
+  Agent Hub ships as both a CLI and an opencode plugin. When loaded as
+  a plugin without a configured hub runtime, it runs in degraded mode:
+    - Tool blocking (blockedTools) is disabled
+    - The call_omo_agent tool is blocked as a safety fallback
+  Run '${cliCommand} setup' once to initialize the hub runtime and exit
+  degraded mode. Features that require the hub runtime: profile composition,
+  agent souls, skill injection, and plan detection.
+
+HR HOME
+  HR live state is stored separately at ${hrHomePath}
+  Override with OPENCODE_AGENTHUB_HR_HOME environment variable.
+  Use '${cliCommand} hr' to enter the HR Office. If HR is not installed yet, Agent Hub bootstraps it automatically.
+  Use '${cliCommand} hr <profile>' to test an HR-home profile or a staged profile in a workspace before promote.
+  HR model overrides live in ${hrSettingsPath}.
+
+NOTE
+	This package requires Node on PATH.
+	Windows users should use WSL 2 for the best experience; native Windows remains best-effort in alpha.
+`);
+};
+const fail = (message) => {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+};
+const formatWorkspaceAccessError = (workspace) => {
+  const quotedWorkspace = `'${workspace}'`;
+  const macHint = process.platform === "darwin" ? "\n\nOn macOS this usually means Terminal/Bun/opencode does not currently have permission to read that folder. Check Privacy & Security access for Documents/Desktop/iCloud-backed folders, then retry." : "";
+  return [
+    `Workspace ${quotedWorkspace} is not readable.`,
+    "Agent Hub can assemble the runtime, but opencode will fail to launch if it cannot scan the workspace.",
+    `Try: ls ${quotedWorkspace}`
+  ].join("\n") + macHint;
+};
+const ensureWorkspaceReadable = async (workspace) => {
+  try {
+    await readdir(workspace);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && (error.code === "EACCES" || error.code === "EPERM")) {
+      fail(formatWorkspaceAccessError(workspace));
+    }
+    throw error;
+  }
+};
+const parseSetupMode = (value) => {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "minimal" || normalized === "auto") {
+    return normalized;
+  }
+  return fail(`Invalid setup mode '${value}'. Use 'auto' or 'minimal'.`);
+};
+const normalizeRuntimeProfileName = (value) => {
+  return value;
+};
+const parseBundleName = (value) => {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "tools-only" || normalized === "customized-agent") {
+    return normalized;
+  }
+  return fail(
+    `Invalid bundle '${value}'. Use 'tools-only' or 'customized-agent'.`
+  );
+};
+const parseSettingsMode = (value) => {
+  if (!value || value === "preserve" || value === "replace")
+    return value || "preserve";
+  return fail(`Invalid settings mode '${value}'. Use 'preserve' or 'replace'.`);
+};
+const parseArgs = (argv) => {
+  let command = "run";
+  let runtimeSelection;
+  let composeSelection2;
+  let listTarget;
+  let pluginSubcommand;
+  let workspace = process.cwd();
+  let configRoot;
+  let assembleOnly = false;
+  const opencodeArgs = [];
+  const bootstrapOptions = {};
+  const profileCreateOptions = {
+    addBundles: [],
+    reservedOk: false
+  };
+  const upgradeOptions = {
+    force: false,
+    dryRun: true
+  };
+  const transferOptions = {
+    overwrite: false,
+    settingsMode: "preserve"
+  };
+  const doctorOptions = {
+    fixAll: false,
+    dryRun: false,
+    clearModel: false,
+    clearPrompt: false
+  };
+  let promotePackageId;
+  let startIntent;
+  let hrIntent;
+  let index = 0;
+  const maybeCommand = argv[0];
+  if (maybeCommand === "setup" || maybeCommand === "hr" || maybeCommand === "backup" || maybeCommand === "restore" || maybeCommand === "promote" || maybeCommand === "new" || maybeCommand === "upgrade" || maybeCommand === "plugin" || maybeCommand === "hub-export" || maybeCommand === "hub-import" || maybeCommand === "compose" || maybeCommand === "run" || maybeCommand === "start" || maybeCommand === "list" || maybeCommand === "doctor" || maybeCommand === "hub-doctor") {
+    command = maybeCommand;
+    index = 1;
+    const targetType = argv[index];
+    const targetName = argv[index + 1];
+    if (command === "hr") {
+      if (targetType === "set") {
+        fail(`'hr set <profile>' is not supported. Use '${cliCommand} hr <profile>' to test a temporary HR profile in this workspace.`);
+      }
+      if (targetType === "last") {
+        hrIntent = { kind: "compose", source: "last" };
+        index = 2;
+      } else {
+        const hrProfileArg = targetType && !targetType.startsWith("-") ? targetType : void 0;
+        if (hrProfileArg) {
+          hrIntent = {
+            kind: "compose",
+            profile: normalizeRuntimeProfileName(hrProfileArg),
+            source: "explicit"
+          };
+          runtimeSelection = {
+            kind: "profile",
+            profile: normalizeRuntimeProfileName(hrProfileArg)
+          };
+          index = 2;
+        } else {
+          hrIntent = { kind: "office" };
+          runtimeSelection = {
+            kind: "profile",
+            profile: "hr"
+          };
+        }
+      }
+    } else if (command === "promote" && targetType && !targetType.startsWith("-")) {
+      promotePackageId = targetType;
+      index = 2;
+    }
+    if ((command === "compose" || command === "new") && targetType === "profile") {
+      const name = targetName?.trim();
+      if (!name) {
+        fail(`'${command} profile' requires a profile name.`);
+      }
+      composeSelection2 = { kind: "profile", name };
+      index = 3;
+    } else if ((command === "compose" || command === "new") && targetType === "bundle") {
+      const name = targetName?.trim();
+      if (!name) {
+        fail(`'${command} bundle' requires a bundle name.`);
+      }
+      composeSelection2 = { kind: "bundle", name };
+      index = 3;
+    } else if (command === "new" && targetType === "soul") {
+      const name = targetName?.trim();
+      if (!name) fail("'new soul' requires a name.");
+      composeSelection2 = { kind: "soul", name };
+      index = 3;
+    } else if (command === "new" && targetType === "skill") {
+      const name = targetName?.trim();
+      if (!name) fail("'new skill' requires a name.");
+      composeSelection2 = { kind: "skill", name };
+      index = 3;
+    } else if (command === "new" && targetType === "instruction") {
+      const name = targetName?.trim();
+      if (!name) fail("'new instruction' requires a name.");
+      composeSelection2 = { kind: "instruction", name };
+      index = 3;
+    } else if (command === "plugin" && targetType === "doctor") {
+      pluginSubcommand = "doctor";
+      index = 2;
+    } else if (command === "setup" && targetType && !targetType.startsWith("-")) {
+      bootstrapOptions.mode = parseSetupMode(targetType);
+      index = 2;
+    } else if (command === "run" && targetType === "profile") {
+      startIntent = {
+        kind: "compose",
+        profile: normalizeRuntimeProfileName(targetName || "auto"),
+        source: "explicit"
+      };
+      runtimeSelection = {
+        kind: "profile",
+        profile: normalizeRuntimeProfileName(targetName || "auto")
+      };
+      index = 3;
+    } else if (command === "run" && targetType === "bundle") {
+      runtimeSelection = { kind: parseBundleName(targetName || "") };
+      index = 3;
+    } else if (command === "run" && targetType === "last") {
+      startIntent = { kind: "compose", source: "last" };
+      index = 2;
+    } else if (command === "run" && targetType === "set") {
+      const profile = normalizeRuntimeProfileName(targetName || "");
+      if (!profile) {
+        fail("'run set <profile>' requires a profile name.");
+      }
+      startIntent = { kind: "set-default", profile };
+      index = 3;
+    } else if (command === "run" && targetType && !targetType.startsWith("-")) {
+      startIntent = {
+        kind: "compose",
+        profile: normalizeRuntimeProfileName(targetType),
+        source: "explicit"
+      };
+      runtimeSelection = {
+        kind: "profile",
+        profile: normalizeRuntimeProfileName(targetType)
+      };
+      index = 2;
+    } else if (command === "start" && targetType === "profile") {
+      startIntent = {
+        kind: "compose",
+        profile: normalizeRuntimeProfileName(targetName || "auto"),
+        source: "explicit"
+      };
+      runtimeSelection = {
+        kind: "profile",
+        profile: normalizeRuntimeProfileName(targetName || "auto")
+      };
+      index = 3;
+    } else if (command === "start" && targetType === "bundle") {
+      runtimeSelection = { kind: parseBundleName(targetName || "") };
+      index = 3;
+    } else if (command === "start" && targetType === "last") {
+      startIntent = { kind: "compose", source: "last" };
+      index = 2;
+    } else if (command === "start" && targetType === "set") {
+      const profile = normalizeRuntimeProfileName(targetName || "");
+      if (!profile) {
+        fail("'start set <profile>' requires a profile name.");
+      }
+      startIntent = { kind: "set-default", profile };
+      index = 3;
+    } else if (command === "start" && targetType && !targetType.startsWith("-")) {
+      startIntent = {
+        kind: "compose",
+        profile: normalizeRuntimeProfileName(targetType),
+        source: "explicit"
+      };
+      runtimeSelection = {
+        kind: "profile",
+        profile: normalizeRuntimeProfileName(targetType)
+      };
+      index = 2;
+    } else if (command === "list" && targetType && !targetType.startsWith("-")) {
+      listTarget = targetType;
+      index = 2;
+    }
+  }
+  if (maybeCommand && !maybeCommand.startsWith("-") && command === "run" && maybeCommand !== "run" && index === 0) {
+    process.stderr.write(
+      `Unknown command: '${maybeCommand}'
+
+Run '${cliCommand} --help' to see available commands.
+`
+    );
+    process.exit(1);
+  }
+  for (; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    if (arg === "--version" || arg === "-v") {
+      process.stdout.write(`${readPackageVersion()}
+`);
+      process.exit(0);
+    }
+    if (arg === "--profile") {
+      runtimeSelection = {
+        kind: "profile",
+        profile: normalizeRuntimeProfileName(argv[index + 1] || "auto")
+      };
+      index += 1;
+      continue;
+    }
+    if (arg === "--mode") {
+      runtimeSelection = { kind: parseBundleName(argv[index + 1] || "") };
+      index += 1;
+      continue;
+    }
+    if (arg === "--from") {
+      profileCreateOptions.fromProfile = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--add") {
+      profileCreateOptions.addBundles.push(argv[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--reserved-ok") {
+      profileCreateOptions.reservedOk = true;
+      continue;
+    }
+    if (arg === "--workspace") {
+      workspace = path.resolve(argv[index + 1] || workspace);
+      index += 1;
+      continue;
+    }
+    if (arg === "--config-root") {
+      configRoot = path.resolve(argv[index + 1] || workspace);
+      index += 1;
+      continue;
+    }
+    if (arg === "--assemble-only") {
+      assembleOnly = true;
+      continue;
+    }
+    if (arg === "--target-root") {
+      const resolved = path.resolve(argv[index + 1] || defaultAgentHubHome());
+      bootstrapOptions.targetRoot = resolved;
+      transferOptions.targetRoot = resolved;
+      index += 1;
+      continue;
+    }
+    if (arg === "--source-root" || arg === "--source") {
+      transferOptions.sourceRoot = path.resolve(argv[index + 1] || workspace);
+      index += 1;
+      continue;
+    }
+    if (arg === "--output") {
+      transferOptions.outputRoot = path.resolve(argv[index + 1] || workspace);
+      index += 1;
+      continue;
+    }
+    if (arg === "--overwrite") {
+      transferOptions.overwrite = true;
+      continue;
+    }
+    if (arg === "--force") {
+      upgradeOptions.force = true;
+      continue;
+    }
+    if (arg === "--settings") {
+      transferOptions.settingsMode = parseSettingsMode(argv[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === "--fix-all") {
+      doctorOptions.fixAll = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      doctorOptions.dryRun = true;
+      upgradeOptions.dryRun = true;
+      continue;
+    }
+    if (arg === "--agent") {
+      doctorOptions.agent = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--model") {
+      doctorOptions.model = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--clear-model") {
+      doctorOptions.clearModel = true;
+      continue;
+    }
+    if (arg === "--prompt-file") {
+      doctorOptions.promptFile = path.resolve(argv[index + 1] || workspace);
+      index += 1;
+      continue;
+    }
+    if (arg === "--clear-prompt") {
+      doctorOptions.clearPrompt = true;
+      continue;
+    }
+    if (arg === "--import-souls") {
+      bootstrapOptions.importSoulsPath = path.resolve(
+        argv[index + 1] || workspace
+      );
+      index += 1;
+      continue;
+    }
+    if (arg === "--import-instructions") {
+      bootstrapOptions.importInstructionsPath = path.resolve(
+        argv[index + 1] || workspace
+      );
+      index += 1;
+      continue;
+    }
+    if (arg === "--import-skills") {
+      bootstrapOptions.importSkillsPath = path.resolve(
+        argv[index + 1] || workspace
+      );
+      index += 1;
+      continue;
+    }
+    if (arg === "--import-mcp-servers") {
+      bootstrapOptions.importMcpServersPath = path.resolve(
+        argv[index + 1] || workspace
+      );
+      index += 1;
+      continue;
+    }
+    if (arg === "--") {
+      opencodeArgs.push(...argv.slice(index + 1));
+      break;
+    }
+    if (command === "promote" && !arg.startsWith("-") && !promotePackageId) {
+      promotePackageId = arg;
+      continue;
+    }
+    opencodeArgs.push(arg);
+  }
+  if (command === "start" && !startIntent) {
+    startIntent = { kind: "compose" };
+  }
+  if (command === "start" && startIntent?.kind === "compose" && !runtimeSelection) {
+    runtimeSelection = { kind: "profile", profile: startIntent.profile || "auto" };
+  }
+  if (runtimeSelection && runtimeSelection.kind !== "profile" && command === "setup") {
+    fail(
+      "'setup' does not accept '--mode'. Use 'setup minimal' for a minimal home."
+    );
+  }
+  if ((command === "compose" || command === "new") && !composeSelection2) {
+    if (command === "compose") {
+      fail("Use 'compose profile <name>' or 'compose bundle <name>'.");
+    }
+    fail(
+      "Use 'new soul <name>', 'new skill <name>', 'new instruction <name>', 'new bundle <name>', or 'new profile <name>'."
+    );
+  }
+  if ((profileCreateOptions.fromProfile || profileCreateOptions.addBundles.length > 0) && composeSelection2?.kind !== "profile") {
+    fail("'--from' and '--add' can only be used with 'compose profile' or 'new profile'.");
+  }
+  if (command === "doctor" || command === "hub-doctor") {
+    const modelActionCount = Number(Boolean(doctorOptions.model)) + Number(doctorOptions.clearModel);
+    const promptActionCount = Number(Boolean(doctorOptions.promptFile)) + Number(doctorOptions.clearPrompt);
+    const totalActionCount = modelActionCount + promptActionCount;
+    if (totalActionCount > 1) {
+      fail(
+        "Use exactly one of '--model <value>', '--clear-model', '--prompt-file <path>', or '--clear-prompt' with '--agent'."
+      );
+    }
+    if (totalActionCount > 0 && !doctorOptions.agent) {
+      fail("'doctor' prompt/model override commands require '--agent <name>'.");
+    }
+    if (doctorOptions.agent && totalActionCount === 0) {
+      fail(
+        "'doctor --agent <name>' requires one of '--model <value>', '--clear-model', '--prompt-file <path>', or '--clear-prompt'."
+      );
+    }
+  }
+  if (command === "hub-export" && !transferOptions.outputRoot) {
+    fail("'hub-export' requires '--output <path>'.");
+  }
+  if (command === "hub-import" && !transferOptions.sourceRoot) {
+    fail("'hub-import' requires '--source <path>'.");
+  }
+  if (command === "upgrade") {
+    doctorOptions.dryRun = false;
+    if (upgradeOptions.force) {
+      upgradeOptions.dryRun = false;
+    }
+  }
+  return {
+    command,
+    runtimeSelection,
+    composeSelection: composeSelection2,
+    listTarget,
+    pluginSubcommand,
+    workspace,
+    configRoot,
+    assembleOnly,
+    opencodeArgs,
+    bootstrapOptions,
+    profileCreateOptions,
+    upgradeOptions,
+    transferOptions,
+    doctorOptions,
+    promotePackageId,
+    startIntent,
+    hrIntent
+  };
+};
+const printTransferReport = (action, report) => {
+  process.stdout.write(`${action} complete
+`);
+  process.stdout.write(`- source: ${report.sourceRoot}
+`);
+  if (report.sourceKind) {
+    process.stdout.write(`- source kind: ${report.sourceKind}
+`);
+  }
+  process.stdout.write(`- target: ${report.targetRoot}
+`);
+  process.stdout.write(`- copied: ${report.copied.length}
+`);
+  process.stdout.write(`- skipped: ${report.skipped.length}
+`);
+  process.stdout.write(`- overwritten: ${report.overwritten.length}
+`);
+  process.stdout.write(`- settings: ${report.settingsAction}
+`);
+  if (report.warnings.length > 0) {
+    process.stdout.write(`Warnings:
+`);
+    for (const warning of report.warnings) {
+      process.stdout.write(`- ${warning}
+`);
+    }
+  }
+};
+const printRuntimeBanner = (label, root) => {
+  process.stdout.write(`[agenthub] Environment: ${label}
+`);
+  process.stdout.write(`[agenthub] Home: ${root}
+`);
+};
+const listPromotablePackageIds = async (hrRoot = defaultHrHome()) => {
+  try {
+    const entries = await readdir(path.join(hrRoot, "staging"), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+};
+const readPromoteHandoff = async (sourceRoot) => {
+  try {
+    return JSON.parse(
+      await readFile(path.join(path.dirname(sourceRoot), "handoff.json"), "utf-8")
+    );
+  } catch {
+    return null;
+  }
+};
+const resolvePromoteDefaultProfile = (handoff) => {
+  if (!handoff?.promotion_preferences?.set_default_profile) return void 0;
+  const targetProfile = handoff.target_profile?.trim();
+  if (targetProfile) return targetProfile;
+  const proposedProfile = handoff.proposed_profile?.trim();
+  return proposedProfile || void 0;
+};
+const resolvePromoteSourceRoot = async (packageId, hrRoot = defaultHrHome()) => {
+  if (packageId) {
+    return path.join(hrRoot, "staging", packageId, "agenthub-home");
+  }
+  const packageIds = await listPromotablePackageIds(hrRoot);
+  if (packageIds.length === 0) {
+    fail(`No staged HR packages found in ${path.join(hrRoot, "staging")}.`);
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    fail(`'promote' requires a package id in non-interactive mode. Available: ${packageIds.join(", ")}`);
+  }
+  const rl = createPromptInterface();
+  try {
+    process.stdout.write(`Available HR packages: ${packageIds.join(", ")}
+`);
+    const selected = await promptRequired(rl, "Package to promote", packageIds[0]);
+    if (!packageIds.includes(selected)) {
+      fail(`Unknown staged HR package '${selected}'. Available: ${packageIds.join(", ")}`);
+    }
+    return path.join(hrRoot, "staging", selected, "agenthub-home");
+  } finally {
+    rl.close();
+  }
+};
+const validatePromoteSourceRoot = async (sourceRoot, hrRoot = defaultHrHome()) => {
+  const resolvedSource = path.resolve(sourceRoot);
+  const stagingRoot = path.resolve(path.join(hrRoot, "staging"));
+  if (!resolvedSource.startsWith(`${stagingRoot}${path.sep}`)) {
+    fail(`Promote source must be inside ${stagingRoot}`);
+  }
+  const finalChecklistPath = path.join(path.dirname(resolvedSource), "final-checklist.md");
+  let finalChecklist;
+  try {
+    finalChecklist = await readFile(finalChecklistPath, "utf-8");
+  } catch {
+    finalChecklist = void 0;
+  }
+  if (!finalChecklist || !finalChecklist.includes("READY FOR HUMAN CONFIRMATION")) {
+    process.stderr.write(
+      `[agenthub] Warning: ${finalChecklistPath} is missing or not marked READY FOR HUMAN CONFIRMATION. Continuing with manual promote.
+`
+    );
+  }
+  const handoffPath = path.join(path.dirname(resolvedSource), "handoff.json");
+  let handoff = null;
+  try {
+    handoff = JSON.parse(await readFile(handoffPath, "utf-8"));
+  } catch {
+    process.stderr.write(`[agenthub] Warning: ${handoffPath} is missing.
+`);
+    return;
+  }
+  const instructions = handoff.operator_instructions;
+  if (!instructions?.test_current_workspace) {
+    process.stderr.write(
+      `[agenthub] Warning: ${handoffPath} is missing operator_instructions.test_current_workspace. Operators may not realize staged profiles can be tested before promote.
+`
+    );
+  }
+  if (!instructions?.use_in_another_workspace) {
+    process.stderr.write(
+      `[agenthub] Warning: ${handoffPath} is missing operator_instructions.use_in_another_workspace. Operators may not realize staged profiles can be used in another workspace before promote.
+`
+    );
+  }
+  if (!instructions?.promote) {
+    process.stderr.write(
+      `[agenthub] Warning: ${handoffPath} is missing operator_instructions.promote.
+`
+    );
+  }
+  if (!instructions?.advanced_import) {
+    process.stderr.write(
+      `[agenthub] Warning: ${handoffPath} is missing operator_instructions.advanced_import.
+`
+    );
+  }
+  const hostRequirements = handoff.host_requirements;
+  if (hostRequirements?.mcp_servers_bundled === false) {
+    const missing = hostRequirements.missing?.join(", ") || "MCP server artifacts";
+    fail(
+      `Staged package cannot be promoted yet because required MCP server artifacts are missing: ${missing}. Re-stage the package with bundled MCP servers first.`
+    );
+  }
+};
+const ensureHomeReadyOrFail = async (targetRoot = defaultAgentHubHome()) => {
+  if (await agentHubHomeInitialized(targetRoot)) return;
+  fail(`Agent Hub home is not initialized. Run:
+  ${cliCommand} setup`);
+};
+const ensureSelectedHomeReadyOrFail = async (parsed2) => {
+  const targetRoot = resolveSelectedHomeRoot(parsed2);
+  if (parsed2.command === "hr") {
+    if (await hrHomeInitialized(targetRoot || defaultHrHome())) return;
+    fail(`HR Office is not initialized. Run:
+  ${cliCommand} hr`);
+  }
+  await ensureHomeReadyOrFail(targetRoot);
+};
+const ensureHomeReadyOrBootstrap = async (targetRoot = defaultAgentHubHome()) => {
+  if (await agentHubHomeInitialized(targetRoot)) return;
+  await installAgentHubHome({ targetRoot, mode: "auto" });
+  process.stdout.write(`\u2713 First run \u2014 initialised coding system at ${targetRoot}
+`);
+};
+const promptHrBootstrapModelSelection = async (hrRoot) => {
+  const rl = createPromptInterface();
+  try {
+    process.stdout.write("\nFirst-time HR Office setup\n");
+    process.stdout.write("Choose an HR model preset:\n");
+    process.stdout.write(
+      `  recommended  Use ${recommendedHrBootstrapModel} (${recommendedHrBootstrapVariant})
+`
+    );
+    process.stdout.write(
+      "  free         Pick from current opencode free models (quality may drop)\n"
+    );
+    process.stdout.write("  custom       Enter any model id yourself\n\n");
+    const subagentStrategy = await promptChoice(
+      rl,
+      "HR model preset",
+      ["recommended", "free", "custom"],
+      "recommended"
+    );
+    let sharedSubagentModel;
+    let consoleModel;
+    if (subagentStrategy === "recommended") {
+      consoleModel = recommendedHrBootstrapModel;
+      sharedSubagentModel = recommendedHrBootstrapModel;
+    }
+    if (subagentStrategy === "free") {
+      const freeModels = await listOpencodeFreeModels();
+      const fallbackFreeModel = freeModels.includes("opencode/minimax-m2.5-free") ? "opencode/minimax-m2.5-free" : freeModels[0] || "opencode/minimax-m2.5-free";
+      process.stdout.write("Current opencode free models:\n");
+      sharedSubagentModel = await promptIndexedChoice(
+        rl,
+        "Choose a free model for HR",
+        freeModels.length > 0 ? freeModels : [fallbackFreeModel],
+        fallbackFreeModel
+      );
+      consoleModel = sharedSubagentModel;
+    } else if (subagentStrategy === "custom") {
+      sharedSubagentModel = await promptRequired(
+        rl,
+        "Custom HR model",
+        recommendedHrBootstrapModel
+      );
+      consoleModel = sharedSubagentModel;
+    }
+    process.stdout.write(`
+[agenthub] HR settings will be written to ${path.join(hrRoot, "settings.json")}
+`);
+    return {
+      consoleModel,
+      subagentStrategy,
+      sharedSubagentModel
+    };
+  } finally {
+    rl.close();
+  }
+};
+const printHrModelOverrideHint = (targetRoot) => {
+  process.stdout.write(
+    [
+      `[agenthub] HR model settings: ${path.join(targetRoot, "settings.json")}`,
+      `[agenthub] Change later with: ${cliCommand} doctor --target-root ${targetRoot} --agent ${hrPrimaryAgentName} --model <model>`,
+      `[agenthub] HR subagents: ${hrSubagentNames.join(", ")} (use the same doctor command with --agent <name>)`
+    ].join("\n") + "\n"
+  );
+};
+const countConfiguredHrGithubSources = async (targetRoot) => {
+  try {
+    const raw = JSON.parse(
+      await readFile(path.join(targetRoot, "hr-config.json"), "utf-8")
+    );
+    const githubSources = [];
+    if (Array.isArray(raw.sources)) {
+      githubSources.push(...raw.sources);
+    } else if (raw.sources && typeof raw.sources === "object") {
+      const nestedGithub = raw.sources.github;
+      if (Array.isArray(nestedGithub)) githubSources.push(...nestedGithub);
+    }
+    if (Array.isArray(raw.github)) githubSources.push(...raw.github);
+    return githubSources.length;
+  } catch {
+    return null;
+  }
+};
+const countConfiguredHrModelCatalogSources = async (targetRoot) => {
+  try {
+    const raw = JSON.parse(
+      await readFile(path.join(targetRoot, "hr-config.json"), "utf-8")
+    );
+    const modelSources = [];
+    if (raw.sources && typeof raw.sources === "object") {
+      const nestedModels = raw.sources.models;
+      if (Array.isArray(nestedModels)) modelSources.push(...nestedModels);
+    }
+    if (Array.isArray(raw.models)) modelSources.push(...raw.models);
+    return modelSources.length;
+  } catch {
+    return null;
+  }
+};
+const syncHrSourceInventoryOnFirstRun = async (targetRoot) => {
+  const configuredSourceCount = await countConfiguredHrGithubSources(targetRoot);
+  const configuredModelSourceCount = await countConfiguredHrModelCatalogSources(targetRoot);
+  const sourceParts = [];
+  if (configuredSourceCount && configuredSourceCount > 0) {
+    sourceParts.push(
+      `${configuredSourceCount} GitHub repo${configuredSourceCount === 1 ? "" : "s"}`
+    );
+  }
+  if (configuredModelSourceCount && configuredModelSourceCount > 0) {
+    sourceParts.push(
+      `${configuredModelSourceCount} model catalog${configuredModelSourceCount === 1 ? "" : "s"}`
+    );
+  }
+  const sourceLabel = sourceParts.length > 0 ? sourceParts.join(" + ") : "configured HR sources";
+  process.stdout.write(`[agenthub] First run \u2014 syncing HR inventory from ${sourceLabel}...
+`);
+  try {
+    const pythonCommand = resolvePythonCommand();
+    const scriptPath = path.join(targetRoot, "bin", "sync_sources.py");
+    const child = spawn(pythonCommand, [scriptPath], {
+      cwd: targetRoot,
+      env: {
+        ...process.env,
+        OPENCODE_AGENTHUB_HR_HOME: targetRoot
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      ...spawnOptions()
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const code = await new Promise((resolve, reject) => {
+      child.on("error", reject);
+      child.on("close", (exitCode) => resolve(exitCode ?? 1));
+    });
+    const summary = stdout.trim();
+    if (code === 0) {
+      if (summary) process.stdout.write(`${summary}
+`);
+      process.stdout.write(
+        `[agenthub] HR source status: ${path.join(targetRoot, "source-status.json")}
+`
+      );
+      return;
+    }
+    process.stderr.write(
+      `[agenthub] Warning: first-run HR source sync did not complete. Continue using HR and retry later with '${pythonCommand} ${scriptPath}'.
+`
+    );
+    if (stderr.trim()) process.stderr.write(`${stderr.trim()}
+`);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const pythonCommand = resolvePythonCommand();
+    process.stderr.write(
+      `[agenthub] Warning: failed to launch first-run HR source sync (${reason}). Retry later with '${pythonCommand} ${path.join(targetRoot, "bin", "sync_sources.py")}'.
+`
+    );
+  }
+};
+const ensureHrOfficeReadyOrBootstrap = async (targetRoot = defaultHrHome(), options = {}) => {
+  if (await hrHomeInitialized(targetRoot)) return;
+  const shouldPrompt = process.stdin.isTTY && process.stdout.isTTY;
+  const hrModelSelection = shouldPrompt ? await promptHrBootstrapModelSelection(targetRoot) : void 0;
+  await installHrOfficeHomeWithOptions({
+    hrRoot: targetRoot,
+    hrModelSelection
+  });
+  process.stdout.write(`\u2713 First run \u2014 initialised HR Office at ${targetRoot}
+`);
+  printHrModelOverrideHint(targetRoot);
+  if (options.syncSourcesOnFirstRun ?? true) {
+    await syncHrSourceInventoryOnFirstRun(targetRoot);
+  }
+};
+const isHrRuntimeSelection = (selection) => selection?.kind === "profile" && selection.profile === "hr";
+const normalizeCsv = (value) => value.split(",").map((item) => item.trim()).filter(Boolean);
+const uniqueValues = (values) => [...new Set(values)];
+const normalizeOptional = (value) => {
+  const trimmed = value.trim();
+  return trimmed || void 0;
+};
+const toJsonFile = (root, directory, name) => path.join(root, directory, `${name}.json`);
+const listNamesByExt = async (dirPath, ext) => {
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(ext)).map((entry) => entry.name.slice(0, -ext.length)).sort();
+  } catch {
+    return [];
+  }
+};
+const writeJsonFile = async (filePath, payload) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+};
+const workspacePreferencesPath = (workspace) => path.join(workspace, ".opencode-agenthub.user.json");
+const readJsonIfExists = async (filePath) => {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const normalized = content.split("\n").filter((line) => !line.trim().startsWith("//")).join("\n");
+    return JSON.parse(normalized);
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT" || code === "EISDIR") return void 0;
+    throw e;
+  }
+};
+const loadWorkspacePreferences = async (workspace) => {
+  const raw = await readJsonIfExists(
+    workspacePreferencesPath(workspace)
+  ) || {};
+  return {
+    _version: 1,
+    ...raw
+  };
+};
+const saveWorkspacePreferences = async (workspace, preferences) => {
+  await writeJsonFile(workspacePreferencesPath(workspace), {
+    _version: 1,
+    ...preferences
+  });
+};
+const updateWorkspacePreferences = async (workspace, updater) => {
+  const current = await loadWorkspacePreferences(workspace);
+  await saveWorkspacePreferences(workspace, updater(current));
+};
+const readStartDefaultProfile = async (targetRoot = defaultAgentHubHome()) => {
+  const settings = await readAgentHubSettings(targetRoot);
+  return settings?.preferences?.defaultProfile?.trim() || void 0;
+};
+const setStartDefaultProfile = async (profile, targetRoot = defaultAgentHubHome()) => {
+  const existingSettings = await readAgentHubSettings(targetRoot) || {};
+  const mergedSettings = mergeAgentHubSettingsDefaults(existingSettings);
+  await writeAgentHubSettings(targetRoot, {
+    ...mergedSettings,
+    preferences: {
+      ...mergedSettings.preferences || {},
+      defaultProfile: profile
+    }
+  });
+};
+const resolveStartProfilePreference = async (workspace, targetRoot = defaultAgentHubHome()) => {
+  const defaultProfile = await readStartDefaultProfile(targetRoot);
+  if (defaultProfile) {
+    return { profile: defaultProfile, source: "default" };
+  }
+  const preferences = await loadWorkspacePreferences(workspace);
+  const lastProfile = preferences.start?.lastProfile?.trim();
+  if (lastProfile) {
+    return { profile: lastProfile, source: "last" };
+  }
+  return { profile: "auto", source: "fallback" };
+};
+const resolveHrLastProfilePreference = async (workspace) => {
+  const preferences = await loadWorkspacePreferences(workspace);
+  return preferences.hr?.lastProfile?.trim() || void 0;
+};
+const resolveStartLastProfilePreference = async (workspace) => {
+  const preferences = await loadWorkspacePreferences(workspace);
+  const lastProfile = preferences.start?.lastProfile?.trim();
+  if (lastProfile) {
+    return { profile: lastProfile, source: "last" };
+  }
+  return { profile: "auto", source: "fallback" };
+};
+const noteProfileResolution = (command, source, profile) => {
+  if (source === "explicit") return;
+  if (command === "start" && source === "default") {
+    process.stderr.write(`[agenthub] start -> using personal default profile '${profile}'.
+`);
+    return;
+  }
+  if (source === "last") {
+    process.stderr.write(`[agenthub] ${command} -> using last profile '${profile}'.
+`);
+    return;
+  }
+  if (command === "start" && source === "fallback") {
+    process.stderr.write(`[agenthub] start -> no default or previous profile found; using 'auto'.
+`);
+  }
+};
+const warnIfWorkspaceRuntimeWillBeReplaced = async (workspace, label) => {
+  const lockPath = path.join(getWorkspaceRuntimeRoot(workspace), "agenthub-lock.json");
+  if (!await readJsonIfExists(lockPath)) return;
+  process.stderr.write(
+    `[agenthub] Replacing the current workspace runtime with ${label}. Plain 'opencode' in this folder will use the new runtime after compose.
+`
+  );
+};
+const toWorkspaceEnvrc = (workspace, configRoot) => {
+  const resolvedConfigRoot = path.resolve(configRoot);
+  const relativeConfigRoot = path.relative(workspace, resolvedConfigRoot);
+  const configRootRef = relativeConfigRoot && !relativeConfigRoot.startsWith("..") ? `$PWD/${relativeConfigRoot}` : resolvedConfigRoot;
+  return `# Generated by opencode-agenthub. Remove this file to disable auto-activation.
+export XDG_CONFIG_HOME="${configRootRef}/xdg"
+export OPENCODE_DISABLE_PROJECT_CONFIG=true
+export OPENCODE_CONFIG_DIR="${configRootRef}"
+`;
+};
+const maybeConfigureEnvrc = async (workspace, configRoot) => {
+  if (!shouldOfferEnvrc()) return;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+  const preferences = await loadWorkspacePreferences(workspace);
+  const envrcPath = path.join(workspace, ".envrc");
+  const envrcExists = await stat(envrcPath).then((s) => s.isFile() || s.isFIFO()).catch((e) => e.code === "ENOENT" ? false : Promise.reject(e));
+  if (envrcExists) {
+    if (!preferences.envrc?.enabled || !preferences.envrc?.prompted) {
+      await saveWorkspacePreferences(workspace, {
+        ...preferences,
+        envrc: { prompted: true, enabled: true }
+      });
+    }
+    return;
+  }
+  if (preferences.envrc?.prompted) return;
+  const rl = createPromptInterface();
+  try {
+    const enableEnvrc = await promptBoolean(
+      rl,
+      "Enable Agent Hub auto-activation with .envrc so plain 'opencode' works here?",
+      false
+    );
+    if (enableEnvrc) {
+      await writeFile(
+        envrcPath,
+        toWorkspaceEnvrc(workspace, configRoot),
+        "utf-8"
+      );
+      process.stdout.write(
+        `Wrote ${envrcPath}. Run 'direnv allow' in this workspace to enable plain 'opencode'.
+`
+      );
+    }
+    await saveWorkspacePreferences(workspace, {
+      ...preferences,
+      envrc: { prompted: true, enabled: enableEnvrc }
+    });
+  } finally {
+    rl.close();
+  }
+};
+const createPromptInterface = () => readline.createInterface({ input: process.stdin, output: process.stdout });
+const promptRequired = async (rl, question, defaultValue) => {
+  while (true) {
+    const answer = await rl.question(
+      defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `
+    );
+    const value = normalizeOptional(answer) || defaultValue;
+    if (value) return value;
+    process.stdout.write("This field is required.\n");
+  }
+};
+const promptOptional = async (rl, question, defaultValue) => {
+  const answer = await rl.question(
+    defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `
+  );
+  return normalizeOptional(answer) || defaultValue;
+};
+const promptCsv = async (rl, question, defaultValues = []) => {
+  const defaultValue = defaultValues.join(", ");
+  const answer = await rl.question(
+    defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `
+  );
+  return normalizeCsv(answer || defaultValue);
+};
+const promptBoolean = async (rl, question, defaultValue) => {
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  while (true) {
+    const answer = (await rl.question(`${question} ${suffix}: `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    if (answer === "y" || answer === "yes") return true;
+    if (answer === "n" || answer === "no") return false;
+    process.stdout.write("Please answer y or n.\n");
+  }
+};
+const promptChoice = async (rl, question, choices, defaultValue) => {
+  const label = `${question} [${choices.join("/")}] (${defaultValue})`;
+  while (true) {
+    const answer = (await rl.question(`${label}: `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    const match = choices.find((choice) => choice === answer);
+    if (match) return match;
+    process.stdout.write(`Choose one of: ${choices.join(", ")}
+`);
+  }
+};
+const promptIndexedChoice = async (rl, question, choices, defaultValue) => {
+  choices.forEach((choice, index) => {
+    process.stdout.write(`  ${index + 1}. ${choice}
+`);
+  });
+  const defaultIndex = Math.max(choices.indexOf(defaultValue), 0) + 1;
+  while (true) {
+    const answer = (await rl.question(`${question} [1-${choices.length}] (${defaultIndex}): `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    const numeric = Number(answer);
+    if (Number.isInteger(numeric) && numeric >= 1 && numeric <= choices.length) {
+      return choices[numeric - 1] || defaultValue;
+    }
+    const exactMatch = choices.find((choice) => choice.toLowerCase() === answer);
+    if (exactMatch) return exactMatch;
+    process.stdout.write("Choose a listed number or exact model id.\n");
+  }
+};
+const listOpencodeFreeModels = async () => new Promise((resolve) => {
+  const child = spawn("opencode", ["models", "opencode"], {
+    stdio: ["ignore", "pipe", "ignore"],
+    ...spawnOptions()
+  });
+  let stdout = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.on("error", () => resolve([]));
+  child.on("close", () => {
+    const models = stdout.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("opencode/") && line.includes("free"));
+    resolve([...new Set(models)].sort());
+  });
+});
+const promptOptionalCsvSelection = async (rl, question, available, defaultValues = []) => {
+  const include = await promptBoolean(rl, question, false);
+  if (!include) return [];
+  if (available.length > 0) {
+    process.stdout.write(`Available: ${available.join(", ")}
+`);
+  }
+  return promptCsv(rl, "Enter names (comma-separated)", defaultValues);
+};
+const listSkillNames = async (skillsDir) => {
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+};
+const assertNameNotReserved = async (kind, name, reservedOk) => {
+  if (reservedOk) return;
+  const builtIns = await listBuiltInAssetNames(kind);
+  if (!builtIns.has(name)) return;
+  fail(
+    `'${name}' is a reserved built-in ${kind} name. Use a different name or pass '--reserved-ok' to override.`
+  );
+};
+const detectSetupModeForHome = async (targetRoot) => {
+  const settings = await readAgentHubSettings(targetRoot);
+  const mode = settings?.meta?.onboarding?.mode;
+  if (mode === "auto" || mode === "minimal") {
+    return mode;
+  }
+  const legacyStarter = settings?.meta?.onboarding?.starter;
+  if (legacyStarter === "none" || legacyStarter === "framework") {
+    return "minimal";
+  }
+  return "auto";
+};
+const detectInstallModeForHome = async (targetRoot, isHrHome = false) => {
+  if (isHrHome) return "hr-office";
+  return detectSetupModeForHome(targetRoot);
+};
+const warnIfBuiltInsDrifted = async (targetRoot, mode) => {
+  const settings = await readAgentHubSettings(targetRoot);
+  const builtinVersion = settings?.meta?.builtinVersion;
+  if (!builtinVersion || Object.keys(builtinVersion).length === 0) return;
+  const effectiveMode = mode ?? await detectInstallModeForHome(targetRoot);
+  const allowedKeys = new Set(getBuiltInManifestKeysForMode(effectiveMode));
+  const currentVersion = readPackageVersion();
+  const staleAssets = Object.entries(builtinVersion).filter(([asset]) => allowedKeys.has(asset)).filter(([, installedVersion]) => installedVersion !== currentVersion).map(([asset]) => asset).sort();
+  if (staleAssets.length === 0) return;
+  process.stderr.write(
+    [
+      `[agenthub] Built-in assets may be stale (${staleAssets.length} item${staleAssets.length === 1 ? "" : "s"}) relative to package ${currentVersion}.`,
+      `Run '${cliCommand} upgrade${targetRoot !== defaultAgentHubHome() ? ` --target-root ${targetRoot}` : ""}' to preview or sync updates.`
+    ].join("\n") + "\n"
+  );
+};
+const hrLegacyAssetNames = [
+  "hr",
+  "hr-sourcer",
+  "hr-evaluator",
+  "hr-cto",
+  "hr-adapter",
+  "hr-verifier"
+];
+const warnAboutLegacyHrAssets = async (personalRoot = defaultAgentHubHome()) => {
+  const hrBundleDir = path.join(personalRoot, "bundles");
+  const found = await Promise.all(
+    hrLegacyAssetNames.map(async (name) => ({
+      name,
+      exists: await readFile(path.join(hrBundleDir, `${name}.json`), "utf-8").then(() => true).catch(() => false)
+    }))
+  );
+  const present = found.filter((entry) => entry.exists).map((entry) => entry.name);
+  if (present.length === 0) return;
+  process.stderr.write(
+    [
+      `[agenthub] Notice: legacy HR assets were found in your personal home (${present.join(", ")}).`,
+      `[agenthub] They are left in place for compatibility. Use '${cliCommand} hr' for new isolated HR work.`
+    ].join("\n") + "\n"
+  );
+};
+const profileExistsInHome = async (targetRoot, profile) => {
+  return Boolean(
+    await readJsonIfExists(
+      path.join(targetRoot, "profiles", `${profile}.json`)
+    )
+  );
+};
+const listStagedHrProfileMatches = async (profile, hrRoot = defaultHrHome()) => {
+  try {
+    const stagingRoot = path.join(hrRoot, "staging");
+    const entries = await readdir(stagingRoot, { withFileTypes: true });
+    const matches = await Promise.all(
+      entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+        const libraryRoot = path.join(stagingRoot, entry.name, "agenthub-home");
+        const profilePath = path.join(libraryRoot, "profiles", `${profile}.json`);
+        const profileStat = await stat(profilePath).catch(() => null);
+        if (!profileStat?.isFile()) return null;
+        return {
+          packageId: entry.name,
+          profile,
+          libraryRoot,
+          profilePath,
+          modifiedAtMs: profileStat.mtimeMs
+        };
+      })
+    );
+    return matches.filter((match) => Boolean(match)).sort((a, b) => b.modifiedAtMs - a.modifiedAtMs || a.packageId.localeCompare(b.packageId));
+  } catch {
+    return [];
+  }
+};
+const resolveHrProfileSource = async (profile, hrRoot = defaultHrHome()) => {
+  if (await profileExistsInHome(hrRoot, profile)) {
+    return {
+      libraryRoot: hrRoot,
+      settingsRoot: hrRoot,
+      kind: "home"
+    };
+  }
+  const stagedMatches = await listStagedHrProfileMatches(profile, hrRoot);
+  if (stagedMatches.length > 0) {
+    return {
+      libraryRoot: stagedMatches[0].libraryRoot,
+      settingsRoot: hrRoot,
+      kind: "staged",
+      match: stagedMatches[0]
+    };
+  }
+  return {
+    libraryRoot: hrRoot,
+    settingsRoot: hrRoot,
+    kind: "home"
+  };
+};
+const printHrStagedProfileResolution = async (profile, match, hrRoot = defaultHrHome()) => {
+  const stagedMatches = await listStagedHrProfileMatches(profile, hrRoot);
+  process.stderr.write(
+    `[agenthub] Staging test -> using profile '${profile}' from staged package '${match.packageId}'.
+`
+  );
+  process.stderr.write(`[agenthub] Source: ${match.libraryRoot}
+`);
+  if (stagedMatches.length > 1) {
+    const alternates = stagedMatches.slice(1).map((item) => item.packageId).join(", ");
+    process.stderr.write(
+      `[agenthub] Warning: profile '${profile}' also exists in other staged packages: ${alternates}. Using the most recently updated match.
+`
+    );
+  }
+};
+const printUpgradeReport = (targetRoot, report, options) => {
+  const verb = options.dryRun ? "Would" : "Did";
+  process.stdout.write(`Built-in asset sync ${options.dryRun ? "preview" : "complete"}
+`);
+  process.stdout.write(`- target: ${targetRoot}
+`);
+  process.stdout.write(`- mode: ${options.dryRun ? "dry-run" : options.force ? "force" : "safe"}
+`);
+  process.stdout.write(`- add: ${report.added.length}
+`);
+  process.stdout.write(`- update: ${report.updated.length}
+`);
+  process.stdout.write(`- skip: ${report.skipped.length}
+`);
+  for (const [label, entries] of [
+    [`${verb} add`, report.added],
+    [`${verb} update`, report.updated],
+    [`${verb} skip`, report.skipped]
+  ]) {
+    if (entries.length === 0) continue;
+    process.stdout.write(`${label}:
+`);
+    for (const entry of entries) {
+      process.stdout.write(`- ${entry}
+`);
+    }
+  }
+  if (options.dryRun) {
+    process.stdout.write("Run again with '--force' to overwrite managed built-in files.\n");
+  } else if (!options.force) {
+    process.stdout.write("Existing managed files were left in place; re-run with '--force' to overwrite them.\n");
+  }
+};
+const createSoulDefinition = async (root, name, reservedOk = false) => {
+  await assertNameNotReserved("soul", name, reservedOk);
+  const filePath = path.join(root, "souls", `${name}.md`);
+  const rl = createPromptInterface();
+  try {
+    await maybeOverwrite(rl, filePath);
+    const content = [
+      `# ${name}`,
+      "",
+      "## Description",
+      "Describe this soul's purpose and when to use it.",
+      "",
+      "## Behavior",
+      "- Primary goals",
+      "- Constraints",
+      "- Expected output style",
+      ""
+    ].join("\n");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+    return filePath;
+  } finally {
+    rl.close();
+  }
+};
+const createInstructionDefinition = async (root, name, reservedOk = false) => {
+  await assertNameNotReserved("instruction", name, reservedOk);
+  const filePath = path.join(root, "instructions", `${name}.md`);
+  const rl = createPromptInterface();
+  try {
+    await maybeOverwrite(rl, filePath);
+    const content = [
+      `# ${name}`,
+      "",
+      "## Purpose",
+      "State the instruction this file adds to an agent.",
+      "",
+      "## Rules",
+      "- Add concrete rules here",
+      ""
+    ].join("\n");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+    return filePath;
+  } finally {
+    rl.close();
+  }
+};
+const createSkillDefinition = async (root, name, reservedOk = false) => {
+  await assertNameNotReserved("skill", name, reservedOk);
+  const filePath = path.join(root, "skills", name, "SKILL.md");
+  const rl = createPromptInterface();
+  try {
+    await maybeOverwrite(rl, filePath);
+    const content = [
+      `# ${name}`,
+      "",
+      "## When to use",
+      "Describe when this skill should be loaded.",
+      "",
+      "## Instructions",
+      "- Add the concrete workflow here",
+      ""
+    ].join("\n");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+    return filePath;
+  } finally {
+    rl.close();
+  }
+};
+const readProfileDefinition = async (root, name) => readJsonIfExists(path.join(root, "profiles", `${name}.json`));
+const promptRecord = async (rl, question) => {
+  const answer = await rl.question(
+    `${question} (comma-separated key=value, blank to skip): `
+  );
+  const entries = normalizeCsv(answer);
+  if (entries.length === 0) return void 0;
+  const record = {};
+  for (const entry of entries) {
+    const separator = entry.indexOf("=");
+    if (separator === -1) {
+      fail(`Invalid entry '${entry}'. Use key=value format.`);
+    }
+    const key = entry.slice(0, separator).trim();
+    const value = entry.slice(separator + 1).trim();
+    if (!key || !value) {
+      fail(`Invalid entry '${entry}'. Use key=value format.`);
+    }
+    record[key] = value;
+  }
+  return Object.keys(record).length > 0 ? record : void 0;
+};
+const maybeOverwrite = async (rl, filePath) => {
+  try {
+    await readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const overwrite = await promptBoolean(
+    rl,
+    `${path.basename(filePath)} already exists. Overwrite it?`,
+    false
+  );
+  if (!overwrite) {
+    fail(`Aborted without changing ${filePath}`);
+  }
+};
+const createProfileDefinition = async (root, name, options = { addBundles: [], reservedOk: false }) => {
+  await assertNameNotReserved("profile", name, options.reservedOk);
+  const filePath = toJsonFile(root, "profiles", name);
+  const availableBundles = await listNamesByExt(path.join(root, "bundles"), ".json");
+  const addCapabilities = listProfileAddCapabilityNames();
+  const seededProfile = options.fromProfile ? await readProfileDefinition(root, options.fromProfile) : void 0;
+  if (options.fromProfile && !seededProfile) {
+    const availableProfiles = await listNamesByExt(path.join(root, "profiles"), ".json");
+    fail(
+      `Profile '${options.fromProfile}' was not found. Available profiles: ${availableProfiles.join(", ") || "(none)"}`
+    );
+  }
+  const expandedAdds = expandProfileAddSelections(options.addBundles.filter(Boolean));
+  const seededBundles = uniqueValues([
+    ...seededProfile?.bundles || [],
+    ...expandedAdds
+  ]);
+  const invalidBundles = seededBundles.filter((bundle) => !availableBundles.includes(bundle));
+  if (invalidBundles.length > 0) {
+    fail(
+      `Unknown bundle(s): ${invalidBundles.join(", ")}. Available bundles: ${availableBundles.join(", ") || "(none)"}. Capability shorthands: ${addCapabilities.join(", ") || "(none)"}`
+    );
+  }
+  const rl = createPromptInterface();
+  try {
+    await maybeOverwrite(rl, filePath);
+    if (availableBundles.length > 0) {
+      process.stdout.write(
+        `Available bundles: ${availableBundles.join(", ")}
+`
+      );
+    }
+    if (addCapabilities.length > 0) {
+      process.stdout.write(
+        `Capability shorthands for --add: ${addCapabilities.join(", ")}
+`
+      );
+    }
+    const description = await promptOptional(rl, "Profile description");
+    const bundles = await promptCsv(
+      rl,
+      "Bundles to include",
+      seededBundles
+    );
+    const defaultAgent = await promptOptional(
+      rl,
+      "Default agent (leave blank to let runtime decide)"
+    );
+    const plugins = await promptCsv(
+      rl,
+      "Plugins to enable (comma-separated package names or paths)",
+      seededProfile?.plugins || []
+    );
+    const payload = {
+      name,
+      bundles,
+      plugins
+    };
+    if (description) payload.description = description;
+    if (defaultAgent) payload.defaultAgent = defaultAgent;
+    await writeJsonFile(filePath, payload);
+    return filePath;
+  } finally {
+    rl.close();
+  }
+};
+const createBundleDefinition = async (root, name, reservedOk = false) => {
+  await assertNameNotReserved("bundle", name, reservedOk);
+  const filePath = toJsonFile(root, "bundles", name);
+  const availableSouls = await listNamesByExt(path.join(root, "souls"), ".md");
+  const availableInstructions = await listNamesByExt(
+    path.join(root, "instructions"),
+    ".md"
+  );
+  const availableSkills = await listSkillNames(path.join(root, "skills"));
+  const availableMcp = await listNamesByExt(path.join(root, "mcp"), ".json");
+  const rl = createPromptInterface();
+  try {
+    await maybeOverwrite(rl, filePath);
+    if (availableSouls.length > 0) {
+      process.stdout.write(`Available souls: ${availableSouls.join(", ")}
+`);
+    }
+    if (availableInstructions.length > 0) {
+      process.stdout.write(`Available instructions: ${availableInstructions.join(", ")}
+`);
+    }
+    if (availableSkills.length > 0) {
+      process.stdout.write(`Available skills: ${availableSkills.join(", ")}
+`);
+    }
+    const runtime = await promptChoice(
+      rl,
+      "Runtime",
+      ["native", "omo"],
+      "native"
+    );
+    const readOnly = runtime === "native" ? await promptBoolean(
+      rl,
+      "Read-only agent? (Y = plan-like, N = build-like)",
+      true
+    ) : false;
+    const soul = await promptRequired(rl, "Soul name", availableSouls[0]);
+    const instructions = await promptOptionalCsvSelection(
+      rl,
+      "Attach instructions from instructions/?",
+      availableInstructions
+    );
+    const skills = await promptOptionalCsvSelection(
+      rl,
+      "Attach skills from skills/?",
+      availableSkills
+    );
+    const mcp = await promptOptionalCsvSelection(
+      rl,
+      "Attach custom MCP tools? (basic opencode tools stay available)",
+      availableMcp
+    );
+    const guards = await promptCsv(rl, "Extra guards (comma-separated)");
+    const categories = runtime === "omo" ? await promptRecord(rl, "Category model mapping") : void 0;
+    const agentName = await promptRequired(rl, "Agent name", name);
+    const agentMode = await promptChoice(
+      rl,
+      "Agent mode",
+      ["primary", "subagent"],
+      "primary"
+    );
+    const hidden = await promptBoolean(
+      rl,
+      "Hide this agent from normal listings?",
+      false
+    );
+    const model = await promptRequired(rl, "Agent model");
+    const description = await promptOptional(rl, "Agent description");
+    const payload = {
+      name,
+      runtime,
+      soul,
+      ...instructions.length > 0 ? { instructions } : {},
+      skills,
+      agent: {
+        name: agentName,
+        mode: agentMode,
+        hidden,
+        model
+      }
+    };
+    if (readOnly) {
+      payload.guards = uniqueValues([...payload.guards || [], "no_task"]);
+    }
+    if (mcp.length > 0) payload.mcp = mcp;
+    if (guards.length > 0) {
+      payload.guards = uniqueValues([...payload.guards || [], ...guards]);
+    }
+    if (description) payload.agent.description = description;
+    if (categories && Object.keys(categories).length > 0) {
+      payload.categories = categories;
+      const enableSpawn = await promptBoolean(
+        rl,
+        "Generate category-family spawn config from those categories?",
+        true
+      );
+      if (enableSpawn) {
+        payload.spawn = {
+          strategy: "category-family",
+          source: "categories",
+          shared: {
+            soul,
+            skills
+          }
+        };
+      }
+    }
+    await writeJsonFile(filePath, payload);
+    return filePath;
+  } finally {
+    rl.close();
+  }
+};
+const resolveConfigRoot = (parsed2) => {
+  if (parsed2.configRoot) return parsed2.configRoot;
+  if (!parsed2.runtimeSelection) {
+    return parsed2.workspace;
+  }
+  if (parsed2.runtimeSelection.kind === "tools-only") {
+    return getWorkspaceRuntimeRoot(parsed2.workspace);
+  }
+  if (parsed2.runtimeSelection.kind === "customized-agent") {
+    return getWorkspaceRuntimeRoot(parsed2.workspace);
+  }
+  return getDefaultConfigRoot(
+    parsed2.workspace,
+    parsed2.runtimeSelection.profile
+  );
+};
+const resolveSelectedHomeRoot = (parsed2) => {
+  if (parsed2.bootstrapOptions.targetRoot) {
+    return parsed2.bootstrapOptions.targetRoot;
+  }
+  if (parsed2.command === "hr") {
+    return defaultHrHome();
+  }
+  return void 0;
+};
+const composeSelection = async (parsed2, configRoot) => {
+  let homeRoot = resolveSelectedHomeRoot(parsed2);
+  let settingsRoot = homeRoot;
+  if (!parsed2.runtimeSelection) {
+    return { workspace: parsed2.workspace, configRoot };
+  }
+  if (parsed2.command === "hr" && parsed2.hrIntent?.kind === "compose" && parsed2.runtimeSelection.kind === "profile") {
+    const resolved = await resolveHrProfileSource(
+      parsed2.runtimeSelection.profile,
+      defaultHrHome()
+    );
+    homeRoot = resolved.libraryRoot;
+    settingsRoot = resolved.settingsRoot;
+    if (resolved.kind === "staged" && resolved.match) {
+      await printHrStagedProfileResolution(
+        parsed2.runtimeSelection.profile,
+        resolved.match,
+        defaultHrHome()
+      );
+    }
+  }
+  if (parsed2.runtimeSelection.kind === "tools-only") {
+    return composeToolInjection(parsed2.workspace, configRoot, { homeRoot, settingsRoot });
+  }
+  if (parsed2.runtimeSelection.kind === "customized-agent") {
+    return composeCustomizedAgent(parsed2.workspace, configRoot, { homeRoot, settingsRoot });
+  }
+  return composeWorkspace(
+    parsed2.workspace,
+    parsed2.runtimeSelection.profile,
+    configRoot,
+    { homeRoot, settingsRoot }
+  );
+};
+const runOpencode = async (workspace, configRoot, opencodeArgs) => {
+  const env = configRoot ? {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(configRoot, "xdg"),
+    OPENCODE_DISABLE_PROJECT_CONFIG: "true",
+    OPENCODE_CONFIG_DIR: configRoot
+  } : process.env;
+  const child = spawn("opencode", opencodeArgs, {
+    cwd: workspace,
+    stdio: "inherit",
+    env,
+    ...spawnOptions()
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+};
+const parsed = parseArgs(process.argv.slice(2));
+const startupNotice = windowsStartupNotice();
+if (startupNotice) {
+  process.stderr.write(`${startupNotice}
+`);
+}
+if (parsed.command === "start" || parsed.command === "run") {
+  if (parsed.runtimeSelection?.kind === "profile" && parsed.runtimeSelection.profile === "hr") {
+    fail(
+      `'start hr' and 'run hr' are no longer supported. Use '${cliCommand} hr' for HR Office or '${cliCommand} hr <profile>' to test an HR profile in this workspace.`
+    );
+  }
+  if (parsed.startIntent?.kind === "set-default") {
+    const targetRoot = resolveSelectedHomeRoot(parsed) || defaultAgentHubHome();
+    await ensureHomeReadyOrFail(targetRoot);
+    if (!await profileExistsInHome(targetRoot, parsed.startIntent.profile)) {
+      fail(
+        `Profile '${parsed.startIntent.profile}' not found in ${path.join(targetRoot, "profiles")}.`
+      );
+    }
+    await setStartDefaultProfile(parsed.startIntent.profile, targetRoot);
+    process.stdout.write(
+      `Set default start profile to '${parsed.startIntent.profile}' for ${targetRoot}
+`
+    );
+    process.exit(0);
+  }
+  if (parsed.startIntent?.kind === "compose" && !parsed.startIntent.profile) {
+    const resolved = parsed.startIntent.source === "last" ? await resolveStartLastProfilePreference(parsed.workspace) : await resolveStartProfilePreference(
+      parsed.workspace,
+      resolveSelectedHomeRoot(parsed) || defaultAgentHubHome()
+    );
+    parsed.startIntent = {
+      kind: "compose",
+      profile: resolved.profile,
+      source: resolved.source
+    };
+    parsed.runtimeSelection = {
+      kind: "profile",
+      profile: resolved.profile
+    };
+    noteProfileResolution("start", resolved.source, resolved.profile);
+  }
+}
+if (parsed.command === "hr" && parsed.hrIntent?.kind === "compose" && parsed.hrIntent.source === "last") {
+  const lastProfile = await resolveHrLastProfilePreference(parsed.workspace);
+  if (!lastProfile) {
+    fail(`No previous HR workspace profile for this folder. Use: ${cliCommand} hr <profile>`);
+  }
+  parsed.hrIntent = { kind: "compose", profile: lastProfile, source: "last" };
+  parsed.runtimeSelection = {
+    kind: "profile",
+    profile: lastProfile
+  };
+  noteProfileResolution("hr", "last", lastProfile);
+}
+if (parsed.command === "setup") {
+  const options = Object.keys(parsed.bootstrapOptions).length ? parsed.bootstrapOptions : await promptHubInitAnswers();
+  const targetRoot = await installAgentHubHome(options);
+  const mode = options.mode ?? "auto";
+  if (mode === "auto") {
+    process.stdout.write(`\u2713 Coding system ready. Run: ${cliCommand} start
+`);
+  } else {
+    process.stdout.write("\u2713 Minimal Agent Hub structure ready. Add your own assets anytime.\n");
+  }
+  process.stdout.write(`${targetRoot}
+`);
+  process.exit(0);
+}
+if (parsed.command === "backup") {
+  const outputRoot = parsed.transferOptions.outputRoot;
+  if (!outputRoot) {
+    fail("'backup' requires '--output <path>'.");
+  }
+  const report = await exportAgentHubHome({
+    sourceRoot: defaultAgentHubHome(),
+    outputRoot,
+    pluginVersion: readPackageVersion()
+  });
+  printTransferReport("Backup", report);
+  process.exit(0);
+}
+if (parsed.command === "restore") {
+  const importSourceRoot = parsed.transferOptions.sourceRoot;
+  if (!importSourceRoot) {
+    fail("'restore' requires '--source <path>'.");
+  }
+  const report = await importAgentHubHome({
+    sourceRoot: importSourceRoot,
+    targetRoot: defaultAgentHubHome(),
+    overwrite: parsed.transferOptions.overwrite,
+    settingsMode: parsed.transferOptions.settingsMode
+  });
+  printTransferReport("Restore", report);
+  process.exit(0);
+}
+if (parsed.command === "promote") {
+  const hrRoot = defaultHrHome();
+  const sourceRoot = await resolvePromoteSourceRoot(parsed.promotePackageId, hrRoot);
+  const handoff = await readPromoteHandoff(sourceRoot);
+  await validatePromoteSourceRoot(sourceRoot, hrRoot);
+  const report = await importAgentHubHome({
+    sourceRoot,
+    targetRoot: defaultAgentHubHome(),
+    overwrite: false,
+    settingsMode: "preserve"
+  });
+  const defaultProfile = resolvePromoteDefaultProfile(handoff);
+  if (defaultProfile) {
+    await setStartDefaultProfile(defaultProfile);
+  }
+  printTransferReport("Promote", report);
+  if (defaultProfile) {
+    process.stdout.write(`- default profile updated: ${defaultProfile}
+`);
+  }
+  process.exit(0);
+}
+if (parsed.command === "hub-export") {
+  const outputRoot = parsed.transferOptions.outputRoot;
+  if (!outputRoot) {
+    fail("'hub-export' requires '--output <path>'.");
+  }
+  const report = await exportAgentHubHome({
+    sourceRoot: parsed.transferOptions.sourceRoot,
+    outputRoot,
+    pluginVersion: readPackageVersion()
+  });
+  printTransferReport("Export", report);
+  process.exit(0);
+}
+if (parsed.command === "hub-import") {
+  const importSourceRoot = parsed.transferOptions.sourceRoot;
+  if (!importSourceRoot) {
+    fail("'hub-import' requires '--source <path>'.");
+  }
+  const report = await importAgentHubHome({
+    sourceRoot: importSourceRoot,
+    targetRoot: parsed.transferOptions.targetRoot,
+    overwrite: parsed.transferOptions.overwrite,
+    settingsMode: parsed.transferOptions.settingsMode
+  });
+  printTransferReport("Import", report);
+  process.exit(0);
+}
+if (parsed.command === "compose" || parsed.command === "new") {
+  const agentHubHome = parsed.bootstrapOptions.targetRoot || defaultAgentHubHome();
+  await ensureHomeReadyOrFail(agentHubHome);
+  const composeSelection2 = parsed.composeSelection;
+  if (!composeSelection2) {
+    fail(
+      parsed.command === "compose" ? "Use 'compose profile <name>' or 'compose bundle <name>'." : "Use 'new soul <name>', 'new skill <name>', 'new instruction <name>', 'new bundle <name>', or 'new profile <name>'."
+    );
+  }
+  const filePath = composeSelection2.kind === "profile" ? await createProfileDefinition(
+    agentHubHome,
+    composeSelection2.name,
+    parsed.profileCreateOptions
+  ) : composeSelection2.kind === "bundle" ? await createBundleDefinition(
+    agentHubHome,
+    composeSelection2.name,
+    parsed.profileCreateOptions.reservedOk
+  ) : composeSelection2.kind === "soul" ? await createSoulDefinition(
+    agentHubHome,
+    composeSelection2.name,
+    parsed.profileCreateOptions.reservedOk
+  ) : composeSelection2.kind === "skill" ? await createSkillDefinition(
+    agentHubHome,
+    composeSelection2.name,
+    parsed.profileCreateOptions.reservedOk
+  ) : await createInstructionDefinition(
+    agentHubHome,
+    composeSelection2.name,
+    parsed.profileCreateOptions.reservedOk
+  );
+  await warnIfBuiltInsDrifted(agentHubHome, await detectSetupModeForHome(agentHubHome));
+  process.stdout.write(`${filePath}
+`);
+  process.exit(0);
+}
+if (parsed.command === "plugin") {
+  if (parsed.pluginSubcommand !== "doctor") {
+    fail("Use 'plugin doctor'.");
+  }
+  const configRoot = resolvePluginConfigRoot(parsed.configRoot);
+  const runtimeInspection = await inspectRuntimeConfig(configRoot);
+  process.stdout.write(`Plugin doctor
+`);
+  process.stdout.write(`- config root: ${configRoot}
+`);
+  process.stdout.write(`- runtime file: ${runtimeInspection.runtimeConfigPath}
+`);
+  if (!runtimeInspection.ok) {
+    process.stdout.write(`- runtime config: missing or unreadable
+`);
+    process.stdout.write(`- active mode: degraded
+`);
+    process.stdout.write(`- blocked tools: call_omo_agent (safety fallback)
+`);
+    process.stdout.write(`- plan detection: disabled
+`);
+    process.stdout.write(`Next: run '${cliCommand} start auto' or compose a profile to generate agenthub-runtime.json.
+`);
+  } else {
+    const summary = summarizeRuntimeFeatureState(runtimeInspection.config);
+    process.stdout.write(`- runtime config: ok
+`);
+    process.stdout.write(`- active mode: composed runtime
+`);
+    process.stdout.write(`- blocked tools: ${Array.from(summary.blockedTools).sort().join(", ") || "(none)"}
+`);
+    process.stdout.write(`- plan detection: ${summary.planDetection?.enabled ? "enabled" : "disabled"}
+`);
+  }
+  const pluginConfigPath = path.join(configRoot, "opencode.jsonc");
+  const xdgPluginConfigPath = path.join(configRoot, "xdg", "opencode", "opencode.json");
+  let pluginRegistered = false;
+  for (const filePath of [pluginConfigPath, xdgPluginConfigPath]) {
+    const config = await readJsonIfExists(filePath);
+    if (Array.isArray(config?.plugin) && config.plugin.includes("opencode-agenthub")) {
+      pluginRegistered = true;
+      break;
+    }
+  }
+  process.stdout.write(`- plugin registered: ${pluginRegistered ? "yes" : "no"}
+`);
+  if (!pluginRegistered) {
+    process.stdout.write(`Next: compose a profile so opencode.jsonc includes 'opencode-agenthub'.
+`);
+  }
+  process.exit(0);
+}
+if (parsed.command === "upgrade") {
+  const targetRoot = resolveSelectedHomeRoot(parsed) || defaultAgentHubHome();
+  await ensureHomeReadyOrFail(targetRoot);
+  const mode = await detectSetupModeForHome(targetRoot);
+  const report = await syncBuiltInAgentHubAssets({
+    targetRoot,
+    mode,
+    force: parsed.upgradeOptions.force,
+    dryRun: parsed.upgradeOptions.dryRun
+  });
+  printUpgradeReport(targetRoot, report, parsed.upgradeOptions);
+  process.exit(0);
+}
+if ((parsed.command === "run" || parsed.command === "start") && !parsed.runtimeSelection) {
+  if (parsed.assembleOnly) {
+    fail("'run'/'start' without a profile cannot be used with '--assemble-only'.");
+  }
+  if (process.stderr.isTTY) {
+    process.stderr.write(
+      "\u26A0  No profile selected \u2014 launching plain opencode (hub runtime is inactive)\n"
+    );
+  }
+  await ensureWorkspaceReadable(parsed.workspace);
+  await runOpencode(parsed.workspace, void 0, parsed.opencodeArgs);
+  process.exit(0);
+}
+if (parsed.command === "doctor" || parsed.command === "hub-doctor") {
+  const targetRoot = parsed.bootstrapOptions.targetRoot || defaultAgentHubHome();
+  const {
+    runDiagnostics,
+    interactiveAssembly,
+    interactiveDoctor,
+    updateAgentModelOverride,
+    updateAgentPromptOverride,
+    fixMissingGuards,
+    createBundleForSoul,
+    createProfile,
+    fixOmoMixedProfile,
+    getAvailableBundles
+  } = await import("../skills/agenthub-doctor/index.js");
+  if (parsed.doctorOptions.agent) {
+    const promptFilePath = parsed.doctorOptions.promptFile;
+    const message = parsed.doctorOptions.model || parsed.doctorOptions.clearModel ? await updateAgentModelOverride(
+      targetRoot,
+      parsed.doctorOptions.agent,
+      parsed.doctorOptions.clearModel ? "" : parsed.doctorOptions.model || ""
+    ) : await updateAgentPromptOverride(
+      targetRoot,
+      parsed.doctorOptions.agent,
+      parsed.doctorOptions.clearPrompt ? "" : promptFilePath ? await readFile(promptFilePath, "utf-8") : fail(
+        "'doctor --prompt-file <path>' requires a prompt file path."
+      )
+    );
+    process.stdout.write(`${message}
+`);
+    process.exit(0);
+  }
+  process.stdout.write("\u{1F50D} Running Agent Hub diagnostics...\n\n");
+  const report = await runDiagnostics(targetRoot);
+  if (report.healthy.length > 0) {
+    process.stdout.write("\u2705 Healthy:\n");
+    for (const item of report.healthy) {
+      process.stdout.write(`  - ${item}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (report.issues.length === 0) {
+    process.stdout.write("\u2705 No issues found! Agent Hub is ready to use.\n");
+    if (parsed.doctorOptions.fixAll || parsed.doctorOptions.dryRun || !process.stdin.isTTY) {
+      process.exit(0);
+    }
+    await interactiveDoctor(targetRoot, report);
+    process.exit(0);
+  }
+  process.stdout.write("\u26A0\uFE0F  Issues Found:\n");
+  for (const issue of report.issues) {
+    const icon = issue.severity === "error" ? "\u274C" : issue.severity === "warning" ? "\u26A0\uFE0F " : "\u2139\uFE0F ";
+    process.stdout.write(`  ${icon} ${issue.message}
+`);
+  }
+  process.stdout.write("\n");
+  if (parsed.doctorOptions.dryRun) {
+    process.stdout.write("(Dry run - no fixes applied)\n");
+    process.exit(0);
+  }
+  if (parsed.doctorOptions.fixAll) {
+    process.stdout.write("\u{1F527} Applying fixes...\n\n");
+    const missingGuardsIssue = report.issues.find(
+      (i) => i.type === "missing_guards"
+    );
+    if (missingGuardsIssue) {
+      const guards = missingGuardsIssue.details.guards;
+      const result2 = await fixMissingGuards(targetRoot, guards);
+      process.stdout.write(
+        `  ${result2.success ? "\u2713" : "\u2717"} ${result2.message}
+`
+      );
+    }
+    const orphanedSoulsIssue = report.issues.find(
+      (i) => i.type === "orphaned_souls"
+    );
+    if (orphanedSoulsIssue) {
+      const souls = orphanedSoulsIssue.details.souls;
+      for (const soul of souls) {
+        const result2 = await createBundleForSoul(targetRoot, soul);
+        process.stdout.write(
+          `  ${result2.success ? "\u2713" : "\u2717"} ${result2.message}
+`
+        );
+      }
+    }
+    const noProfilesIssue = report.issues.find((i) => i.type === "no_profiles");
+    if (noProfilesIssue) {
+      const bundles = await getAvailableBundles(targetRoot);
+      if (bundles.length > 0) {
+        const result2 = await createProfile(targetRoot, "imported", {
+          bundleNames: bundles
+        });
+        process.stdout.write(
+          `  ${result2.success ? "\u2713" : "\u2717"} ${result2.message}
+`
+        );
+      }
+    }
+    const omoIssue = report.issues.find((i) => i.type === "omo_mixed_profile");
+    if (omoIssue) {
+      const result2 = await fixOmoMixedProfile(
+        targetRoot,
+        omoIssue.details
+      );
+      process.stdout.write(
+        `  ${result2.success ? "\u2713" : "\u2717"} ${result2.message}
+`
+      );
+    }
+    process.stdout.write("\n\u2705 All fixes applied!\n");
+    process.exit(0);
+  }
+  await interactiveAssembly(targetRoot, report);
+  process.exit(0);
+}
+if (parsed.command === "list") {
+  const {
+    labelSouls,
+    labelBundles,
+    labelProfiles,
+    labelSkills,
+    labelInstructions
+  } = await import("./query.js");
+  const hubHome = parsed.bootstrapOptions.targetRoot || defaultAgentHubHome();
+  const target = parsed.listTarget;
+  const printSection = (title, items) => {
+    process.stdout.write(`
+${title} (${items.length}):
+`);
+    if (items.length === 0) {
+      process.stdout.write("  (none)\n");
+    } else {
+      for (const item of items) {
+        process.stdout.write(`  ${item.name}  [${item.source}]
+`);
+      }
+    }
+  };
+  if (!target || target === "souls") {
+    printSection("Souls", await labelSouls(hubHome));
+  }
+  if (!target || target === "bundles") {
+    printSection("Bundles", await labelBundles(hubHome));
+  }
+  if (!target || target === "profiles") {
+    printSection("Profiles", await labelProfiles(hubHome));
+  }
+  if (!target || target === "skills") {
+    printSection("Skills", await labelSkills(hubHome));
+  }
+  if (!target || target === "instructions") {
+    printSection("Instructions", await labelInstructions(hubHome));
+  }
+  if (target && !["souls", "bundles", "profiles", "skills", "instructions"].includes(target)) {
+    fail(`Unknown list target '${target}'. Use: souls, bundles, profiles, skills, instructions`);
+  }
+  process.stdout.write("\n");
+  process.exit(0);
+}
+if (parsed.command === "hr") {
+  await ensureHrOfficeReadyOrBootstrap(resolveSelectedHomeRoot(parsed), {
+    syncSourcesOnFirstRun: !parsed.assembleOnly
+  });
+  if (parsed.hrIntent?.kind === "office") {
+    parsed.workspace = resolveSelectedHomeRoot(parsed) || defaultHrHome();
+  } else if (parsed.hrIntent?.kind === "compose") {
+    await warnIfWorkspaceRuntimeWillBeReplaced(
+      parsed.workspace,
+      `HR profile '${parsed.hrIntent.profile}'`
+    );
+  }
+} else if (parsed.command === "start" || parsed.command === "run") {
+  await ensureHomeReadyOrBootstrap(resolveSelectedHomeRoot(parsed));
+  await warnAboutLegacyHrAssets(resolveSelectedHomeRoot(parsed) || defaultAgentHubHome());
+} else {
+  await ensureSelectedHomeReadyOrFail(parsed);
+}
+{
+  const selectedHome = resolveSelectedHomeRoot(parsed) || defaultAgentHubHome();
+  const selectedMode = await detectInstallModeForHome(selectedHome, parsed.command === "hr");
+  await warnIfBuiltInsDrifted(selectedHome, selectedMode);
+}
+if (parsed.command === "run" || parsed.command === "start" || parsed.command === "hr") {
+  await ensureWorkspaceReadable(parsed.workspace);
+}
+const finalConfigRoot = resolveConfigRoot(parsed);
+const result = await composeSelection(parsed, finalConfigRoot);
+printRuntimeBanner(
+  parsed.command === "hr" ? "HR Office" : "My Team",
+  resolveSelectedHomeRoot(parsed) || defaultAgentHubHome()
+);
+if (shouldChmod()) {
+  await chmod(path.join(result.configRoot, "run.sh"), 493);
+}
+if ((parsed.command === "start" || parsed.command === "run") && parsed.runtimeSelection?.kind === "profile") {
+  await updateWorkspacePreferences(parsed.workspace, (current) => ({
+    ...current,
+    start: {
+      ...current.start || {},
+      lastProfile: parsed.runtimeSelection?.kind === "profile" ? parsed.runtimeSelection.profile : void 0
+    }
+  }));
+}
+if (parsed.command === "hr" && parsed.hrIntent?.kind === "compose" && parsed.runtimeSelection?.kind === "profile") {
+  await updateWorkspacePreferences(parsed.workspace, (current) => ({
+    ...current,
+    hr: {
+      ...current.hr || {},
+      lastProfile: parsed.runtimeSelection?.kind === "profile" ? parsed.runtimeSelection.profile : void 0
+    }
+  }));
+}
+if ((parsed.command === "run" || parsed.command === "start" || parsed.command === "hr" && parsed.hrIntent?.kind === "compose") && parsed.runtimeSelection?.kind === "profile" && !parsed.assembleOnly) {
+  await maybeConfigureEnvrc(parsed.workspace, result.configRoot);
+}
+if (parsed.command === "compose" || parsed.assembleOnly) {
+  process.stdout.write(`${result.configRoot}
+`);
+  process.exit(0);
+}
+await runOpencode(parsed.workspace, result.configRoot, parsed.opencodeArgs);