oh-my-opencode-slim 2.0.1 → 2.0.3

package/dist/cli/index.js

@@ -19,14 +19,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/utils/compat.ts
-var exports_compat = {};
-__export(exports_compat, {
-  isBun: () => isBun,
-  crossWrite: () => crossWrite,
-  crossSpawn: () => crossSpawn
-});
 import { spawn as nodeSpawn } from "node:child_process";
-import { writeFile as fsWriteFile } from "node:fs/promises";
 function collectStream(stream) {
   if (!stream)
     return () => Promise.resolve("");
@@ -69,13 +62,7 @@ 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";
-});
+var init_compat = () => {};
 
 // src/utils/zip-extractor.ts
 var exports_zip_extractor = {};
@@ -306,11 +293,11 @@ var SUBAGENT_NAMES = [
   "council",
   "councillor"
 ];
-var ORCHESTRATOR_NAME = "orchestrator";
-var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var ALL_AGENT_NAMES = ["orchestrator", ...SUBAGENT_NAMES];
 var PROTECTED_AGENTS = new Set(["orchestrator", "councillor"]);
-var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
+var PHASE_REMINDER = `<internal_reminder>${PHASE_REMINDER_TEXT}</internal_reminder>`;
 // src/config/council-schema.ts
 import { z } from "zod";
 var ModelIdSchema = z.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.4-mini")');
