oh-my-opencode-slim 2.0.0-beta.9 → 2.0.1

package/dist/cli/index.js

@@ -1,32 +1,32 @@
 #!/usr/bin/env bun
 // @bun
 import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/cli/doctor.ts
-import * as fs2 from "node:fs";
-import { z as z3 } from "zod";
-
-// src/config/loader.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-// src/cli/config-io.ts
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
-  readFileSync,
-  renameSync,
-  statSync as statSync2,
-  writeFileSync
-} from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
-
 // src/utils/compat.ts
+var exports_compat = {};
+__export(exports_compat, {
+  isBun: () => isBun,
+  crossWrite: () => crossWrite,
+  crossSpawn: () => crossSpawn
+});
 import { spawn as nodeSpawn } from "node:child_process";
-var isBun = typeof globalThis.Bun !== "undefined";
+import { writeFile as fsWriteFile } from "node:fs/promises";
 function collectStream(stream) {
   if (!stream)
     return () => Promise.resolve("");
@@ -69,6 +69,124 @@ function crossSpawn(command, options) {
     }
   };
 }
+async function crossWrite(path, data) {
+  await fsWriteFile(path, Buffer.from(data));
+}
+var isBun;
+var init_compat = __esm(() => {
+  isBun = typeof globalThis.Bun !== "undefined";
+});
+
+// src/utils/zip-extractor.ts
+var exports_zip_extractor = {};
+__export(exports_zip_extractor, {
+  extractZip: () => extractZip
+});
+import { spawnSync } from "node:child_process";
+import { release } from "node:os";
+function getWindowsBuildNumber() {
+  if (process.platform !== "win32")
+    return null;
+  const parts = release().split(".");
+  if (parts.length >= 3) {
+    const build = parseInt(parts[2], 10);
+    if (!Number.isNaN(build))
+      return build;
+  }
+  return null;
+}
+function isPwshAvailable() {
+  if (process.platform !== "win32")
+    return false;
+  const result = spawnSync("where", ["pwsh"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
+function escapePowerShellPath(path2) {
+  return path2.replace(/'/g, "''");
+}
+function getWindowsZipExtractor() {
+  const buildNumber = getWindowsBuildNumber();
+  if (buildNumber !== null && buildNumber >= WINDOWS_BUILD_WITH_TAR) {
+    return "tar";
+  }
+  if (isPwshAvailable()) {
+    return "pwsh";
+  }
+  return "powershell";
+}
+async function extractZip(archivePath, destDir) {
+  let proc;
+  if (process.platform === "win32") {
+    const extractor = getWindowsZipExtractor();
+    switch (extractor) {
+      case "tar":
+        proc = crossSpawn(["tar", "-xf", archivePath, "-C", destDir], {
+          stdout: "ignore",
+          stderr: "pipe"
+        });
+        break;
+      case "pwsh":
+        proc = crossSpawn([
+          "pwsh",
+          "-Command",
+          `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
+        ], {
+          stdout: "ignore",
+          stderr: "pipe"
+        });
+        break;
+      default:
+        proc = crossSpawn([
+          "powershell",
+          "-Command",
+          `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
+        ], {
+          stdout: "ignore",
+          stderr: "pipe"
+        });
+        break;
+    }
+  } else {
+    proc = crossSpawn(["unzip", "-o", archivePath, "-d", destDir], {
+      stdout: "ignore",
+      stderr: "pipe"
+    });
+  }
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await proc.stderr();
+    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
+  }
+}
+var WINDOWS_BUILD_WITH_TAR = 17134;
+var init_zip_extractor = __esm(() => {
+  init_compat();
+});
+
+// src/cli/doctor.ts
+import * as fs2 from "node:fs";
+import { z as z3 } from "zod";
+
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/cli/config-io.ts
+init_compat();
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
 
 // src/cli/paths.ts
 import { existsSync, mkdirSync } from "node:fs";
@@ -100,7 +218,7 @@ function getConfigSearchDirs() {
   });
 }
 function getOpenCodeConfigPaths() {
-  const configDir = getDefaultOpenCodeConfigDir();
+  const configDir = getConfigDir();
   return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
 }
 function getConfigJson() {
@@ -328,11 +446,13 @@ var MultiplexerLayoutSchema = z2.enum([
   "even-horizontal",
   "even-vertical"
 ]);
+var ZellijPaneModeSchema = z2.enum(["agent-tab", "current-tab"]);
 var TmuxLayoutSchema = MultiplexerLayoutSchema;
 var MultiplexerConfigSchema = z2.object({
   type: MultiplexerTypeSchema.default("none"),
   layout: MultiplexerLayoutSchema.default("main-vertical"),
-  main_pane_size: z2.number().min(20).max(80).default(60)
+  main_pane_size: z2.number().min(20).max(80).default(60),
+  zellij_pane_mode: ZellijPaneModeSchema.default("agent-tab")
 });
 var TmuxConfigSchema = z2.object({
   enabled: z2.boolean().default(false),
@@ -343,7 +463,7 @@ var PresetSchema = z2.record(z2.string(), AgentOverrideConfigSchema);
 var WebsearchConfigSchema = z2.object({
   provider: z2.enum(["exa", "tavily"]).default("exa")
 });
-var McpNameSchema = z2.enum(["websearch", "context7", "grep_app"]);
+var McpNameSchema = z2.enum(["websearch", "context7", "gh_grep"]);
 var InterviewConfigSchema = z2.object({
   maxQuestions: z2.number().int().min(1).max(10).default(2),
   outputFolder: z2.string().min(1).default("interview"),
@@ -351,28 +471,11 @@ var InterviewConfigSchema = z2.object({
   port: z2.number().int().min(0).max(65535).default(0),
   dashboard: z2.boolean().default(false)
 });
-var SessionManagerConfigSchema = z2.object({
+var BackgroundJobsConfigSchema = z2.object({
   maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
   readContextMinLines: z2.number().int().min(0).max(1000).default(10),
   readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
 });
-var DivoomConfigSchema = z2.object({
-  enabled: z2.boolean().default(false),
-  python: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/.venv/bin/python"),
-  script: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/tools/divoom_send.py"),
-  size: z2.number().int().min(1).max(1024).default(128),
-  fps: z2.number().int().min(1).max(60).default(8),
-  speed: z2.number().int().min(1).max(1e4).default(125),
-  maxFrames: z2.number().int().min(1).max(500).default(24),
-  posterizeBits: z2.number().int().min(1).max(8).default(3),
-  gifs: z2.record(z2.string(), z2.string().min(1)).optional()
-});
-var TodoContinuationConfigSchema = z2.object({
-  maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
-  cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
-  autoEnable: z2.boolean().default(false).describe("Automatically enable auto-continue when the orchestrator session has enough todos"),
-  autoEnableThreshold: z2.number().int().min(1).max(50).default(4).describe("Number of todos that triggers auto-enable (only used when autoEnable is true)")
-});
 var FailoverConfigSchema = z2.object({
   enabled: z2.boolean().default(true),
   timeoutMs: z2.number().min(0).default(15000),
@@ -380,6 +483,11 @@ var FailoverConfigSchema = z2.object({
   chains: FallbackChainsSchema.default({}),
   retry_on_empty: z2.boolean().default(true).describe("When true (default), empty provider responses are treated as failures, " + "triggering fallback/retry. Set to false to treat them as successes.")
 });
+var CompanionConfigSchema = z2.object({
+  enabled: z2.boolean().optional(),
+  position: z2.enum(["bottom-right", "bottom-left", "top-right", "top-left"]).optional(),
+  size: z2.enum(["small", "medium", "large"]).optional()
+});
 function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
   for (const [name, override] of Object.entries(overrides)) {
     const isBuiltInOrAlias = ALL_AGENT_NAMES.includes(name) || AGENT_ALIASES[name] !== undefined;
@@ -417,11 +525,10 @@ var PluginConfigSchema = z2.object({
   tmux: TmuxConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   interview: InterviewConfigSchema.optional(),
-  sessionManager: SessionManagerConfigSchema.optional(),
-  divoom: DivoomConfigSchema.optional(),
-  todoContinuation: TodoContinuationConfigSchema.optional(),
+  backgroundJobs: BackgroundJobsConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
-  council: CouncilConfigSchema.optional()
+  council: CouncilConfigSchema.optional(),
+  companion: CompanionConfigSchema.optional()
 }).superRefine((value, ctx) => {
   if (value.agents) {
     validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
@@ -437,7 +544,7 @@ var DEFAULT_AGENT_MCPS = {
   orchestrator: ["*", "!context7"],
   designer: [],
   oracle: [],
-  librarian: ["websearch", "context7", "grep_app"],
+  librarian: ["websearch", "context7", "gh_grep"],
   explorer: [],
   fixer: [],
   observer: [],
@@ -479,6 +586,12 @@ var CUSTOM_SKILLS = [
     description: "Heavy/complex coding sessions and large modifications workflow",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/deepwork"
+  },
+  {
+    name: "oh-my-opencode-slim",
+    description: "Configure, customize, and safely improve oh-my-opencode-slim setups",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/oh-my-opencode-slim"
   }
 ];
 function getCustomSkillsDir() {
@@ -526,12 +639,12 @@ var SCHEMA_URL = "https://unpkg.com/oh-my-opencode-slim@latest/oh-my-opencode-sl
 var GENERATED_PRESETS = ["openai", "opencode-go"];
 var MODEL_MAPPINGS = {
   openai: {
-    orchestrator: { model: "openai/gpt-5.5" },
+    orchestrator: { model: "openai/gpt-5.5", variant: "medium" },
     oracle: { model: "openai/gpt-5.5", variant: "high" },
     librarian: { model: "openai/gpt-5.4-mini", variant: "low" },
     explorer: { model: "openai/gpt-5.4-mini", variant: "low" },
     designer: { model: "openai/gpt-5.4-mini", variant: "medium" },
-    fixer: { model: "openai/gpt-5.4-mini", variant: "low" }
+    fixer: { model: "openai/gpt-5.5", variant: "low" }
   },
   kimi: {
     orchestrator: { model: "kimi-for-coding/k2p5" },
@@ -620,11 +733,24 @@ function generateLiteConfig(installConfig) {
       main_pane_size: 60
     };
   }
+  if (installConfig.companion === "yes") {
+    config.companion = {
+      enabled: true,
+      position: "bottom-right",
+      size: "medium"
+    };
+  }
   return config;
 }
 
 // src/cli/config-io.ts
 var PACKAGE_NAME = "oh-my-opencode-slim";
+var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = [
+  "build",
+  "explore",
+  "general",
+  "plan"
+];
 function isString(value) {
   return typeof value === "string";
 }
@@ -705,17 +831,63 @@ function getPluginEntry() {
     return PACKAGE_NAME;
   }
 }
-function getOpenCodePluginCacheDir() {
+function getPinnedVersionFromConfig() {
+  try {
+    const { config } = parseConfig(getExistingConfigPath());
+    if (!config)
+      return;
+    for (const entry of getPlugins(config)) {
+      const spec = getPluginSpec(entry);
+      if (!spec)
+        continue;
+      if (spec === PACKAGE_NAME)
+        return;
+      if (spec.startsWith(`${PACKAGE_NAME}@`)) {
+        const version = spec.slice(PACKAGE_NAME.length + 1);
+        if (version && version !== "latest")
+          return version;
+      }
+    }
+  } catch {}
+  return;
+}
+function getRequestedPackageTag(packageRoot) {
+  const normalizedPath = normalizePathForMatch(packageRoot);
+  const marker = `/bunx-`;
+  const markerIndex = normalizedPath.lastIndexOf(marker);
+  if (markerIndex === -1)
+    return;
+  const bunxSegment = normalizedPath.slice(markerIndex + marker.length).split("/")[0];
+  const packagePrefix = `${PACKAGE_NAME}@`;
+  const packageIndex = bunxSegment.lastIndexOf(packagePrefix);
+  if (packageIndex === -1)
+    return;
+  const tag = bunxSegment.slice(packageIndex + packagePrefix.length);
+  return tag || undefined;
+}
+function getVersionFromPackageRoot(packageRoot) {
+  try {
+    const packageJsonPath = join3(packageRoot, "package.json");
+    if (!existsSync3(packageJsonPath))
+      return;
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return;
+  }
+}
+function getOpenCodePluginCacheDir(version) {
   const cacheDir = process.env.XDG_CACHE_HOME?.trim() || join3(homedir2(), ".cache");
-  return join3(cacheDir, "opencode", "packages", `${PACKAGE_NAME}@latest`);
+  const suffix = version ? `${PACKAGE_NAME}@${version}` : `${PACKAGE_NAME}@latest`;
+  return join3(cacheDir, "opencode", "packages", suffix);
 }
-function writeOpenCodePluginCacheManifest(cacheDir) {
+function writeOpenCodePluginCacheManifest(cacheDir, version = "latest") {
   try {
     writeFileSync(join3(cacheDir, "package.json"), JSON.stringify({
       name: `${PACKAGE_NAME}-cache`,
       private: true,
       dependencies: {
-        [PACKAGE_NAME]: "latest"
+        [PACKAGE_NAME]: version
       }
     }, null, 2));
     return null;
@@ -727,6 +899,14 @@ function writeOpenCodePluginCacheManifest(cacheDir) {
     };
   }
 }
+function removeOpenCodePluginCacheArtifacts(cacheDir) {
+  rmSync(join3(cacheDir, "node_modules", PACKAGE_NAME), {
+    recursive: true,
+    force: true
+  });
+  rmSync(join3(cacheDir, "bun.lock"), { force: true });
+  rmSync(join3(cacheDir, "bun.lockb"), { force: true });
+}
 function verifyOpenCodePluginCache(cacheDir) {
   const pluginPackageJsonPath = join3(cacheDir, "node_modules", PACKAGE_NAME, "package.json");
   if (!existsSync3(pluginPackageJsonPath)) {
@@ -763,7 +943,11 @@ async function warmOpenCodePluginCache() {
   if (!packageRoot || !isPackageManagerInstall(packageRoot)) {
     return null;
   }
-  const cacheDir = getOpenCodePluginCacheDir();
+  const pinnedVersion = getPinnedVersionFromConfig();
+  const runningVersion = getVersionFromPackageRoot(packageRoot);
+  const requestedTag = getRequestedPackageTag(packageRoot);
+  const cacheVersion = pinnedVersion ?? requestedTag ?? runningVersion;
+  const cacheDir = getOpenCodePluginCacheDir(cacheVersion);
   try {
     mkdirSync3(cacheDir, { recursive: true });
   } catch (err) {
@@ -773,9 +957,10 @@ async function warmOpenCodePluginCache() {
       error: `Failed to create OpenCode cache directory: ${err}`
     };
   }
-  const manifestError = writeOpenCodePluginCacheManifest(cacheDir);
+  const manifestError = writeOpenCodePluginCacheManifest(cacheDir, cacheVersion);
   if (manifestError)
     return manifestError;
+  removeOpenCodePluginCacheArtifacts(cacheDir);
   try {
     const proc = crossSpawn(["bun", "install", "--ignore-scripts"], {
       cwd: cacheDir,
@@ -956,8 +1141,13 @@ function disableDefaultAgents() {
     }
     const config = parsedConfig ?? {};
     const agent = config.agent ?? {};
-    agent.explore = { disable: true };
-    agent.general = { disable: true };
+    for (const agentName of DEFAULT_OPENCODE_AGENTS_TO_DISABLE) {
+      const existing = agent[agentName];
+      agent[agentName] = {
+        ...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {},
+        disable: true
+      };
+    }
     config.agent = agent;
     writeConfig(configPath, config);
     return { success: true, configPath };
@@ -1085,10 +1275,10 @@ function mergePluginConfigs(base, override) {
     tmux: deepMerge(base.tmux, override.tmux),
     multiplexer: deepMerge(base.multiplexer, override.multiplexer),
     interview: deepMerge(base.interview, override.interview),
-    sessionManager: deepMerge(base.sessionManager, override.sessionManager),
-    divoom: deepMerge(base.divoom, override.divoom),
+    backgroundJobs: deepMerge(base.backgroundJobs, override.backgroundJobs),
     fallback: deepMerge(base.fallback, override.fallback),
-    council: deepMerge(base.council, override.council)
+    council: deepMerge(base.council, override.council),
+    companion: deepMerge(base.companion, override.companion)
   };
 }
 function deepMerge(base, override) {
@@ -1304,16 +1494,253 @@ Options:
 }
 
 // src/cli/install.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { createInterface } from "node:readline/promises";
+
+// src/cli/background-subagents.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname4, join as join5 } from "node:path";
+var ENV_NAME = "OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS";
+var START_MARKER = "# >>> oh-my-opencode-slim background subagents >>>";
+var END_MARKER = "# <<< oh-my-opencode-slim background subagents <<<";
+function isBackgroundSubagentsEnabled(value) {
+  if (!value)
+    return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && !["0", "false", "no", "off"].includes(normalized);
+}
+function detectShellKind(shell) {
+  const name = shell?.split("/").at(-1);
+  if (name === "zsh" || name === "bash" || name === "fish")
+    return name;
+  return;
+}
+function detectBackgroundSubagentsTarget(env = process.env) {
+  const shell = detectShellKind(env.SHELL);
+  const home = env.HOME || homedir3();
+  if (shell === "zsh")
+    return join5(home, ".zshrc");
+  if (shell === "bash")
+    return join5(home, ".bashrc");
+  if (shell === "fish") {
+    const configHome = env.XDG_CONFIG_HOME || join5(home, ".config");
+    return join5(configHome, "fish", "conf.d", "opencode-background-subagents.fish");
+  }
+  return;
+}
+function getBackgroundSubagentsBlock(targetPath) {
+  const isFish = targetPath.endsWith(".fish");
+  const command = isFish ? `set -gx ${ENV_NAME} true` : `export ${ENV_NAME}=true`;
+  return `${START_MARKER}
+${command}
+${END_MARKER}`;
+}
+function manualBackgroundSubagentsInstructions(options) {
+  const shell = options?.shell ?? (options?.targetPath?.endsWith(".fish") ? "fish" : undefined) ?? detectShellKind(options?.targetPath);
+  const bashZshSnippet = `export ${ENV_NAME}=true`;
+  const fishSnippet = `set -gx ${ENV_NAME} true`;
+  if (shell === "fish") {
+    return `Start OpenCode with background subagents enabled:
+  env ${ENV_NAME}=true opencode
+
+Or add this to your fish startup file:
+  ${fishSnippet}`;
+  }
+  if (shell === "bash" || shell === "zsh") {
+    return `Start OpenCode with background subagents enabled:
+  ${ENV_NAME}=true opencode
+
+Or add this to your shell startup file:
+  ${bashZshSnippet}`;
+  }
+  return `Start OpenCode with background subagents enabled:
+  ${ENV_NAME}=true opencode
+
+Or add one of these to your shell startup file:
+  bash/zsh: ${bashZshSnippet}
+  fish: ${fishSnippet}`;
+}
+function expandHomePath(targetPath) {
+  if (targetPath === "~")
+    return homedir3();
+  if (targetPath.startsWith("~/"))
+    return join5(homedir3(), targetPath.slice(2));
+  return targetPath;
+}
+function upsertBackgroundSubagentsBlock(content, block) {
+  const start = content.indexOf(START_MARKER);
+  const end = content.indexOf(END_MARKER);
+  if (start !== -1 && end !== -1 && end > start) {
+    const afterEnd = end + END_MARKER.length;
+    return `${content.slice(0, start)}${block}${content.slice(afterEnd)}`;
+  }
+  const separator = content.length > 0 && !content.endsWith(`
+`) ? `
+
+` : "";
+  const prefix = content.length > 0 && content.endsWith(`
+`) ? `
+` : separator;
+  return `${content}${prefix}${block}
+`;
+}
+function writeBackgroundSubagentsBlock(targetPath) {
+  const block = getBackgroundSubagentsBlock(targetPath);
+  const content = existsSync5(targetPath) ? readFileSync4(targetPath, "utf8") : "";
+  const nextContent = upsertBackgroundSubagentsBlock(content, block);
+  mkdirSync4(dirname4(targetPath), { recursive: true });
+  writeFileSync2(targetPath, nextContent);
+}
+
+// src/cli/companion.ts
+import {
+  chmodSync,
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  mkdtempSync,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir4, tmpdir } from "node:os";
+import * as path2 from "node:path";
+var COMPANION_VERSION = "0.1.0";
+var COMPANION_TAG = "companion-v0.1.0";
+var GITHUB_REPO = "alvinunreal/oh-my-opencode-slim";
+function getCompanionTarget() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === "darwin") {
+    if (a === "arm64")
+      return "aarch64-apple-darwin";
+    if (a === "x64")
+      return "x86_64-apple-darwin";
+  } else if (p === "linux") {
+    if (a === "x64")
+      return "x86_64-unknown-linux-gnu";
+    if (a === "arm64")
+      return "aarch64-unknown-linux-gnu";
+  } else if (p === "win32") {
+    if (a === "x64")
+      return "x86_64-pc-windows-msvc";
+  }
+  return null;
+}
+function getCompanionBinaryPath() {
+  const xdg = process.env.XDG_DATA_HOME?.trim();
+  const base = xdg && path2.isAbsolute(xdg) ? xdg : path2.join(homedir4(), ".local", "share");
+  return path2.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", process.platform === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion");
+}
+async function installCompanion(config) {
+  const target = getCompanionTarget();
+  const finalBinaryPath = getCompanionBinaryPath();
+  if (!target) {
+    return {
+      success: false,
+      configPath: finalBinaryPath,
+      error: `Unsupported platform/architecture: ${process.platform} ${process.arch}`
+    };
+  }
+  const isWindows = process.platform === "win32";
+  const ext = isWindows ? "zip" : "tar.gz";
+  const archiveName = `oh-my-opencode-slim-companion-v${COMPANION_VERSION}-${target}.${ext}`;
+  const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/${COMPANION_TAG}/${archiveName}`;
+  if (config.dryRun) {
+    console.log(`  [dry-run] Detected companion target: ${target}`);
+    console.log(`  [dry-run] Would download archive: ${downloadUrl}`);
+    console.log(`  [dry-run] Would extract and install to: ${finalBinaryPath}`);
+    return {
+      success: true,
+      configPath: finalBinaryPath
+    };
+  }
+  let buffer;
+  try {
+    const res = await fetch(downloadUrl);
+    if (!res.ok) {
+      return {
+        success: false,
+        configPath: finalBinaryPath,
+        error: `Failed to download companion binary (HTTP ${res.status}): ${res.statusText}`
+      };
+    }
+    buffer = await res.arrayBuffer();
+  } catch (err) {
+    return {
+      success: false,
+      configPath: finalBinaryPath,
+      error: `Failed to fetch companion archive: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let tempDir = "";
+  try {
+    tempDir = mkdtempSync(path2.join(tmpdir(), "companion-install-"));
+    const archivePath = path2.join(tempDir, archiveName);
+    writeFileSync3(archivePath, Buffer.from(buffer));
+    const extractedDir = path2.join(tempDir, "extracted");
+    mkdirSync5(extractedDir, { recursive: true });
+    if (isWindows) {
+      const { extractZip: extractZip2 } = await Promise.resolve().then(() => (init_zip_extractor(), exports_zip_extractor));
+      await extractZip2(archivePath, extractedDir);
+    } else {
+      const { crossSpawn: crossSpawn2 } = await Promise.resolve().then(() => (init_compat(), exports_compat));
+      const proc = crossSpawn2(["tar", "-xzf", archivePath, "-C", extractedDir]);
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await proc.stderr();
+        return {
+          success: false,
+          configPath: finalBinaryPath,
+          error: `Archive extraction failed (tar exited with ${exitCode}): ${stderr}`
+        };
+      }
+    }
+    const binaryName = isWindows ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion";
+    const extractedBinaryPath = path2.join(extractedDir, binaryName);
+    if (!existsSync6(extractedBinaryPath)) {
+      return {
+        success: false,
+        configPath: finalBinaryPath,
+        error: `Binary ${binaryName} not found in extracted archive`
+      };
+    }
+    const binDir = path2.dirname(finalBinaryPath);
+    mkdirSync5(binDir, { recursive: true });
+    const tmpFinalPath = `${finalBinaryPath}.tmp`;
+    copyFileSync3(extractedBinaryPath, tmpFinalPath);
+    if (!isWindows) {
+      chmodSync(tmpFinalPath, 493);
+    }
+    renameSync2(tmpFinalPath, finalBinaryPath);
+    return {
+      success: true,
+      configPath: finalBinaryPath
+    };
+  } catch (err) {
+    return {
+      success: false,
+      configPath: finalBinaryPath,
+      error: `Failed to install companion: ${err instanceof Error ? err.message : String(err)}`
+    };
+  } finally {
+    if (tempDir) {
+      try {
+        rmSync2(tempDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+}
 // src/cli/system.ts
-import { spawnSync } from "node:child_process";
+init_compat();
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { statSync as statSync4 } from "node:fs";
 var cachedOpenCodePath = null;
 function resolvePathCommand(command) {
   try {
     const resolver = process.platform === "win32" ? "where" : "which";
-    const result = spawnSync(resolver, [command], {
+    const result = spawnSync2(resolver, [command], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -1328,7 +1755,7 @@ function resolvePathCommand(command) {
 }
 function canExecute(command, args) {
   try {
-    const result = spawnSync(command, args, {
+    const result = spawnSync2(command, args, {
       stdio: "ignore"
     });
     return result.status === 0;
@@ -1430,8 +1857,8 @@ async function getOpenCodeVersion() {
   return null;
 }
 function getOpenCodePath() {
-  const path2 = resolveOpenCodePath();
-  return path2 === "opencode" ? null : path2;
+  const path3 = resolveOpenCodePath();
+  return path3 === "opencode" ? null : path3;
 }
 // src/cli/install.ts
 var GREEN = "\x1B[32m";
@@ -1450,8 +1877,8 @@ var SYMBOLS = {
   warn: `${YELLOW}[!]${RESET}`,
   star: `${YELLOW}★${RESET}`
 };
-var GITHUB_REPO = "alvinunreal/oh-my-opencode-slim";
-var GITHUB_URL = `https://github.com/${GITHUB_REPO}`;
+var GITHUB_REPO2 = "alvinunreal/oh-my-opencode-slim";
+var GITHUB_URL = `https://github.com/${GITHUB_REPO2}`;
 function printHeader(isUpdate) {
   console.log();
   console.log(`${BOLD}oh-my-opencode-slim ${isUpdate ? "Update" : "Install"}${RESET}`);
@@ -1467,6 +1894,9 @@ function printSuccess(message) {
 function printError(message) {
   console.log(`${SYMBOLS.cross} ${RED}${message}${RESET}`);
 }
+function printWarning(message) {
+  console.log(`${SYMBOLS.warn} ${YELLOW}${message}${RESET}`);
+}
 function printInfo(message) {
   console.log(`${SYMBOLS.info} ${message}`);
 }
@@ -1491,7 +1921,7 @@ async function askToStarRepo(config) {
     return;
   try {
     const { execFileSync } = await import("node:child_process");
-    execFileSync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${GITHUB_REPO}`], { stdio: "ignore", timeout: 1e4 });
+    execFileSync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${GITHUB_REPO2}`], { stdio: "ignore", timeout: 1e4 });
     printSuccess("Thanks for starring! ★");
   } catch {
     printInfo(`Couldn't star automatically. You can star manually:
@@ -1511,11 +1941,88 @@ async function checkOpenCodeInstalled() {
     return { ok: false };
   }
   const version = await getOpenCodeVersion();
-  const path2 = getOpenCodePath();
+  const path3 = getOpenCodePath();
   const detectedVersion = version ?? "";
-  const pathInfo = path2 ? ` (${DIM}${path2}${RESET})` : "";
+  const pathInfo = path3 ? ` (${DIM}${path3}${RESET})` : "";
   printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
-  return { ok: true, version: version ?? undefined, path: path2 ?? undefined };
+  return { ok: true, version: version ?? undefined, path: path3 ?? undefined };
+}
+async function configureBackgroundSubagents(config) {
+  if (isBackgroundSubagentsEnabled(process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS)) {
+    printSuccess("OpenCode background subagents already enabled in environment");
+    return { enabledNow: true };
+  }
+  const target = config.backgroundSubagentsTarget !== undefined ? expandHomePath(config.backgroundSubagentsTarget) : detectBackgroundSubagentsTarget();
+  if (config.backgroundSubagents === "no") {
+    printInfo("OpenCode background subagents shell setup skipped.");
+    console.log(manualBackgroundSubagentsInstructions({ targetPath: target }));
+    return { enabledNow: false };
+  }
+  if (!target) {
+    printInfo("No safe shell startup file detected.");
+    console.log(manualBackgroundSubagentsInstructions());
+    return { enabledNow: false };
+  }
+  const block = getBackgroundSubagentsBlock(target);
+  if (config.dryRun) {
+    printInfo("Dry run mode - background subagents block that would be written:");
+    console.log(`Target: ${target}`);
+    console.log(`
+${block}
+`);
+    return { enabledNow: false, configuredTarget: target };
+  }
+  if (config.backgroundSubagents === "ask") {
+    if (!process.stdin.isTTY) {
+      printInfo("Skipped background subagents shell setup in non-TTY mode.");
+      console.log(manualBackgroundSubagentsInstructions({ targetPath: target }));
+      return { enabledNow: false };
+    }
+    console.log();
+    printInfo("V2 requires OpenCode background subagents for default orchestration.");
+    printInfo(`The installer can add the required environment export to ${target}.`);
+    const shouldWrite = await confirm("Add OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true now?", true);
+    if (!shouldWrite) {
+      printInfo("Skipped background subagents shell setup.");
+      console.log(manualBackgroundSubagentsInstructions({ targetPath: target }));
+      return { enabledNow: false };
+    }
+  }
+  try {
+    writeBackgroundSubagentsBlock(target);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Could not write background subagents shell config: ${message}`);
+    printInfo("Add the setting manually instead:");
+    console.log(manualBackgroundSubagentsInstructions({ targetPath: target }));
+    return { enabledNow: false };
+  }
+  printSuccess(`Background subagents enabled ${SYMBOLS.arrow} ${DIM}${target}${RESET}`);
+  return { enabledNow: false, configuredTarget: target };
+}
+async function shouldInstallCompanion(config) {
+  if (config.companion === "yes")
+    return true;
+  if (config.companion === "no")
+    return false;
+  if (config.dryRun) {
+    printInfo("Dry run mode - would ask to install the desktop companion (default: yes).");
+    config.companion = "yes";
+    return true;
+  }
+  if (!process.stdin.isTTY) {
+    printInfo("Skipped desktop companion prompt in non-TTY mode. Use --companion=yes to install it.");
+    config.companion = "no";
+    return false;
+  }
+  console.log();
+  printInfo("The optional desktop companion shows live agent activity.");
+  const shouldInstall = await confirm("Install and enable the desktop companion?", true);
+  config.companion = shouldInstall ? "yes" : "no";
+  if (!shouldInstall) {
+    printInfo("Desktop companion install skipped.");
+  }
+  return shouldInstall;
 }
 function handleStepResult(result, successMsg) {
   if (!result.success) {
@@ -1525,13 +2032,24 @@ function handleStepResult(result, successMsg) {
   printSuccess(`${successMsg} ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`);
   return true;
 }
+function handleOptionalCompanionResult(result) {
+  if (result.success) {
+    printSuccess(`Companion installed ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`);
+    return;
+  }
+  printWarning(`Desktop companion install skipped: ${result.error}`);
+  printInfo("The desktop companion is optional; continuing plugin installation without it.");
+}
 async function runInstall(config) {
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
-  let totalSteps = 6;
+  const companionInstall = await shouldInstallCompanion(config);
+  let totalSteps = 7;
   if (config.installCustomSkills)
     totalSteps += 1;
+  if (companionInstall)
+    totalSteps += 1;
   totalSteps += 1;
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
@@ -1590,6 +2108,15 @@ async function runInstall(config) {
     if (!handleStepResult(lspResult, "LSP enabled"))
       return 1;
   }
+  printStep(step++, totalSteps, "Configuring OpenCode background subagents...");
+  const backgroundSubagents = await configureBackgroundSubagents(config);
+  if (companionInstall) {
+    printStep(step++, totalSteps, "Installing desktop companion binary...");
+    const companionResult = await installCompanion(config);
+    handleOptionalCompanionResult(companionResult);
+    if (!companionResult.success)
+      config.companion = "no";
+  }
   printStep(step++, totalSteps, "Writing oh-my-opencode-slim configuration...");
   if (config.dryRun) {
     const liteConfig = generateLiteConfig(config);
@@ -1599,7 +2126,7 @@ ${JSON.stringify(liteConfig, null, 2)}
 `);
   } else {
     const configPath2 = getExistingLiteConfigPath();
-    const configExists = existsSync5(configPath2);
+    const configExists = existsSync7(configPath2);
     if (configExists && !config.reset) {
       printInfo(`Configuration already exists at ${configPath2}. Use --reset to overwrite.`);
     } else {
@@ -1646,7 +2173,15 @@ ${JSON.stringify(liteConfig, null, 2)}
   console.log(`     ${BLUE}${configPath}${RESET}`);
   console.log();
   console.log("  4. Start OpenCode:");
-  console.log(`     ${BLUE}$ opencode${RESET}`);
+  if (backgroundSubagents.enabledNow) {
+    console.log(`     ${BLUE}$ opencode${RESET}`);
+  } else if (backgroundSubagents.configuredTarget) {
+    console.log(`     ${BLUE}$ source ${backgroundSubagents.configuredTarget}${RESET}`);
+    console.log(`     ${BLUE}$ opencode${RESET}`);
+    console.log(`     ${DIM}Or restart your terminal before running opencode.${RESET}`);
+  } else {
+    console.log(`     ${BLUE}$ OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true opencode${RESET}`);
+  }
   console.log();
   console.log("  5. Verify the agents are responding:");
   console.log(`     ${BLUE}> ping all agents${RESET}`);
@@ -1668,7 +2203,10 @@ async function install(args) {
     preset: args.preset,
     promptForStar: args.tui,
     dryRun: args.dryRun,
-    reset: args.reset ?? false
+    reset: args.reset ?? false,
+    backgroundSubagents: args.backgroundSubagents ?? "ask",
+    backgroundSubagentsTarget: args.backgroundSubagentsTarget,
+    companion: args.companion
   };
   return runInstall(config);
 }
@@ -1686,13 +2224,21 @@ function getGeneratedPresetNames2() {
 function parseArgs(args) {
   const result = {
     tui: true,
-    skills: "yes"
+    skills: "yes",
+    companion: "ask"
   };
   for (const arg of args) {
     if (arg === "--no-tui") {
       result.tui = false;
     } else if (arg.startsWith("--skills=")) {
       result.skills = arg.split("=")[1];
+    } else if (arg.startsWith("--companion=")) {
+      const mode = arg.split("=")[1];
+      if (!["ask", "yes", "no"].includes(mode)) {
+        console.error("Unsupported --companion value: use ask, yes, or no");
+        process.exit(1);
+      }
+      result.companion = mode;
     } else if (arg.startsWith("--preset=")) {
       const preset = arg.split("=")[1];
       if (!isGeneratedPresetName2(preset)) {
@@ -1700,6 +2246,15 @@ function parseArgs(args) {
         process.exit(1);
       }
       result.preset = preset;
+    } else if (arg.startsWith("--background-subagents=")) {
+      const mode = arg.split("=")[1];
+      if (!["ask", "yes", "no"].includes(mode)) {
+        console.error("Unsupported --background-subagents value: use ask, yes, or no");
+        process.exit(1);
+      }
+      result.backgroundSubagents = mode;
+    } else if (arg.startsWith("--background-subagents-target=")) {
+      result.backgroundSubagentsTarget = arg.split("=")[1];
     } else if (arg === "--dry-run") {
       result.dryRun = true;
     } else if (arg === "--reset") {
@@ -1709,6 +2264,7 @@ function parseArgs(args) {
       process.exit(0);
     }
   }
+  result.backgroundSubagents ??= "ask";
   return result;
 }
 function printHelp() {
@@ -1721,7 +2277,14 @@ Usage:
 
 Options:
   --skills=yes|no        Install bundled skills (default: yes)
+  --companion=ask|yes|no Install desktop companion binary and enable config
+                         (default: ask; prompt defaults to yes)
   --preset=<name>        Active generated config preset (default: openai)
+  --background-subagents=ask|yes|no
+                          Persist required OpenCode background subagent env
+                          (default: ask; prompt defaults to yes)
+  --background-subagents-target=<path>
+                          Shell startup file to update
   --no-tui               Non-interactive mode
   --dry-run              Simulate install without writing files
   --reset                Force overwrite of existing configuration
@@ -1739,6 +2302,7 @@ For the full config reference, see docs/configuration.md.
 Examples:
   bunx oh-my-opencode-slim install
   bunx oh-my-opencode-slim install --no-tui --skills=yes
+  bunx oh-my-opencode-slim install --background-subagents=yes
   bunx oh-my-opencode-slim install --preset=opencode-go
   bunx oh-my-opencode-slim install --reset
   bunx oh-my-opencode-slim doctor
@@ -1764,7 +2328,12 @@ async function main() {
     process.exit(1);
   }
 }
-main().catch((err) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});
+if (__require.main == __require.module) {
+  main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}
+export {
+  parseArgs
+};