@@ -357,17 +344,11 @@ var CouncilConfigSchema = z.object({
   default_preset: z.string().default("default"),
   councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
   councillor_retries: z.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries."),
-  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly."),
-  master_timeout: z.unknown().optional().describe('DEPRECATED — ignored. Use "timeout" instead.'),
-  master_fallback: z.unknown().optional().describe("DEPRECATED — ignored. No separate master session.")
+  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly.")
 }).transform((data) => {
   const deprecated = [];
   if (data.master !== undefined)
     deprecated.push("master");
-  if (data.master_timeout !== undefined)
-    deprecated.push("master_timeout");
-  if (data.master_fallback !== undefined)
-    deprecated.push("master_fallback");
   const legacyMasterModel = typeof data.master === "object" && data.master !== null && "model" in data.master && typeof data.master.model === "string" ? data.master.model : undefined;
   return {
     presets: data.presets,
@@ -409,15 +390,6 @@ var ManualPlanSchema = z2.object({
   librarian: ManualAgentPlanSchema,
   fixer: ManualAgentPlanSchema
 }).strict();
-var AgentModelChainSchema = z2.array(z2.string()).min(1);
-var FallbackChainsSchema = z2.object({
-  orchestrator: AgentModelChainSchema.optional(),
-  oracle: AgentModelChainSchema.optional(),
-  designer: AgentModelChainSchema.optional(),
-  explorer: AgentModelChainSchema.optional(),
-  librarian: AgentModelChainSchema.optional(),
-  fixer: AgentModelChainSchema.optional()
-}).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = z2.object({
   model: z2.union([
     z2.string(),
@@ -480,14 +452,32 @@ var FailoverConfigSchema = z2.object({
   enabled: z2.boolean().default(true),
   timeoutMs: z2.number().min(0).default(15000),
   retryDelayMs: z2.number().min(0).default(500),
-  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.")
-});
+}).strict();
 var CompanionConfigSchema = z2.object({
   enabled: z2.boolean().optional(),
+  binaryPath: z2.string().min(1).optional().describe("Path to a custom companion binary to launch."),
   position: z2.enum(["bottom-right", "bottom-left", "top-right", "top-left"]).optional(),
-  size: z2.enum(["small", "medium", "large"]).optional()
+  size: z2.enum(["small", "medium", "large"]).optional(),
+  gifPack: z2.enum(["default"]).optional().describe("Bundled companion animation pack to use."),
+  loopStyle: z2.enum(["classic", "smooth"]).optional().describe("Companion animation playback style: classic loops or smooth ping-pong playback."),
+  speed: z2.number().min(0.25).max(4).optional().describe("Companion animation playback speed multiplier. Defaults to 1."),
+  debug: z2.boolean().optional().describe("Enable verbose native companion debug logs.")
 });
+var AcpAgentPermissionModeSchema = z2.enum(["ask", "allow", "reject"]);
+var AcpAgentConfigSchema = z2.object({
+  command: z2.string().min(1),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string(), z2.string()).default({}),
+  cwd: z2.string().min(1).optional(),
+  description: z2.string().min(1).optional(),
+  prompt: z2.string().min(1).optional(),
+  orchestratorPrompt: z2.string().min(1).optional(),
+  wrapperModel: ProviderModelIdSchema.optional(),
+  timeoutMs: z2.number().int().min(1000).max(900000).default(300000),
+  permissionMode: AcpAgentPermissionModeSchema.default("ask")
+}).strict();
+var AcpAgentsConfigSchema = z2.record(z2.string(), AcpAgentConfigSchema);
 function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
   for (const [name, override] of Object.entries(overrides)) {
     const isBuiltInOrAlias = ALL_AGENT_NAMES.includes(name) || AGENT_ALIASES[name] !== undefined;
@@ -513,10 +503,7 @@ function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
 var PluginConfigSchema = z2.object({
   preset: z2.string().optional(),
   setDefaultAgent: z2.boolean().optional(),
-  scoringEngineVersion: z2.enum(["v1", "v2-shadow", "v2"]).optional(),
-  balanceProviderUsage: z2.boolean().optional(),
   autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
-  manualPlan: ManualPlanSchema.optional(),
   presets: z2.record(z2.string(), PresetSchema).optional(),
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
   disabled_agents: z2.array(z2.string()).optional().describe("Agent names to disable completely. " + "Disabled agents are not instantiated and cannot be delegated to. " + "Orchestrator and council internal agents (councillor) cannot be disabled. " + "By default, 'observer' is disabled. Remove it from this list and configure a vision-capable model to enable."),
@@ -528,7 +515,8 @@ var PluginConfigSchema = z2.object({
   backgroundJobs: BackgroundJobsConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional(),
-  companion: CompanionConfigSchema.optional()
+  companion: CompanionConfigSchema.optional(),
+  acpAgents: AcpAgentsConfigSchema.optional()
 }).superRefine((value, ctx) => {
   if (value.agents) {
     validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
@@ -587,11 +575,23 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/deepwork"
   },
+  {
+    name: "reflect",
+    description: "Review repeated work and suggest reusable workflow improvements",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/reflect"
+  },
   {
     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"
+  },
+  {
+    name: "worktrees",
+    description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/worktrees"
   }
 ];
 function getCustomSkillsDir() {
@@ -737,7 +737,11 @@ function generateLiteConfig(installConfig) {
     config.companion = {
       enabled: true,
       position: "bottom-right",
-      size: "medium"
+      size: "medium",
+      gifPack: "default",
+      loopStyle: "classic",
+      speed: 1,
+      debug: false
     };
   }
   return config;
@@ -745,12 +749,7 @@ function generateLiteConfig(installConfig) {
 
 // src/cli/config-io.ts
 var PACKAGE_NAME = "oh-my-opencode-slim";
-var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = [
-  "build",
-  "explore",
-  "general",
-  "plan"
-];
+var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = ["explore", "general"];
 function isString(value) {
   return typeof value === "string";
 }
@@ -1278,6 +1277,7 @@ function mergePluginConfigs(base, override) {
     backgroundJobs: deepMerge(base.backgroundJobs, override.backgroundJobs),
     fallback: deepMerge(base.fallback, override.fallback),
     council: deepMerge(base.council, override.council),
+    acpAgents: deepMerge(base.acpAgents, override.acpAgents),
     companion: deepMerge(base.companion, override.companion)
   };
 }
@@ -1593,22 +1593,67 @@ function writeBackgroundSubagentsBlock(targetPath) {
   writeFileSync2(targetPath, nextContent);
 }
 
-// src/cli/companion.ts
+// src/companion/updater.ts
+init_compat();
+import { createHash } from "node:crypto";
 import {
   chmodSync,
   copyFileSync as copyFileSync3,
   existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   mkdtempSync,
+  readFileSync as readFileSync5,
   renameSync as renameSync2,
   rmSync as rmSync2,
+  statSync as statSync4,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir4, tmpdir } from "node:os";
+import { homedir as homedir4, platform, 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";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/utils/logger.ts
+import { appendFile } from "node:fs/promises";
+var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+var logFile = null;
+var writeChain = Promise.resolve();
+function log(message, data) {
+  const target = logFile;
+  if (!target)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    let dataStr = "";
+    if (data !== undefined) {
+      try {
+        dataStr = JSON.stringify(data);
+      } catch {
+        dataStr = "[unserializable]";
+      }
+    }
+    const logEntry = `[${timestamp}] ${message} ${dataStr}
+`;
+    writeChain = writeChain.then(() => appendFile(target, logEntry)).catch(() => {});
+  } catch {}
+}
+
+// src/companion/updater.ts
+var DOWNLOAD_TIMEOUT_MS = 30000;
+var LOCK_TIMEOUT_MS = 2000;
+var STALE_LOCK_MS = 5 * 60000;
+var FIRST_METADATA_VERSION = "0.1.2";
+var COMPANION_MANIFEST = {
+  version: "0.1.3",
+  tag: "companion-v0.1.3",
+  repo: "alvinunreal/oh-my-opencode-slim",
+  checksums: {
+    "oh-my-opencode-slim-companion-v0.1.3-aarch64-apple-darwin.tar.gz": "b4885f9b1900c02376e5f8f5ae6f3b8a89d26f7514b03f836d7e3d618164a0ed",
+    "oh-my-opencode-slim-companion-v0.1.3-aarch64-unknown-linux-gnu.tar.gz": "ed7cffc583e1eaa78c9bea702e6b6aa3bbc5bb4d881713fb2050237ba6b7aca5",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-apple-darwin.tar.gz": "98d8ea7c7bc4415b18e0d4c524adb4eb9a84c872919840fdc021f0f50c61f808",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-pc-windows-msvc.zip": "9316a49bf01f3b4fb1ce2d62edfc46094e73bb153d6ce023fb7df085afcf77bd",
+    "oh-my-opencode-slim-companion-v0.1.3-x86_64-unknown-linux-gnu.tar.gz": "33f5fd4b6c80155a019391e5efb13904ca9531ba8dd8c6cba30a161f1b07b764"
+  }
+};
 function getCompanionTarget() {
   const p = process.platform;
   const a = process.arch;
@@ -1631,47 +1676,109 @@ function getCompanionTarget() {
 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");
+  return path2.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", platform() === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion");
 }
-async function installCompanion(config) {
+async function ensureCompanionVersion(options) {
+  const { config, dryRun = false } = options;
+  const manifest = options.manifest ?? COMPANION_MANIFEST;
+  const binaryPath = getCompanionBinaryPath();
+  if (config?.enabled !== true) {
+    return { status: "skipped", reason: "disabled", binaryPath };
+  }
+  if (config.binaryPath?.trim()) {
+    return { status: "skipped", reason: "custom-binary", binaryPath };
+  }
   const target = getCompanionTarget();
-  const finalBinaryPath = getCompanionBinaryPath();
   if (!target) {
     return {
-      success: false,
-      configPath: finalBinaryPath,
+      status: "failed",
+      binaryPath,
       error: `Unsupported platform/architecture: ${process.platform} ${process.arch}`
     };
   }
+  const current = readInstallMetadata(binaryPath);
+  if (existsSync6(binaryPath) && !current && manifest.version === FIRST_METADATA_VERSION) {
+    const archiveName = companionArchiveName(manifest.version, target);
+    writeInstallMetadata(binaryPath, {
+      version: manifest.version,
+      tag: manifest.tag,
+      target,
+      installedAt: new Date().toISOString(),
+      archiveName,
+      checksum: manifest.checksums?.[archiveName]
+    });
+    return { status: "current", binaryPath, version: manifest.version };
+  }
+  if (existsSync6(binaryPath) && current?.target === target && compareSemver(current.version, manifest.version) >= 0) {
+    return { status: "current", binaryPath, version: current.version };
+  }
+  if (dryRun) {
+    return { status: "installed", binaryPath, version: manifest.version };
+  }
+  return withCompanionInstallLock(binaryPath, options.lockTimeoutMs, options.lockStaleMs, async () => {
+    const lockedCurrent = readInstallMetadata(binaryPath);
+    if (existsSync6(binaryPath) && !lockedCurrent && manifest.version === FIRST_METADATA_VERSION) {
+      const archiveName = companionArchiveName(manifest.version, target);
+      writeInstallMetadata(binaryPath, {
+        version: manifest.version,
+        tag: manifest.tag,
+        target,
+        installedAt: new Date().toISOString(),
+        archiveName,
+        checksum: manifest.checksums?.[archiveName]
+      });
+      return { status: "current", binaryPath, version: manifest.version };
+    }
+    if (existsSync6(binaryPath) && lockedCurrent?.target === target && compareSemver(lockedCurrent.version, manifest.version) >= 0) {
+      return {
+        status: "current",
+        binaryPath,
+        version: lockedCurrent.version
+      };
+    }
+    return installCompanionArchive(binaryPath, target, manifest, options.downloadTimeoutMs ?? DOWNLOAD_TIMEOUT_MS);
+  });
+}
+async function installCompanionArchive(finalBinaryPath, target, manifest, downloadTimeoutMs) {
   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}`);
+  const archiveName = companionArchiveName(manifest.version, target, isWindows);
+  const downloadUrl = `https://github.com/${manifest.repo}/releases/download/${manifest.tag}/${archiveName}`;
+  const expectedChecksum = manifest.checksums?.[archiveName];
+  if (!expectedChecksum) {
     return {
-      success: true,
-      configPath: finalBinaryPath
+      status: "failed",
+      binaryPath: finalBinaryPath,
+      error: `Missing SHA256 checksum for companion archive: ${archiveName}`
     };
   }
   let buffer;
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), downloadTimeoutMs);
   try {
-    const res = await fetch(downloadUrl);
+    const res = await fetch(downloadUrl, { signal: controller.signal });
     if (!res.ok) {
       return {
-        success: false,
-        configPath: finalBinaryPath,
+        status: "failed",
+        binaryPath: 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)}`
+      status: "failed",
+      binaryPath: finalBinaryPath,
+      error: `Failed to fetch companion archive: ${formatError(err)}`
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+  const checksum = createHash("sha256").update(Buffer.from(buffer)).digest("hex");
+  if (checksum !== expectedChecksum) {
+    return {
+      status: "failed",
+      binaryPath: finalBinaryPath,
+      error: "Companion archive checksum mismatch"
     };
   }
   let tempDir = "";
@@ -1685,14 +1792,13 @@ async function installCompanion(config) {
       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 proc = crossSpawn(["tar", "-xzf", archivePath, "-C", extractedDir]);
       const exitCode = await proc.exited;
       if (exitCode !== 0) {
         const stderr = await proc.stderr();
         return {
-          success: false,
-          configPath: finalBinaryPath,
+          status: "failed",
+          binaryPath: finalBinaryPath,
           error: `Archive extraction failed (tar exited with ${exitCode}): ${stderr}`
         };
       }
@@ -1701,8 +1807,8 @@ async function installCompanion(config) {
     const extractedBinaryPath = path2.join(extractedDir, binaryName);
     if (!existsSync6(extractedBinaryPath)) {
       return {
-        success: false,
-        configPath: finalBinaryPath,
+        status: "failed",
+        binaryPath: finalBinaryPath,
         error: `Binary ${binaryName} not found in extracted archive`
       };
     }
@@ -1714,15 +1820,24 @@ async function installCompanion(config) {
       chmodSync(tmpFinalPath, 493);
     }
     renameSync2(tmpFinalPath, finalBinaryPath);
+    writeInstallMetadata(finalBinaryPath, {
+      version: manifest.version,
+      tag: manifest.tag,
+      target,
+      installedAt: new Date().toISOString(),
+      archiveName,
+      checksum
+    });
     return {
-      success: true,
-      configPath: finalBinaryPath
+      status: "installed",
+      binaryPath: finalBinaryPath,
+      version: manifest.version
     };
   } catch (err) {
     return {
-      success: false,
-      configPath: finalBinaryPath,
-      error: `Failed to install companion: ${err instanceof Error ? err.message : String(err)}`
+      status: "failed",
+      binaryPath: finalBinaryPath,
+      error: `Failed to install companion: ${formatError(err)}`
     };
   } finally {
     if (tempDir) {
@@ -1732,10 +1847,131 @@ async function installCompanion(config) {
     }
   }
 }
+function readInstallMetadata(binaryPath) {
+  try {
+    const parsed = JSON.parse(readFileSync5(metadataPath(binaryPath), "utf8"));
+    if (parsed?.version && parsed.tag && parsed.target) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function writeInstallMetadata(binaryPath, metadata) {
+  writeFileSync3(metadataPath(binaryPath), JSON.stringify(metadata, null, 2));
+}
+function metadataPath(binaryPath) {
+  return `${binaryPath}.json`;
+}
+async function withCompanionInstallLock(binaryPath, timeoutMs, staleMs, run) {
+  const lock = `${binaryPath}.lock`;
+  const deadline = Date.now() + (timeoutMs ?? LOCK_TIMEOUT_MS);
+  const staleAfterMs = staleMs ?? STALE_LOCK_MS;
+  mkdirSync5(path2.dirname(binaryPath), { recursive: true });
+  while (Date.now() <= deadline) {
+    try {
+      mkdirSync5(lock);
+      try {
+        return await run();
+      } finally {
+        try {
+          rmSync2(lock, { recursive: true, force: true });
+        } catch {}
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST")
+        throw err;
+      try {
+        const ageMs = Date.now() - statSync4(lock).mtimeMs;
+        if (ageMs > staleAfterMs) {
+          rmSync2(lock, { recursive: true, force: true });
+          log("[companion] removed stale install lock", lock);
+          continue;
+        }
+      } catch (statErr) {
+        const statCode = statErr.code;
+        if (statCode !== "ENOENT")
+          throw statErr;
+      }
+      await delay(25);
+    }
+  }
+  log("[companion] install lock timed out", lock);
+  return {
+    status: "failed",
+    binaryPath,
+    error: "Timed out waiting for companion install lock"
+  };
+}
+function companionArchiveName(version, target, isWindows = process.platform === "win32") {
+  const ext = isWindows ? "zip" : "tar.gz";
+  return `oh-my-opencode-slim-companion-v${version}-${target}.${ext}`;
+}
+function compareSemver(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  if (!left || !right)
+    return a.localeCompare(b);
+  for (let i = 0;i < 3; i++) {
+    const diff = left[i] - right[i];
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function parseSemver(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  if (!match)
+    return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/cli/companion.ts
+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 ext = process.platform === "win32" ? "zip" : "tar.gz";
+  const archiveName = `oh-my-opencode-slim-companion-v${COMPANION_MANIFEST.version}-${target}.${ext}`;
+  const downloadUrl = `https://github.com/${COMPANION_MANIFEST.repo}/releases/download/${COMPANION_MANIFEST.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
+    };
+  }
+  const result = await ensureCompanionVersion({
+    config: { enabled: true },
+    manifest: COMPANION_MANIFEST
+  });
+  if (result.status === "installed" || result.status === "current") {
+    return {
+      success: true,
+      configPath: finalBinaryPath
+    };
+  }
+  return {
+    success: false,
+    configPath: finalBinaryPath,
+    error: result.status === "failed" ? result.error : `Companion install skipped: ${result.reason}`
+  };
+}
 // src/cli/system.ts
 init_compat();
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync5 } from "node:fs";
 var cachedOpenCodePath = null;
 function resolvePathCommand(command) {
   try {
@@ -1808,7 +2044,7 @@ function resolveOpenCodePath() {
     if (opencodePath === "opencode")
       continue;
     try {
-      const stat = statSync4(opencodePath);
+      const stat = statSync5(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -1877,8 +2113,8 @@ var SYMBOLS = {
   warn: `${YELLOW}[!]${RESET}`,
   star: `${YELLOW}★${RESET}`
 };
-var GITHUB_REPO2 = "alvinunreal/oh-my-opencode-slim";
-var GITHUB_URL = `https://github.com/${GITHUB_REPO2}`;
+var GITHUB_REPO = "alvinunreal/oh-my-opencode-slim";
+var GITHUB_URL = `https://github.com/${GITHUB_REPO}`;
 function printHeader(isUpdate) {
   console.log();
   console.log(`${BOLD}oh-my-opencode-slim ${isUpdate ? "Update" : "Install"}${RESET}`);
@@ -1921,7 +2157,7 @@ async function askToStarRepo(config) {
     return;
   try {
     const { execFileSync } = await import("node:child_process");
-    execFileSync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${GITHUB_REPO2}`], { stdio: "ignore", timeout: 1e4 });
+    execFileSync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${GITHUB_REPO}`], { stdio: "ignore", timeout: 1e4 });
     printSuccess("Thanks for starring! ★");
   } catch {
     printInfo(`Couldn't star automatically. You can star manually:
@@ -2001,8 +2237,9 @@ ${block}
   return { enabledNow: false, configuredTarget: target };
 }
 async function shouldInstallCompanion(config) {
-  if (config.companion === "yes")
+  if (config.companion === "yes") {
     return true;
+  }
   if (config.companion === "no")
     return false;
   if (config.dryRun) {

package/dist/companion/manager.d.ts

@@ -1,5 +1,6 @@
 import type { CompanionConfig } from '../config/schema';
 export declare function stateFilePath(): string;
+export declare function resolveCompanionBinaryPath(config?: CompanionConfig): string | null;
 /**
  * Tracks live agent activity per session and mirrors it to the companion
  * state file. Source of truth is OpenCode's session.status events: every

package/dist/companion/updater.d.ts

@@ -0,0 +1,36 @@
+import type { CompanionConfig } from '../config/schema';
+export interface CompanionManifest {
+    version: string;
+    tag: string;
+    repo: string;
+    checksums?: Record<string, string>;
+}
+export type CompanionUpdateResult = {
+    status: 'installed';
+    binaryPath: string;
+    version: string;
+} | {
+    status: 'current';
+    binaryPath: string;
+    version: string;
+} | {
+    status: 'skipped';
+    reason: string;
+    binaryPath?: string;
+} | {
+    status: 'failed';
+    error: string;
+    binaryPath: string;
+};
+export declare const COMPANION_MANIFEST: CompanionManifest;
+export declare function getCompanionTarget(): string | null;
+export declare function getCompanionBinaryPath(): string;
+export declare function loadCompanionManifestFromPackageRoot(packageRoot: string): CompanionManifest | null;
+export declare function ensureCompanionVersion(options: {
+    config?: CompanionConfig;
+    manifest?: CompanionManifest;
+    dryRun?: boolean;
+    downloadTimeoutMs?: number;
+    lockTimeoutMs?: number;
+    lockStaleMs?: number;
+}): Promise<CompanionUpdateResult>;

package/dist/config/agent-mcps.d.ts

@@ -5,10 +5,6 @@ export declare const DEFAULT_AGENT_MCPS: Record<AgentName, string[]>;
  * Parse a list with wildcard and exclusion syntax.
  */
 export declare function parseList(items: string[], allAvailable: string[]): string[];
-/**
- * Get available MCP names from schema and config.
- */
-export declare function getAvailableMcpNames(config?: PluginConfig): string[];
 /**
  * Get the MCP list for an agent (from config or defaults).
  */