oh-my-opencode-slim 2.0.2 → 2.0.4

package/dist/index.js

@@ -30,8 +30,160 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+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/utils/compat.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { writeFile as fsWriteFile } from "node:fs/promises";
+function collectStream(stream) {
+  if (!stream)
+    return () => Promise.resolve("");
+  const chunks = [];
+  stream.on("data", (chunk) => chunks.push(chunk));
+  return () => new Promise((resolve, reject) => {
+    if (!stream.readable) {
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+      return;
+    }
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stream.on("error", reject);
+  });
+}
+function crossSpawn(command, options) {
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    stdio: [
+      options?.stdin ?? "ignore",
+      options?.stdout ?? "pipe",
+      options?.stderr ?? "pipe"
+    ],
+    cwd: options?.cwd,
+    env: options?.env
+  });
+  const stdoutCollector = collectStream(proc.stdout);
+  const stderrCollector = collectStream(proc.stderr);
+  const exited = new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  return {
+    proc,
+    stdout: stdoutCollector,
+    stderr: stderrCollector,
+    exited,
+    kill: (signal) => proc.kill(signal),
+    get exitCode() {
+      return proc.exitCode;
+    }
+  };
+}
+async function crossWrite(path, data) {
+  await fsWriteFile(path, Buffer.from(data));
+}
+var init_compat = () => {};
+
+// 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(path4) {
+  return path4.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();
+});
+
 // node_modules/.pnpm/@mozilla+readability@0.6.0/node_modules/@mozilla/readability/Readability.js
 var require_Readability = __commonJS((exports, module) => {
   function Readability(doc, options) {
@@ -6246,33 +6398,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path18) {
-        if (!path18)
-          return path18;
+      function remove_dot_segments(path19) {
+        if (!path19)
+          return path19;
         var output = "";
-        while (path18.length > 0) {
-          if (path18 === "." || path18 === "..") {
-            path18 = "";
+        while (path19.length > 0) {
+          if (path19 === "." || path19 === "..") {
+            path19 = "";
             break;
           }
-          var twochars = path18.substring(0, 2);
-          var threechars = path18.substring(0, 3);
-          var fourchars = path18.substring(0, 4);
+          var twochars = path19.substring(0, 2);
+          var threechars = path19.substring(0, 3);
+          var fourchars = path19.substring(0, 4);
           if (threechars === "../") {
-            path18 = path18.substring(3);
+            path19 = path19.substring(3);
           } else if (twochars === "./") {
-            path18 = path18.substring(2);
+            path19 = path19.substring(2);
           } else if (threechars === "/./") {
-            path18 = "/" + path18.substring(3);
-          } else if (twochars === "/." && path18.length === 2) {
-            path18 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path18.length === 3) {
-            path18 = "/" + path18.substring(4);
+            path19 = "/" + path19.substring(3);
+          } else if (twochars === "/." && path19.length === 2) {
+            path19 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path19.length === 3) {
+            path19 = "/" + path19.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path18.match(/(\/?([^\/]*))/)[0];
+            var segment = path19.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path18 = path18.substring(segment.length);
+            path19 = path19.substring(segment.length);
           }
         }
         return output;
@@ -18150,14 +18302,14 @@ var require_turndown_cjs = __commonJS((exports, module) => {
       } else if (node.nodeType === 1) {
         replacement = replacementForNode.call(self, node);
       }
-      return join16(output, replacement);
+      return join17(output, replacement);
     }, "");
   }
   function postProcess(output) {
     var self = this;
     this.rules.forEach(function(rule) {
       if (typeof rule.append === "function") {
-        output = join16(output, rule.append(self.options));
+        output = join17(output, rule.append(self.options));
       }
     });
     return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -18170,7 +18322,7 @@ var require_turndown_cjs = __commonJS((exports, module) => {
       content = content.trim();
     return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
   }
-  function join16(output, replacement) {
+  function join17(output, replacement) {
     var s1 = trimTrailingNewlines(output);
     var s2 = trimLeadingNewlines(replacement);
     var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -18417,54 +18569,8 @@ var CouncilConfigSchema = z.object({
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-// src/utils/compat.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import { writeFile as fsWriteFile } from "node:fs/promises";
-function collectStream(stream) {
-  if (!stream)
-    return () => Promise.resolve("");
-  const chunks = [];
-  stream.on("data", (chunk) => chunks.push(chunk));
-  return () => new Promise((resolve, reject) => {
-    if (!stream.readable) {
-      resolve(Buffer.concat(chunks).toString("utf-8"));
-      return;
-    }
-    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    stream.on("error", reject);
-  });
-}
-function crossSpawn(command, options) {
-  const [cmd, ...args] = command;
-  const proc = nodeSpawn(cmd, args, {
-    stdio: [
-      options?.stdin ?? "ignore",
-      options?.stdout ?? "pipe",
-      options?.stderr ?? "pipe"
-    ],
-    cwd: options?.cwd,
-    env: options?.env
-  });
-  const stdoutCollector = collectStream(proc.stdout);
-  const stderrCollector = collectStream(proc.stderr);
-  const exited = new Promise((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve(code ?? 1));
-  });
-  return {
-    proc,
-    stdout: stdoutCollector,
-    stderr: stderrCollector,
-    exited,
-    kill: (signal) => proc.kill(signal),
-    get exitCode() {
-      return proc.exitCode;
-    }
-  };
-}
-async function crossWrite(path, data) {
-  await fsWriteFile(path, Buffer.from(data));
-}
+// src/cli/config-io.ts
+init_compat();
 
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
@@ -18604,9 +18710,28 @@ var FailoverConfigSchema = z2.object({
 }).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;
@@ -18644,7 +18769,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"]);
@@ -18744,6 +18870,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)
   };
 }
@@ -18797,8 +18924,13 @@ function loadPluginConfig(directory, options) {
   if (config.companion) {
     config.companion = {
       enabled: config.companion.enabled ?? false,
+      binaryPath: config.companion.binaryPath,
       position: config.companion.position ?? "bottom-right",
-      size: config.companion.size ?? "medium"
+      size: config.companion.size ?? "medium",
+      gifPack: config.companion.gifPack ?? "default",
+      loopStyle: config.companion.loopStyle ?? "classic",
+      speed: config.companion.speed ?? 1,
+      debug: config.companion.debug ?? false
     };
   }
   return config;
@@ -18859,6 +18991,9 @@ function getCustomAgentNames(config) {
     return !ALL_AGENT_NAMES.includes(name);
   });
 }
+function getAcpAgentNames(config) {
+  return Object.keys(config?.acpAgents ?? {});
+}
 // src/utils/session.ts
 var SESSION_ABORT_TIMEOUT_MS = 1000;
 
@@ -19116,6 +19251,11 @@ Build a short work graph before dispatching:
 - Advisory ownership for write-capable lanes
 - Verification/review lanes that run after implementation
 
+### Todo Continuity
+- When the user adds a new task while a todo list exists, append the new task to the end of the existing todo list instead of replacing the list.
+- Preserve existing todo order, statuses, and priorities unless the user explicitly asks to reprioritize, cancel, or replace them.
+- Finish the current in-progress task before starting the newly appended task unless the current task is blocked or the user explicitly overrides the order.
+
 Can tasks be split into background specialist work?
 ${enabledParallelExamples}
 
@@ -19123,6 +19263,7 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 
 ### Background Task Discipline
 - Prefer \`task(..., background: true)\` for delegated work that can run independently.
+- Launch specialist agents in the background by default so the orchestrator stays unblocked and can reconcile results when they return.
 - Track each task's specialist, objective, task/session ID, and file/topic ownership.
 - Continue orchestration only on non-overlapping work; otherwise briefly report what was launched and stop.
 - Before local edits or another writer task, compare against running task scopes.
@@ -19734,6 +19875,39 @@ function normalizeDisplayName(displayName) {
   const trimmed = displayName.trim();
   return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
 }
+function buildAcpAgentDefinition(name, config) {
+  const description = config.description ?? `External ACP agent '${name}' via ${config.command}`;
+  const prompt = config.prompt ?? [
+    `You are the ${name} ACP wrapper agent.`,
+    "",
+    "Your only job is to send the user task to the configured external ACP agent using the acp_run tool, then return the ACP agent result.",
+    `Always call acp_run with agent: ${JSON.stringify(name)} and pass the full user task as prompt.`,
+    "Do not edit files yourself unless the ACP result explicitly asks you to report a local follow-up to the orchestrator."
+  ].join(`
+`);
+  return {
+    name,
+    description,
+    config: {
+      model: config.wrapperModel ?? DEFAULT_MODELS.fixer ?? DEFAULT_MODELS.librarian ?? DEFAULT_MODELS.orchestrator ?? DEFAULT_MODELS.oracle,
+      temperature: 0,
+      prompt,
+      permission: {
+        read: "deny",
+        edit: "deny",
+        bash: "deny",
+        task: "deny",
+        glob: "deny",
+        grep: "deny",
+        list: "deny",
+        webfetch: "deny",
+        question: "deny",
+        skill: "deny",
+        acp_run: "allow"
+      }
+    }
+  };
+}
 function isSafeDisplayName(displayName) {
   return SAFE_AGENT_ALIAS_RE.test(displayName);
 }
@@ -19873,6 +20047,24 @@ function createAgents(config) {
       buildCustomAgentDefinition(name, override, customPrompts.prompt, customPrompts.appendPrompt)
     ];
   });
+  const acpAgentNames = getAcpAgentNames(config).map(normalizeCustomAgentName).filter((name) => name.length > 0).filter((name) => {
+    if (!SAFE_AGENT_ALIAS_RE.test(name)) {
+      throw new Error(`ACP agent name '${name}' must match /^[a-z][a-z0-9_-]*$/i`);
+    }
+    if (isKnownAgentName(name) || AGENT_ALIASES[name] !== undefined) {
+      throw new Error(`ACP agent '${name}' conflicts with a built-in agent name or alias`);
+    }
+    if (customAgentNames.includes(name)) {
+      throw new Error(`ACP agent '${name}' conflicts with a custom agent of the same name`);
+    }
+    return !disabled.has(name);
+  });
+  const protoAcpAgents = acpAgentNames.map((name) => {
+    const acp = config?.acpAgents?.[name];
+    if (!acp)
+      throw new Error(`ACP agent '${name}' is missing config`);
+    return buildAcpAgentDefinition(name, acp);
+  });
   const builtInSubAgents = protoSubAgents.map((agent) => {
     const override = getAgentOverride(config, agent.name);
     if (override) {
@@ -19896,7 +20088,15 @@ function createAgents(config) {
     applyDefaultPermissions(agent, override?.skills);
     return agent;
   });
-  const allSubAgents = [...builtInSubAgents, ...customSubAgents];
+  const acpSubAgents = protoAcpAgents.map((agent) => {
+    applyDefaultPermissions(agent);
+    return agent;
+  });
+  const allSubAgents = [
+    ...builtInSubAgents,
+    ...customSubAgents,
+    ...acpSubAgents
+  ];
   const orchestratorOverride = getAgentOverride(config, "orchestrator");
   const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
   const orchestratorPrompts = loadAgentPrompt("orchestrator", config?.preset);
@@ -19918,6 +20118,20 @@ function createAgents(config) {
     const override = getAgentOverride(config, agent.name);
     return override?.orchestratorPrompt;
   }).filter((prompt) => Boolean(prompt));
+  const acpOrchestratorPrompts = acpSubAgents.map((agent) => {
+    const acp = config?.acpAgents?.[agent.name];
+    if (acp?.orchestratorPrompt)
+      return acp.orchestratorPrompt;
+    return [
+      `@${agent.name}`,
+      `- Lane: External ACP-connected agent (${acp?.command ?? "unknown command"})`,
+      `- Role: ${agent.description ?? `External ACP agent ${agent.name}`}`,
+      "- **Delegate when:** The user explicitly asks for this ACP-backed agent, or the task matches its role and benefits from software/subscription-specific capabilities outside OpenCode.",
+      "- **Do not delegate when:** The built-in specialists can handle the task more directly or local file ownership would conflict with another writer lane.",
+      "- **Result handling:** Treat returned output as external-agent work. Reconcile any reported file changes before continuing."
+    ].join(`
+`);
+  });
   const usedDisplayNames = new Set;
   for (const [, displayName] of displayNameMap) {
     const normalizedDisplayName = normalizeDisplayName(displayName);
@@ -19930,13 +20144,17 @@ function createAgents(config) {
     usedDisplayNames.add(normalizedDisplayName);
   }
   for (const displayName of usedDisplayNames) {
-    if (ALL_AGENT_NAMES.includes(displayName) || customAgentNames.includes(displayName)) {
+    if (ALL_AGENT_NAMES.includes(displayName) || customAgentNames.includes(displayName) || acpAgentNames.includes(displayName)) {
       throw new Error(`displayName '${displayName}' conflicts with an agent name`);
     }
   }
   injectDisplayNames(orchestrator, displayNameMap);
-  if (customOrchestratorPrompts.length > 0) {
-    const rewrittenPrompts = customOrchestratorPrompts.map((promptText) => {
+  const extraOrchestratorPrompts = [
+    ...customOrchestratorPrompts,
+    ...acpOrchestratorPrompts
+  ];
+  if (extraOrchestratorPrompts.length > 0) {
+    const rewrittenPrompts = extraOrchestratorPrompts.map((promptText) => {
       let text = promptText;
       for (const [internalName, displayName] of displayNameMap) {
         text = text.replace(new RegExp(`@${escapeRegExp(internalName)}\\b`, "g"), `@${normalizeDisplayName(displayName)}`);
@@ -20008,6 +20226,7 @@ import {
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   renameSync,
+  rmSync,
   writeFileSync
 } from "node:fs";
 import * as os2 from "node:os";
@@ -20096,11 +20315,15 @@ function stateFilePath() {
   const base = xdg && path3.isAbsolute(xdg) ? xdg : path3.join(os2.homedir(), ".local", "share");
   return path3.join(base, "opencode", "storage", "oh-my-opencode-slim", "companion-state.json");
 }
-function binaryPath() {
+function defaultBinaryPath() {
   const xdg = process.env.XDG_DATA_HOME?.trim();
   const base = xdg && path3.isAbsolute(xdg) ? xdg : path3.join(os2.homedir(), ".local", "share");
   const binaryName = os2.platform() === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion";
-  const bin = path3.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", binaryName);
+  return path3.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", binaryName);
+}
+function resolveCompanionBinaryPath(config) {
+  const configured = config?.binaryPath?.trim();
+  const bin = configured || defaultBinaryPath();
   return existsSync2(bin) ? bin : null;
 }
 function readState() {
@@ -20113,17 +20336,43 @@ function readState() {
   } catch {}
   return { version: 1, sessions: [] };
 }
-function writeState(state) {
+function writeState(mutator) {
   const file = stateFilePath();
   try {
     mkdirSync2(path3.dirname(file), { recursive: true });
-    const tmp = `${file}.tmp`;
-    writeFileSync(tmp, JSON.stringify(state));
-    renameSync(tmp, file);
+    const release = acquireStateLock(file);
+    try {
+      const state = readState();
+      mutator(state);
+      const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tmp, JSON.stringify(state));
+      renameSync(tmp, file);
+    } finally {
+      release();
+    }
   } catch (err) {
     log("[companion] write failed", String(err));
   }
 }
+function acquireStateLock(file) {
+  const lock = `${file}.lock`;
+  for (let attempt = 0;attempt < 40; attempt++) {
+    try {
+      mkdirSync2(lock);
+      return () => {
+        try {
+          rmSync(lock, { recursive: true, force: true });
+        } catch {}
+      };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST")
+        throw err;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+  }
+  throw new Error("timed out waiting for companion state lock");
+}
 
 class CompanionManager {
   id;
@@ -20131,6 +20380,7 @@ class CompanionManager {
   status = "idle";
   busyAgentSessions = new Map;
   config;
+  companionProcess = null;
   constructor(sessionId, cwd, config) {
     this.id = sessionId;
     this.cwd = cwd;
@@ -20139,12 +20389,11 @@ class CompanionManager {
   onLoad() {
     if (this.config?.enabled !== true) {
       try {
-        const state = readState();
-        const filtered = state.sessions.filter((s) => s.session_id !== this.id);
-        if (filtered.length !== state.sessions.length) {
-          state.sessions = filtered;
-          writeState(state);
-        }
+        if (!existsSync2(stateFilePath()))
+          return;
+        writeState((state) => {
+          state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
+        });
       } catch {}
       return;
     }
@@ -20196,9 +20445,15 @@ class CompanionManager {
   onExit() {
     if (this.config?.enabled !== true)
       return;
-    const state = readState();
-    state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
-    writeState(state);
+    if (this.companionProcess) {
+      try {
+        this.companionProcess.kill();
+      } catch {}
+      this.companionProcess = null;
+    }
+    writeState((state) => {
+      state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
+    });
   }
   activeAgents() {
     const agents = Array.from(this.busyAgentSessions.values());
@@ -20214,28 +20469,41 @@ class CompanionManager {
     if (this.config?.enabled !== true)
       return;
     try {
-      const state = readState();
       const entry = {
         session_id: this.id,
         cwd: this.cwd,
         active_agents: this.activeAgents(),
         status: this.status,
-        pid: process.pid
-      };
-      const idx = state.sessions.findIndex((s) => s.session_id === this.id);
-      if (idx >= 0) {
-        state.sessions[idx] = entry;
-      } else {
-        state.sessions.push(entry);
-      }
-      if (this.config) {
-        state.config = {
+        pid: process.pid,
+        config: this.config ? {
           enabled: this.config.enabled ?? false,
           position: this.config.position ?? "bottom-right",
-          size: this.config.size ?? "medium"
-        };
-      }
-      writeState(state);
+          size: this.config.size ?? "medium",
+          gifPack: this.config.gifPack ?? "default",
+          loopStyle: this.config.loopStyle ?? "classic",
+          speed: this.config.speed ?? 1,
+          debug: this.config.debug ?? false
+        } : undefined
+      };
+      writeState((state) => {
+        const idx = state.sessions.findIndex((s) => s.session_id === this.id);
+        if (idx >= 0) {
+          state.sessions[idx] = entry;
+        } else {
+          state.sessions.push(entry);
+        }
+        if (this.config) {
+          state.config = {
+            enabled: this.config.enabled ?? false,
+            position: this.config.position ?? "bottom-right",
+            size: this.config.size ?? "medium",
+            gifPack: this.config.gifPack ?? "default",
+            loopStyle: this.config.loopStyle ?? "classic",
+            speed: this.config.speed ?? 1,
+            debug: this.config.debug ?? false
+          };
+        }
+      });
     } catch (err) {
       log("[companion] flush failed", String(err));
     }
@@ -20243,24 +20511,359 @@ class CompanionManager {
   spawnIfAvailable() {
     if (this.config?.enabled !== true)
       return;
-    const bin = binaryPath();
+    const bin = resolveCompanionBinaryPath(this.config);
     if (!bin) {
-      const xdg = process.env.XDG_DATA_HOME?.trim();
-      const base = xdg && path3.isAbsolute(xdg) ? xdg : path3.join(os2.homedir(), ".local", "share");
-      const expected = path3.join(base, "o‍pencode", "storage", "oh-my-o‍pencode-slim", "bin", "oh-my-o‍pencode-slim-companion");
+      const expected = this.config.binaryPath?.trim() || defaultBinaryPath();
       log(`[companion] enabled but companion binary not found at expected path: ${expected}. Please install/download the companion binary separately.`);
       return;
     }
     try {
-      const child = spawn(bin, [], { detached: true, stdio: "ignore" });
+      const child = spawn(bin, [], {
+        detached: true,
+        env: {
+          ...process.env,
+          OH_MY_OPENCODE_SLIM_COMPANION_SESSION_ID: this.id,
+          ...this.config.debug === true ? { OH_MY_OPENCODE_SLIM_COMPANION_DEBUG: "1" } : {}
+        },
+        stdio: "ignore"
+      });
+      this.companionProcess = child;
       child.unref();
-      log("[companion] spawned", bin);
+      log("[companion] spawned", JSON.stringify({
+        bin,
+        sessionId: this.id,
+        debug: this.config.debug === true
+      }));
     } catch (err) {
       log("[companion] spawn failed", String(err));
     }
   }
 }
 
+// src/companion/updater.ts
+init_compat();
+import { createHash } from "node:crypto";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  readFileSync as readFileSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { homedir as homedir4, platform as platform2, tmpdir } from "node:os";
+import * as path4 from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+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;
+  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 && path4.isAbsolute(xdg) ? xdg : path4.join(homedir4(), ".local", "share");
+  return path4.join(base, "opencode", "storage", "oh-my-opencode-slim", "bin", platform2() === "win32" ? "oh-my-opencode-slim-companion.exe" : "oh-my-opencode-slim-companion");
+}
+function loadCompanionManifestFromPackageRoot(packageRoot) {
+  const manifestPath = path4.join(packageRoot, "src", "companion", "companion-manifest.json");
+  try {
+    const parsed = JSON.parse(readFileSync3(manifestPath, "utf8"));
+    if (parsed.version && parsed.tag && parsed.repo) {
+      return {
+        version: parsed.version,
+        tag: parsed.tag,
+        repo: parsed.repo,
+        checksums: parsed.checksums
+      };
+    }
+  } catch {}
+  return null;
+}
+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();
+  if (!target) {
+    return {
+      status: "failed",
+      binaryPath,
+      error: `Unsupported platform/architecture: ${process.platform} ${process.arch}`
+    };
+  }
+  const current = readInstallMetadata(binaryPath);
+  if (existsSync3(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 (existsSync3(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 (existsSync3(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 (existsSync3(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 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 {
+      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, { signal: controller.signal });
+    if (!res.ok) {
+      return {
+        status: "failed",
+        binaryPath: finalBinaryPath,
+        error: `Failed to download companion binary (HTTP ${res.status}): ${res.statusText}`
+      };
+    }
+    buffer = await res.arrayBuffer();
+  } catch (err) {
+    return {
+      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 = "";
+  try {
+    tempDir = mkdtempSync(path4.join(tmpdir(), "companion-install-"));
+    const archivePath = path4.join(tempDir, archiveName);
+    writeFileSync2(archivePath, Buffer.from(buffer));
+    const extractedDir = path4.join(tempDir, "extracted");
+    mkdirSync3(extractedDir, { recursive: true });
+    if (isWindows) {
+      const { extractZip: extractZip2 } = await Promise.resolve().then(() => (init_zip_extractor(), exports_zip_extractor));
+      await extractZip2(archivePath, extractedDir);
+    } else {
+      const proc = crossSpawn(["tar", "-xzf", archivePath, "-C", extractedDir]);
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await proc.stderr();
+        return {
+          status: "failed",
+          binaryPath: 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 = path4.join(extractedDir, binaryName);
+    if (!existsSync3(extractedBinaryPath)) {
+      return {
+        status: "failed",
+        binaryPath: finalBinaryPath,
+        error: `Binary ${binaryName} not found in extracted archive`
+      };
+    }
+    const binDir = path4.dirname(finalBinaryPath);
+    mkdirSync3(binDir, { recursive: true });
+    const tmpFinalPath = `${finalBinaryPath}.tmp`;
+    copyFileSync(extractedBinaryPath, tmpFinalPath);
+    if (!isWindows) {
+      chmodSync(tmpFinalPath, 493);
+    }
+    renameSync2(tmpFinalPath, finalBinaryPath);
+    writeInstallMetadata(finalBinaryPath, {
+      version: manifest.version,
+      tag: manifest.tag,
+      target,
+      installedAt: new Date().toISOString(),
+      archiveName,
+      checksum
+    });
+    return {
+      status: "installed",
+      binaryPath: finalBinaryPath,
+      version: manifest.version
+    };
+  } catch (err) {
+    return {
+      status: "failed",
+      binaryPath: finalBinaryPath,
+      error: `Failed to install companion: ${formatError(err)}`
+    };
+  } finally {
+    if (tempDir) {
+      try {
+        rmSync2(tempDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+}
+function readInstallMetadata(binaryPath) {
+  try {
+    const parsed = JSON.parse(readFileSync3(metadataPath(binaryPath), "utf8"));
+    if (parsed?.version && parsed.tag && parsed.target) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function writeInstallMetadata(binaryPath, metadata) {
+  writeFileSync2(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;
+  mkdirSync3(path4.dirname(binaryPath), { recursive: true });
+  while (Date.now() <= deadline) {
+    try {
+      mkdirSync3(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() - statSync2(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/config/runtime-preset.ts
 var activeRuntimePreset = null;
 function setActiveRuntimePreset(name) {
@@ -20597,7 +21200,7 @@ function ensureApplyPatchError(error, context) {
 
 // src/hooks/apply-patch/execution-context.ts
 import * as fs3 from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/hooks/apply-patch/codec.ts
 function normalizeLineEndings(text) {
@@ -21466,7 +22069,7 @@ function isMissingPathError(error) {
 }
 async function real(target) {
   const parts = [];
-  let current = path4.resolve(target);
+  let current = path5.resolve(target);
   while (true) {
     const exact = await fs3.realpath(current).catch((error) => {
       if (isMissingPathError(error)) {
@@ -21475,19 +22078,19 @@ async function real(target) {
       throw createApplyPatchInternalError(`Failed to resolve real path: ${current}`, error);
     });
     if (exact) {
-      return parts.length === 0 ? exact : path4.join(exact, ...parts.reverse());
+      return parts.length === 0 ? exact : path5.join(exact, ...parts.reverse());
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) {
-      return parts.length === 0 ? current : path4.join(current, ...parts.reverse());
+      return parts.length === 0 ? current : path5.join(current, ...parts.reverse());
     }
-    parts.push(path4.basename(current));
+    parts.push(path5.basename(current));
     current = parent;
   }
 }
 function inside(root, target) {
-  const rel = path4.relative(root, target);
-  return rel === "" || !rel.startsWith("..") && !path4.isAbsolute(rel);
+  const rel = path5.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path5.isAbsolute(rel);
 }
 function createPathGuardContext(root, worktree) {
   return {
@@ -21497,7 +22100,7 @@ function createPathGuardContext(root, worktree) {
   };
 }
 async function realCached(ctx, target) {
-  const resolvedTarget = path4.resolve(target);
+  const resolvedTarget = path5.resolve(target);
   let pending = ctx.realCache.get(resolvedTarget);
   if (!pending) {
     pending = real(resolvedTarget);
@@ -21548,22 +22151,22 @@ async function assertRegularFile(ctx, filePath, verb) {
 function collectPatchTargets(root, hunks) {
   const targets = new Set;
   for (const hunk of hunks) {
-    targets.add(path4.resolve(root, hunk.path));
+    targets.add(path5.resolve(root, hunk.path));
     if (hunk.type === "update" && hunk.move_path) {
-      targets.add(path4.resolve(root, hunk.move_path));
+      targets.add(path5.resolve(root, hunk.move_path));
     }
   }
   return [...targets];
 }
 function toRelativePatchPath(root, target) {
-  const relative = path4.relative(root, target);
+  const relative = path5.relative(root, target);
   return (relative.length === 0 ? "." : relative).replaceAll("\\", "/");
 }
 function normalizePatchPath(root, value) {
-  return path4.isAbsolute(value) ? toRelativePatchPath(root, path4.resolve(value)) : value;
+  return path5.isAbsolute(value) ? toRelativePatchPath(root, path5.resolve(value)) : value;
 }
 function normalizePatchPaths(root, hunks) {
-  const resolvedRoot = path4.resolve(root);
+  const resolvedRoot = path5.resolve(root);
   const normalized = [];
   let changed = false;
   for (const hunk of hunks) {
@@ -21687,7 +22290,7 @@ function stageAddedText(contents) {
 `;
 }
 // src/hooks/apply-patch/rewrite.ts
-import path5 from "node:path";
+import path6 from "node:path";
 function normalizeTextLineEndings(text) {
   return text.replace(/\r\n/g, `
 `).replace(/\r/g, `
@@ -21844,7 +22447,7 @@ async function rewritePatch(root, patchText, cfg, worktree) {
     const dependencyGroups = new Map;
     for (const hunk of hunks) {
       if (hunk.type === "add") {
-        const filePath2 = path5.resolve(root, hunk.path);
+        const filePath2 = path6.resolve(root, hunk.path);
         await assertPreparedPathMissing(filePath2, "add");
         rewritten.push(hunk);
         clearDependencyGroup(filePath2);
@@ -21866,20 +22469,20 @@ async function rewritePatch(root, patchText, cfg, worktree) {
         continue;
       }
       if (hunk.type === "delete") {
-        const filePath2 = path5.resolve(root, hunk.path);
+        const filePath2 = path6.resolve(root, hunk.path);
         await getPreparedFileState(filePath2, "delete");
         clearDependencyGroup(filePath2);
         rewritten.push(hunk);
         staged.set(filePath2, { exists: false, derived: true });
         continue;
       }
-      const filePath = path5.resolve(root, hunk.path);
+      const filePath = path6.resolve(root, hunk.path);
       const currentDependency = dependencyGroups.get(filePath);
       const current = await getPreparedFileState(filePath, "update");
       if (!current.exists) {
         throw createApplyPatchVerificationError(`Failed to read file to update: ${filePath}`);
       }
-      const movePath = hunk.move_path ? path5.resolve(root, hunk.move_path) : undefined;
+      const movePath = hunk.move_path ? path6.resolve(root, hunk.move_path) : undefined;
       if (movePath && movePath !== filePath) {
         await assertPreparedPathMissing(movePath, "move");
       }
@@ -22045,31 +22648,34 @@ function createApplyPatchHook(ctx) {
   };
 }
 // src/hooks/auto-update-checker/index.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
+init_compat();
 
 // src/hooks/auto-update-checker/cache.ts
 import * as fs5 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
+// src/cli/system.ts
+init_compat();
 // src/hooks/auto-update-checker/checker.ts
 import * as fs4 from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
 import * as os3 from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 var PACKAGE_NAME = "oh-my-opencode-slim";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_PACKAGE_URL = `https://registry.npmjs.org/${PACKAGE_NAME}`;
 var NPM_FETCH_TIMEOUT = 5000;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path6.join(process.env.LOCALAPPDATA ?? os3.homedir(), "opencode");
+    return path7.join(process.env.LOCALAPPDATA ?? os3.homedir(), "opencode");
   }
-  return path6.join(os3.homedir(), ".cache", "opencode");
+  return path7.join(os3.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path6.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+var INSTALLED_PACKAGE_JSON = path7.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 var configPaths = getOpenCodeConfigPaths();
 var USER_OPENCODE_CONFIG = configPaths[0];
 var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
@@ -22181,8 +22787,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    path7.join(directory, ".opencode", "opencode.json"),
-    path7.join(directory, ".opencode", "opencode.jsonc"),
+    path8.join(directory, ".opencode", "opencode.json"),
+    path8.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -22211,9 +22817,9 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat2 = fs4.statSync(startPath);
-    let dir = stat2.isDirectory() ? startPath : path7.dirname(startPath);
+    let dir = stat2.isDirectory() ? startPath : path8.dirname(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = path7.join(dir, "package.json");
+      const pkgPath = path8.join(dir, "package.json");
       if (fs4.existsSync(pkgPath)) {
         try {
           const content = fs4.readFileSync(pkgPath, "utf-8");
@@ -22222,7 +22828,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path7.dirname(dir);
+      const parent = path8.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -22247,7 +22853,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    const currentDir = path7.dirname(fileURLToPath(currentModuleUrl));
+    const currentDir = path8.dirname(fileURLToPath(currentModuleUrl));
     return findPackageJsonUp(currentDir);
   } catch (err) {
     log("[auto-update-checker] Failed to resolve runtime package path:", err);
@@ -22406,7 +23012,7 @@ function getBlockingMajorVersion(current, candidates) {
 
 // src/hooks/auto-update-checker/cache.ts
 function removeFromBunLock(installDir, packageName) {
-  const lockPath = path8.join(installDir, "bun.lock");
+  const lockPath = path9.join(installDir, "bun.lock");
   if (!fs5.existsSync(lockPath))
     return false;
   try {
@@ -22457,7 +23063,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const pkgDir = path8.join(installDir, "node_modules", packageName);
+  const pkgDir = path9.join(installDir, "node_modules", packageName);
   if (!fs5.existsSync(pkgDir))
     return false;
   fs5.rmSync(pkgDir, { recursive: true, force: true });
@@ -22466,18 +23072,18 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = path8.dirname(runtimePackageJsonPath);
-    const nodeModulesDir = path8.dirname(packageDir);
-    if (path8.basename(packageDir) === PACKAGE_NAME && path8.basename(nodeModulesDir) === "node_modules") {
-      const installDir = path8.dirname(nodeModulesDir);
-      const packageJsonPath = path8.join(installDir, "package.json");
+    const packageDir = path9.dirname(runtimePackageJsonPath);
+    const nodeModulesDir = path9.dirname(packageDir);
+    if (path9.basename(packageDir) === PACKAGE_NAME && path9.basename(nodeModulesDir) === "node_modules") {
+      const installDir = path9.dirname(nodeModulesDir);
+      const packageJsonPath = path9.join(installDir, "package.json");
       if (fs5.existsSync(packageJsonPath)) {
         return { installDir, packageJsonPath };
       }
     }
     return null;
   }
-  const legacyPackageJsonPath = path8.join(CACHE_DIR, "package.json");
+  const legacyPackageJsonPath = path9.join(CACHE_DIR, "package.json");
   if (fs5.existsSync(legacyPackageJsonPath)) {
     return { installDir: CACHE_DIR, packageJsonPath: legacyPackageJsonPath };
   }
@@ -22508,40 +23114,40 @@ function preparePackageUpdate(version, packageName = PACKAGE_NAME, runtimePackag
 
 // src/hooks/auto-update-checker/skill-sync.ts
 import {
-  copyFileSync,
-  existsSync as existsSync5,
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync6,
   lstatSync,
-  mkdirSync as mkdirSync3,
-  mkdtempSync,
+  mkdirSync as mkdirSync4,
+  mkdtempSync as mkdtempSync2,
   readdirSync as readdirSync2,
-  renameSync as renameSync2,
-  rmSync as rmSync2
+  renameSync as renameSync3,
+  rmSync as rmSync4
 } from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 function copyDirRecursive(src, dest) {
   const stat2 = lstatSync(src);
   if (stat2.isSymbolicLink()) {
     return;
   }
   if (stat2.isDirectory()) {
-    mkdirSync3(dest, { recursive: true });
+    mkdirSync4(dest, { recursive: true });
     const entries = readdirSync2(src);
     for (const entry of entries) {
-      copyDirRecursive(path9.join(src, entry), path9.join(dest, entry));
+      copyDirRecursive(path10.join(src, entry), path10.join(dest, entry));
     }
   } else if (stat2.isFile()) {
-    const destDir = path9.dirname(dest);
-    if (!existsSync5(destDir)) {
-      mkdirSync3(destDir, { recursive: true });
+    const destDir = path10.dirname(dest);
+    if (!existsSync6(destDir)) {
+      mkdirSync4(destDir, { recursive: true });
     }
-    copyFileSync(src, dest);
+    copyFileSync2(src, dest);
   }
 }
 function syncBundledSkillsFromPackage(packageRoot) {
   const installed = [];
   const skippedExisting = [];
   const failed = [];
-  const sourceSkillsDir = path9.join(packageRoot, "src", "skills");
+  const sourceSkillsDir = path10.join(packageRoot, "src", "skills");
   try {
     const stat2 = lstatSync(sourceSkillsDir);
     if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
@@ -22552,10 +23158,10 @@ function syncBundledSkillsFromPackage(packageRoot) {
     log(`[skill-sync] Source skills directory does not exist or is unreadable: ${sourceSkillsDir}`);
     return { installed, skippedExisting, failed };
   }
-  const destSkillsDir = path9.join(getConfigDir(), "skills");
+  const destSkillsDir = path10.join(getConfigDir(), "skills");
   try {
-    if (!existsSync5(destSkillsDir)) {
-      mkdirSync3(destSkillsDir, { recursive: true });
+    if (!existsSync6(destSkillsDir)) {
+      mkdirSync4(destSkillsDir, { recursive: true });
     }
   } catch (err) {
     log(`[skill-sync] Failed to create destination skills directory: ${destSkillsDir}`, err);
@@ -22568,7 +23174,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
     return { installed, skippedExisting, failed };
   }
   for (const entry of entries) {
-    const entryPath = path9.join(sourceSkillsDir, entry);
+    const entryPath = path10.join(sourceSkillsDir, entry);
     try {
       if (entry.startsWith(".")) {
         continue;
@@ -22577,7 +23183,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
       if (entryStat.isSymbolicLink() || !entryStat.isDirectory()) {
         continue;
       }
-      const skillMdPath = path9.join(entryPath, "SKILL.md");
+      const skillMdPath = path10.join(entryPath, "SKILL.md");
       try {
         const skillMdStat = lstatSync(skillMdPath);
         if (skillMdStat.isSymbolicLink() || !skillMdStat.isFile()) {
@@ -22586,7 +23192,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
       } catch {
         continue;
       }
-      const destPath = path9.join(destSkillsDir, entry);
+      const destPath = path10.join(destSkillsDir, entry);
       let destExists = false;
       try {
         lstatSync(destPath);
@@ -22597,7 +23203,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
         skippedExisting.push(entry);
         continue;
       }
-      const stagingDir = mkdtempSync(path9.join(destSkillsDir, `.sync-staging-${entry}-`));
+      const stagingDir = mkdtempSync2(path10.join(destSkillsDir, `.sync-staging-${entry}-`));
       try {
         copyDirRecursive(entryPath, stagingDir);
         let destExistsLate = false;
@@ -22609,7 +23215,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
           log(`[skill-sync] Destination path was created during staging for ${entry}, skipping promotion.`);
           skippedExisting.push(entry);
         } else {
-          renameSync2(stagingDir, destPath);
+          renameSync3(stagingDir, destPath);
           installed.push(entry);
           log(`[skill-sync] Successfully synced skill: ${entry}`);
         }
@@ -22618,8 +23224,8 @@ function syncBundledSkillsFromPackage(packageRoot) {
         failed.push(entry);
       } finally {
         try {
-          if (existsSync5(stagingDir)) {
-            rmSync2(stagingDir, { recursive: true, force: true });
+          if (existsSync6(stagingDir)) {
+            rmSync4(stagingDir, { recursive: true, force: true });
           }
         } catch (err) {
           log(`[skill-sync] Failed to clean up staging directory ${stagingDir}:`, err);
@@ -22635,7 +23241,7 @@ function syncBundledSkillsFromPackage(packageRoot) {
 
 // src/hooks/auto-update-checker/index.ts
 function createAutoUpdateCheckerHook(ctx, options = {}) {
-  const { autoUpdate = true } = options;
+  const { autoUpdate = true, companion } = options;
   let hasChecked = false;
   return {
     event: ({ event }) => {
@@ -22653,14 +23259,14 @@ function createAutoUpdateCheckerHook(ctx, options = {}) {
           log("[auto-update-checker] Local development mode");
           return;
         }
-        runBackgroundUpdateCheck(ctx, autoUpdate).catch((err) => {
+        runBackgroundUpdateCheck(ctx, autoUpdate, companion).catch((err) => {
           log("[auto-update-checker] Background update check failed:", err);
         });
       }, 0);
     }
   };
 }
-async function runBackgroundUpdateCheck(ctx, autoUpdate) {
+async function runBackgroundUpdateCheck(ctx, autoUpdate, companion) {
   const pluginInfo = findPluginEntry(ctx.directory);
   if (!pluginInfo) {
     log("[auto-update-checker] Plugin not found in config");
@@ -22716,8 +23322,10 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
   const installSuccess = await runBunInstallSafe(installDir);
   if (installSuccess) {
     let installedSkills = [];
+    let companionUpdated = false;
+    let companionWillRetry = false;
+    const packageRoot = path11.join(installDir, "node_modules", PACKAGE_NAME);
     try {
-      const packageRoot = path10.join(installDir, "node_modules", PACKAGE_NAME);
       const syncResult = syncBundledSkillsFromPackage(packageRoot);
       installedSkills = syncResult.installed;
       if (syncResult.failed.length > 0) {
@@ -22729,14 +23337,38 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
     } catch (err) {
       log("[auto-update-checker] Skill sync failed silently:", err);
     }
-    let message = `v${currentVersion} → v${latestVersion}
-Restart OpenCode to apply.`;
+    if (companion?.enabled === true) {
+      try {
+        const manifest = loadCompanionManifestFromPackageRoot(packageRoot);
+        const companionResult = await ensureCompanionVersion({
+          config: companion,
+          manifest: manifest ?? undefined
+        });
+        if (companionResult.status === "installed") {
+          companionUpdated = true;
+        } else if (companionResult.status === "failed") {
+          companionWillRetry = true;
+          log("[auto-update-checker] Companion update failed; will retry on restart:", companionResult.error);
+        } else if (companionResult.status === "skipped") {
+          log("[auto-update-checker] Companion update skipped:", companionResult.reason);
+        }
+      } catch (err) {
+        companionWillRetry = true;
+        log("[auto-update-checker] Companion update failed silently; will retry on restart:", err);
+      }
+    }
+    const messageLines = [`v${currentVersion} → v${latestVersion}`];
     if (installedSkills.length > 0) {
-      message = `v${currentVersion} → v${latestVersion}
-Added bundled skills: ${installedSkills.join(", ")}
-Restart OpenCode to apply.`;
+      messageLines.push(`Added bundled skills: ${installedSkills.join(", ")}`);
+    }
+    if (companionUpdated) {
+      messageLines.push("Companion updated.");
+    } else if (companionWillRetry) {
+      messageLines.push("Companion update will retry on restart.");
     }
-    showToast(ctx, "OMO-Slim Updated!", message, "success", 8000);
+    messageLines.push("Restart OpenCode to apply.");
+    showToast(ctx, "OMO-Slim Updated!", messageLines.join(`
+`), "success", 8000);
     log(`[auto-update-checker] Update installed: ${currentVersion} → ${latestVersion}`);
   } else {
     showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
@@ -23119,7 +23751,7 @@ class BackgroundJobBoard {
         existing.set(file.path, { ...file });
       }
     }
-    const contextFiles = [...existing.values()].filter((file) => file.lineCount >= this.readContextMinLines).sort((a, b) => b.lastReadAt - a.lastReadAt).slice(0, this.readContextMaxFiles + 1);
+    const contextFiles = [...existing.values()].filter((file) => file.lineCount >= this.readContextMinLines).sort((a, b) => b.lineCount - a.lineCount || b.lastReadAt - a.lastReadAt || a.path.localeCompare(b.path)).slice(0, this.readContextMaxFiles + 1);
     this.jobs.set(taskID, { ...job, contextFiles });
   }
   list(parentSessionID) {
@@ -23264,86 +23896,10 @@ function hasInternalInitiatorMarker(part) {
   }
   return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
 }
-// src/utils/zip-extractor.ts
-import { spawnSync } from "node:child_process";
-import { release } from "node:os";
-var WINDOWS_BUILD_WITH_TAR = 17134;
-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(path11) {
-  return path11.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}`);
-  }
-}
+
+// src/utils/index.ts
+init_zip_extractor();
+
 // src/hooks/chat-headers.ts
 var INTERNAL_MARKER_CACHE_LIMIT = 1000;
 var internalMarkerCache = new Map;
@@ -23848,17 +24404,17 @@ class ForegroundFallbackManager {
   }
 }
 // src/hooks/image-hook.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
   rmdirSync,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { basename as basename2, extname, join as join10 } from "node:path";
+import { basename as basename2, extname, join as join11 } from "node:path";
 var lastCleanupByDir = new Map;
 var CLEANUP_INTERVAL = 10 * 60 * 1000;
 function isImagePart(p) {
@@ -23906,12 +24462,12 @@ function cleanupAllSessions(saveDir) {
   const dirsToScan = [];
   try {
     for (const entry of readdirSync3(saveDir, { withFileTypes: true })) {
-      const fp = join10(saveDir, entry.name);
+      const fp = join11(saveDir, entry.name);
       if (entry.isDirectory()) {
         dirsToScan.push(fp);
       } else {
         try {
-          if (now - statSync3(fp).mtimeMs > maxAge)
+          if (now - statSync4(fp).mtimeMs > maxAge)
             unlinkSync2(fp);
         } catch {}
       }
@@ -23923,9 +24479,9 @@ function cleanupAllSessions(saveDir) {
       let allRemoved = true;
       for (const f of readdirSync3(dir)) {
         isEmpty = false;
-        const fp = join10(dir, f);
+        const fp = join11(dir, f);
         try {
-          if (now - statSync3(fp).mtimeMs > maxAge) {
+          if (now - statSync4(fp).mtimeMs > maxAge) {
             unlinkSync2(fp);
           } else {
             allRemoved = false;
@@ -23945,20 +24501,20 @@ function cleanupAllSessions(saveDir) {
 function writeUniqueFile(dir, name, data, log2) {
   const ext = extname(name);
   const base = basename2(name, ext) || name;
-  let candidate = join10(dir, name);
-  if (existsSync6(candidate)) {
+  let candidate = join11(dir, name);
+  if (existsSync7(candidate)) {
     return candidate;
   }
   let counter = 0;
   const MAX_ATTEMPTS = 1000;
   for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
     try {
-      writeFileSync4(candidate, data, { flag: "wx" });
+      writeFileSync5(candidate, data, { flag: "wx" });
       return candidate;
     } catch (e) {
       if (e instanceof Error && e.code === "EEXIST") {
         counter += 1;
-        candidate = join10(dir, `${base}-${counter}${ext}`);
+        candidate = join11(dir, `${base}-${counter}${ext}`);
         continue;
       }
       log2(`[image-hook] failed to save image: ${e}`);
@@ -23982,17 +24538,17 @@ function processImageAttachments(args) {
       messagesWithImages.push({ msg, imageParts });
     }
   }
-  const saveDir = join10(workDir, ".opencode", "images");
+  const saveDir = join11(workDir, ".opencode", "images");
   if (messagesWithImages.length === 0) {
-    if (existsSync6(saveDir))
+    if (existsSync7(saveDir))
       cleanupAllSessions(saveDir);
     return;
   }
-  const gitignorePath = join10(workDir, ".opencode", ".gitignore");
+  const gitignorePath = join11(workDir, ".opencode", ".gitignore");
   try {
-    mkdirSync4(saveDir, { recursive: true });
-    if (!existsSync6(gitignorePath))
-      writeFileSync4(gitignorePath, `*
+    mkdirSync5(saveDir, { recursive: true });
+    if (!existsSync7(gitignorePath))
+      writeFileSync5(gitignorePath, `*
 `);
   } catch (e) {
     log2(`[image-hook] failed to create image directory: ${e}`);
@@ -24000,9 +24556,9 @@ function processImageAttachments(args) {
   cleanupAllSessions(saveDir);
   for (const { msg, imageParts } of messagesWithImages) {
     const sessionSubdir = msg.info.sessionID ? sanitizeFilename(msg.info.sessionID) : undefined;
-    const targetDir = sessionSubdir ? join10(saveDir, sessionSubdir) : saveDir;
+    const targetDir = sessionSubdir ? join11(saveDir, sessionSubdir) : saveDir;
     try {
-      mkdirSync4(targetDir, { recursive: true });
+      mkdirSync5(targetDir, { recursive: true });
     } catch (e) {
       log2(`[image-hook] failed to create target image directory: ${e}`);
     }
@@ -24013,7 +24569,7 @@ function processImageAttachments(args) {
       if (url) {
         const decoded = decodeDataUrl(url);
         if (decoded) {
-          const hash = createHash("sha1").update(decoded.data).digest("hex").slice(0, 8);
+          const hash = createHash2("sha1").update(decoded.data).digest("hex").slice(0, 8);
           const sanitizedFilename = filename ? sanitizeFilename(filename) : undefined;
           const baseName = sanitizedFilename ? sanitizedFilename.replace(/\.[^.]+$/, "") || "image" : "image";
           const ext = sanitizedFilename ? extname(sanitizedFilename) || extFromMime(decoded.mime) : extFromMime(decoded.mime);
@@ -24204,18 +24760,7 @@ function createReflectCommandHook() {
   };
 }
 // src/hooks/task-session-manager/index.ts
-import path11 from "node:path";
-var AGENT_NAME_SET = new Set([
-  "orchestrator",
-  "oracle",
-  "designer",
-  "explorer",
-  "librarian",
-  "fixer",
-  "observer",
-  "council",
-  "councillor"
-]);
+import path12 from "node:path";
 var MAX_PENDING_TASK_CALLS = 100;
 var BACKGROUND_JOB_BOARD_SENTINEL = "SENTINEL: background-job-board-v2";
 var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
@@ -24247,9 +24792,6 @@ function createOccurrenceId(part, message, partIndex) {
   const hash = djb2Hash(`${sessionID}:${content}`);
   return `anon:${hash}`;
 }
-function isAgentName(value) {
-  return typeof value === "string" && AGENT_NAME_SET.has(value);
-}
 function extractPath(output) {
   return /<path>([^<]+)<\/path>/.exec(output)?.[1];
 }
@@ -24258,8 +24800,8 @@ function extractTaskSummary(output) {
   return summary?.trim() || undefined;
 }
 function normalizePath(root, file) {
-  const relative = path11.relative(root, file);
-  if (!relative || relative.startsWith("..") || path11.isAbsolute(relative)) {
+  const relative = path12.relative(root, file);
+  if (!relative || relative.startsWith("..") || path12.isAbsolute(relative)) {
     return file;
   }
   return relative;
@@ -24530,16 +25072,17 @@ function createTaskSessionManagerHook(_ctx, options) {
       if (!isRecord(output.args))
         return;
       const args = output.args;
-      if (!isAgentName(args.subagent_type)) {
+      if (typeof args.subagent_type !== "string" || args.subagent_type.trim() === "") {
         if (typeof args.task_id === "string" && args.task_id.trim() !== "") {
           delete args.task_id;
         }
         return;
       }
+      const agentType = args.subagent_type.trim();
       const label = deriveTaskSessionLabel({
         description: typeof args.description === "string" ? args.description : undefined,
         prompt: typeof args.prompt === "string" ? args.prompt : undefined,
-        agentType: args.subagent_type
+        agentType
       });
       const pendingCall = {
         callId: pendingCallId({
@@ -24547,7 +25090,7 @@ function createTaskSessionManagerHook(_ctx, options) {
           sessionID: input.sessionID
         }),
         parentSessionId: input.sessionID,
-        agentType: args.subagent_type,
+        agentType,
         label
       };
       rememberPendingCall(pendingCall);
@@ -24555,7 +25098,7 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       }
       const requested = args.task_id.trim();
-      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, args.subagent_type);
+      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, agentType);
       if (!remembered) {
         if (RAW_SESSION_ID_PATTERN.test(requested)) {
           pendingCall.resumedTaskId = requested;
@@ -24825,7 +25368,7 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
 `);
 }
 // src/interview/manager.ts
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/interview/dashboard.ts
 import crypto from "node:crypto";
@@ -24835,27 +25378,27 @@ import {
   createServer
 } from "node:http";
 import os4 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { URL as URL2 } from "node:url";
 
 // src/interview/document.ts
 import * as fsSync from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 var DEFAULT_OUTPUT_FOLDER = "interview";
 function normalizeOutputFolder(outputFolder) {
   const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
   return normalized || DEFAULT_OUTPUT_FOLDER;
 }
 function createInterviewDirectoryPath(directory, outputFolder) {
-  return path12.join(directory, normalizeOutputFolder(outputFolder));
+  return path13.join(directory, normalizeOutputFolder(outputFolder));
 }
 function createInterviewFilePath(directory, outputFolder, idea) {
   const fileName = `${slugify(idea) || "interview"}.md`;
-  return path12.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+  return path13.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
 }
 function relativeInterviewPath(directory, filePath) {
-  return path12.relative(directory, filePath) || path12.basename(filePath);
+  return path13.relative(directory, filePath) || path13.basename(filePath);
 }
 function resolveExistingInterviewPath(directory, outputFolder, value) {
   const trimmed = value.trim();
@@ -24864,22 +25407,22 @@ function resolveExistingInterviewPath(directory, outputFolder, value) {
   }
   const outputDir = createInterviewDirectoryPath(directory, outputFolder);
   const candidates = new Set;
-  const resolvedRoot = path12.resolve(directory);
-  if (path12.isAbsolute(trimmed)) {
+  const resolvedRoot = path13.resolve(directory);
+  if (path13.isAbsolute(trimmed)) {
     candidates.add(trimmed);
   } else {
-    candidates.add(path12.resolve(directory, trimmed));
-    candidates.add(path12.join(outputDir, trimmed));
+    candidates.add(path13.resolve(directory, trimmed));
+    candidates.add(path13.join(outputDir, trimmed));
     if (!trimmed.endsWith(".md")) {
-      candidates.add(path12.join(outputDir, `${trimmed}.md`));
+      candidates.add(path13.join(outputDir, `${trimmed}.md`));
     }
   }
   for (const candidate of candidates) {
-    if (path12.extname(candidate) !== ".md") {
+    if (path13.extname(candidate) !== ".md") {
       continue;
     }
-    const resolved = path12.resolve(candidate);
-    if (!resolved.startsWith(resolvedRoot + path12.sep) && resolved !== resolvedRoot) {
+    const resolved = path13.resolve(candidate);
+    if (!resolved.startsWith(resolvedRoot + path13.sep) && resolved !== resolvedRoot) {
       continue;
     }
     if (fsSync.existsSync(candidate)) {
@@ -24959,7 +25502,7 @@ function parseFrontmatter(content) {
   return result;
 }
 async function ensureInterviewFile(record) {
-  await fs6.mkdir(path12.dirname(record.markdownPath), { recursive: true });
+  await fs6.mkdir(path13.dirname(record.markdownPath), { recursive: true });
   try {
     await fs6.access(record.markdownPath);
   } catch {
@@ -26629,12 +27172,12 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
 // src/interview/dashboard.ts
 function getAuthFilePath(port) {
-  const dataHome = process.env.XDG_DATA_HOME || path13.join(os4.homedir(), ".local", "share");
-  return path13.join(dataHome, "opencode", `.dashboard-${port}.json`);
+  const dataHome = process.env.XDG_DATA_HOME || path14.join(os4.homedir(), ".local", "share");
+  return path14.join(dataHome, "opencode", `.dashboard-${port}.json`);
 }
 function writeAuthFile(port, token) {
   const filePath = getAuthFilePath(port);
-  const dir = path13.dirname(filePath);
+  const dir = path14.dirname(filePath);
   try {
     fsSync2.mkdirSync(dir, { recursive: true });
   } catch {}
@@ -26771,7 +27314,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     const items = [];
     for (const dir of directories) {
-      const interviewDir = path13.join(dir, config.outputFolder);
+      const interviewDir = path14.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -26783,7 +27326,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path13.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path14.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -26809,7 +27352,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     let rebuilt = 0;
     for (const dir of directories) {
-      const interviewDir = path13.join(dir, config.outputFolder);
+      const interviewDir = path14.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -26821,7 +27364,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path13.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path14.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -26847,7 +27390,7 @@ function createDashboardServer(config) {
           questions: [],
           pendingAnswers: null,
           lastUpdatedAt: fm.updatedAt ? new Date(fm.updatedAt).getTime() : Date.now(),
-          filePath: path13.join(interviewDir, entry),
+          filePath: path14.join(interviewDir, entry),
           nudgeAction: null
         });
         if (!sessions.has(fm.sessionID)) {
@@ -27111,7 +27654,7 @@ function createDashboardServer(config) {
         const dirs = getKnownDirectories();
         for (const dir of dirs) {
           const slug = extractResumeSlug(interviewId);
-          const candidate = path13.join(dir, config.outputFolder, `${slug}.md`);
+          const candidate = path14.join(dir, config.outputFolder, `${slug}.md`);
           try {
             document = await fs7.readFile(candidate, "utf8");
             markdownPath = candidate;
@@ -27639,7 +28182,7 @@ function createInterviewServer(deps) {
 // src/interview/service.ts
 import { spawn as spawn2 } from "node:child_process";
 import * as fs8 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // src/interview/types.ts
 import { z as z3 } from "zod";
@@ -27827,13 +28370,13 @@ function shouldAutoOpenBrowser(config, env) {
   return requested && !isAutomatedRuntime(env);
 }
 function openBrowser(url) {
-  const platform2 = process.platform;
+  const platform3 = process.platform;
   let command;
   let args;
-  if (platform2 === "darwin") {
+  if (platform3 === "darwin") {
     command = "open";
     args = [url];
-  } else if (platform2 === "win32") {
+  } else if (platform3 === "win32") {
     command = "cmd";
     args = ["/c", "start", "", url];
   } else {
@@ -27906,12 +28449,12 @@ function createInterviewService(ctx, config, deps) {
     if (!newSlug) {
       return;
     }
-    const currentFileName = path14.basename(interview.markdownPath, ".md");
+    const currentFileName = path15.basename(interview.markdownPath, ".md");
     if (currentFileName === newSlug) {
       return;
     }
-    const dir = path14.dirname(interview.markdownPath);
-    const newPath = path14.join(dir, `${newSlug}.md`);
+    const dir = path15.dirname(interview.markdownPath);
+    const newPath = path15.join(dir, `${newSlug}.md`);
     try {
       await fs8.access(newPath);
       return;
@@ -27987,9 +28530,9 @@ function createInterviewService(ctx, config, deps) {
     const messages = await loadMessages(sessionID);
     const title = extractTitle(document);
     const record = {
-      id: `${Date.now()}-${++idCounter}-${slugify(path14.basename(markdownPath, ".md")) || "interview"}`,
+      id: `${Date.now()}-${++idCounter}-${slugify(path15.basename(markdownPath, ".md")) || "interview"}`,
       sessionID,
-      idea: title || path14.basename(markdownPath, ".md"),
+      idea: title || path15.basename(markdownPath, ".md"),
       markdownPath,
       createdAt: nowIso(),
       status: "active",
@@ -28216,7 +28759,7 @@ function createInterviewService(ctx, config, deps) {
       return fileCache.items;
     }
     const outputDir = createInterviewDirectoryPath(ctx.directory, outputFolder);
-    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path14.resolve(i.markdownPath)));
+    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path15.resolve(i.markdownPath)));
     let entries;
     try {
       entries = await fs8.readdir(outputDir);
@@ -28227,8 +28770,8 @@ function createInterviewService(ctx, config, deps) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const fullPath = path14.join(outputDir, entry);
-      if (activePaths.has(path14.resolve(fullPath)))
+      const fullPath = path15.join(outputDir, entry);
+      if (activePaths.has(path15.resolve(fullPath)))
         continue;
       let content;
       try {
@@ -28327,7 +28870,7 @@ function createInterviewManager(ctx, config) {
   const outputFolder = interviewConfig?.outputFolder ?? "interview";
   if (!dashboardEnabled) {
     const service2 = createInterviewService(ctx, interviewConfig);
-    const resolvedOutputPath = path15.join(ctx.directory, outputFolder);
+    const resolvedOutputPath = path16.join(ctx.directory, outputFolder);
     const server = createInterviewServer({
       getState: async (interviewId) => service2.getInterviewState(interviewId),
       listInterviewFiles: async () => service2.listInterviewFiles(),
@@ -28432,7 +28975,7 @@ function createInterviewManager(ctx, config) {
               listInterviews: () => service.listInterviews(),
               submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
               handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
-              outputFolder: path15.join(ctx.directory, outputFolder),
+              outputFolder: path16.join(ctx.directory, outputFolder),
               port: 0
             });
             service.setBaseUrlResolver(() => perSessionServer.ensureStarted());
@@ -28700,6 +29243,7 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
 }
 
 // src/multiplexer/tmux/index.ts
+init_compat();
 var TMUX_LAYOUT_DEBOUNCE_MS = 150;
 
 class TmuxMultiplexer {
@@ -28917,23 +29461,23 @@ class TmuxMultiplexer {
         return null;
       }
       const stdout = await proc.stdout();
-      const path16 = stdout.trim().split(`
+      const path17 = stdout.trim().split(`
 `)[0];
-      if (!path16) {
+      if (!path17) {
         log("[tmux] findBinary: no path in output");
         return null;
       }
-      const verifyProc = crossSpawn([path16, "-V"], {
+      const verifyProc = crossSpawn([path17, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
       const verifyExit = await verifyProc.exited;
       if (verifyExit !== 0) {
-        log("[tmux] findBinary: tmux -V failed", { path: path16, verifyExit });
+        log("[tmux] findBinary: tmux -V failed", { path: path17, verifyExit });
         return null;
       }
-      log("[tmux] findBinary: found", { path: path16 });
-      return path16;
+      log("[tmux] findBinary: found", { path: path17 });
+      return path17;
     } catch (err) {
       log("[tmux] findBinary: exception", { error: String(err) });
       return null;
@@ -28945,6 +29489,8 @@ function quoteShellArg(value) {
 }
 
 // src/multiplexer/zellij/index.ts
+init_compat();
+
 class ZellijMultiplexer {
   paneMode;
   type = "zellij";
@@ -29884,22 +30430,359 @@ async function isServerRunning(serverUrl, timeoutMs = 3000, maxAttempts = 2) {
   }
   return false;
 }
-// src/tools/ast-grep/tools.ts
+// src/tools/acp-run.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createInterface } from "node:readline";
 import { tool } from "@opencode-ai/plugin";
+var z4 = tool.schema;
+
+class AcpClient {
+  name;
+  config;
+  cwd;
+  ask;
+  child;
+  next = 1;
+  pending = new Map;
+  chunks = [];
+  errors = [];
+  sessionId;
+  lastUpdate = Date.now();
+  authMethods = [];
+  active = false;
+  activeRequests = 0;
+  constructor(name, config, cwd, ask) {
+    this.name = name;
+    this.config = config;
+    this.cwd = cwd;
+    this.ask = ask;
+    this.child = spawn3(config.command, config.args, {
+      cwd,
+      env: { ...process.env, ...config.env },
+      stdio: "pipe"
+    });
+    this.child.stderr.on("data", (chunk) => {
+      this.errors.push(String(chunk));
+    });
+    this.child.stdin.on("error", (error) => {
+      this.errors.push(String(error));
+      this.rejectPending(error);
+    });
+    this.child.on("error", (error) => {
+      this.rejectPending(error);
+    });
+    this.child.on("exit", (code, signal) => {
+      if (this.pending.size === 0)
+        return;
+      this.rejectPending(new Error(`ACP agent '${name}' exited before replying (code ${code ?? "null"}, signal ${signal ?? "null"})`));
+    });
+    createInterface({ input: this.child.stdout }).on("line", (line) => {
+      this.receive(line).catch((error) => {
+        this.errors.push(String(error));
+      });
+    });
+  }
+  async run(prompt) {
+    const init = await this.request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+      clientInfo: {
+        name: "oh-my-opencode-slim",
+        title: "oh-my-opencode-slim ACP bridge"
+      }
+    });
+    this.authMethods = readAuthMethods(init);
+    const created = await this.newSession();
+    const sessionId = readSessionId(created);
+    this.sessionId = sessionId;
+    this.active = true;
+    await this.request("session/prompt", {
+      sessionId,
+      prompt: [{ type: "text", text: prompt }]
+    });
+    await this.drain();
+    this.active = false;
+    return this.output();
+  }
+  async newSession() {
+    try {
+      return await this.request("session/new", {
+        cwd: this.cwd,
+        mcpServers: []
+      });
+    } catch (error) {
+      if (!isAuthError(error) || this.authMethods.length === 0)
+        throw error;
+      const method = this.authMethods[0];
+      if (typeof method.id !== "string")
+        throw error;
+      await this.request("authenticate", { methodId: method.id });
+      return await this.request("session/new", {
+        cwd: this.cwd,
+        mcpServers: []
+      });
+    }
+  }
+  close() {
+    if (this.active && this.sessionId && !this.child.killed) {
+      this.notify("session/cancel", { sessionId: this.sessionId });
+    }
+    if (!this.child.killed)
+      this.child.kill("SIGTERM");
+  }
+  request(method, params) {
+    const id = this.next++;
+    const payload = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
+      this.child.stdin.write(`${JSON.stringify(payload)}
+`, (error) => {
+        if (!error)
+          return;
+        this.pending.delete(id);
+        reject(error);
+      });
+    });
+  }
+  notify(method, params) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
+`);
+  }
+  async drain() {
+    this.lastUpdate = Date.now();
+    while (this.activeRequests > 0 || Date.now() - this.lastUpdate < 100) {
+      await new Promise((resolve3) => setTimeout(resolve3, 25));
+    }
+  }
+  async receive(line) {
+    if (!line.trim())
+      return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      const error = new Error(`ACP agent '${this.name}' wrote non-JSON stdout: ${line.slice(0, 200)}`);
+      this.errors.push(error.message);
+      this.rejectPending(error);
+      this.close();
+      return;
+    }
+    if ("id" in message && (("result" in message) || ("error" in message))) {
+      const pending = this.pending.get(message.id);
+      if (!pending)
+        return;
+      this.pending.delete(message.id);
+      if (message.error) {
+        pending.reject(rpcError(message.error));
+        return;
+      }
+      pending.resolve(message.result);
+      return;
+    }
+    if ("id" in message && "method" in message) {
+      this.activeRequests++;
+      try {
+        await this.handleRequest(message);
+      } finally {
+        this.activeRequests--;
+        this.lastUpdate = Date.now();
+      }
+      return;
+    }
+    if ("method" in message)
+      this.handleNotification(message);
+  }
+  rejectPending(error) {
+    for (const item of this.pending.values())
+      item.reject(error);
+    this.pending.clear();
+  }
+  async handleRequest(message) {
+    if (message.method === "session/request_permission") {
+      const title = readPermissionTitle(message.params);
+      try {
+        if (this.config.permissionMode === "ask") {
+          await this.ask(title, message.params ?? {});
+        }
+        const optionId = selectPermissionOption(message.params, this.config.permissionMode);
+        if (!optionId)
+          throw new Error("ACP permission request had no usable option");
+        this.reply(message.id, {
+          outcome: { outcome: "selected", optionId }
+        });
+      } catch {
+        const optionId = selectPermissionOption(message.params, "reject");
+        if (optionId) {
+          this.reply(message.id, {
+            outcome: { outcome: "selected", optionId }
+          });
+          return;
+        }
+        this.reply(message.id, { outcome: { outcome: "cancelled" } });
+      }
+      return;
+    }
+    this.replyError(message.id, `Unsupported ACP client method: ${message.method}`);
+  }
+  handleNotification(message) {
+    if (message.method !== "session/update")
+      return;
+    this.lastUpdate = Date.now();
+    const update = message.params?.update;
+    if (!isRecord2(update))
+      return;
+    collectText(update, this.chunks);
+  }
+  reply(id, result) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}
+`);
+  }
+  replyError(id, message) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32601, message } })}
+`);
+  }
+  output() {
+    const text = this.chunks.join("").trim();
+    if (text)
+      return text;
+    const err = this.errors.join("").trim();
+    return err ? `ACP agent '${this.name}' completed without text output. stderr:
+${err}` : `ACP agent '${this.name}' completed without text output.`;
+  }
+}
+function createAcpRunTool(agents = {}) {
+  return tool({
+    description: "Run a configured external ACP-compatible coding agent and return its streamed result. Use for configured ACP agents such as Claude Code ACP, Gemini ACP, or custom ACP servers.",
+    args: {
+      agent: z4.string().describe("Configured ACP agent name"),
+      prompt: z4.string().describe("Task or question to send to the ACP agent"),
+      cwd: z4.string().optional().describe("Optional absolute working directory override"),
+      timeout_ms: z4.number().int().min(1000).max(900000).optional().describe("Optional timeout override in milliseconds")
+    },
+    async execute(args, ctx) {
+      if (ctx.agent !== args.agent) {
+        throw new Error(`acp_run for '${args.agent}' can only be used by @${args.agent}`);
+      }
+      const config = agents[args.agent];
+      if (!config) {
+        throw new Error(`Unknown ACP agent '${args.agent}'. Configured agents: ${Object.keys(agents).join(", ") || "(none)"}`);
+      }
+      const cwd = args.cwd ?? config.cwd ?? ctx.directory;
+      if (!cwd)
+        throw new Error("acp_run requires a working directory");
+      await ctx.ask({
+        permission: "bash",
+        patterns: [`${config.command} ${config.args.join(" ")}`.trim()],
+        always: [],
+        metadata: {
+          agent: args.agent,
+          cwd,
+          command: config.command,
+          args: config.args
+        }
+      });
+      const client = new AcpClient(args.agent, config, cwd, async (title, metadata) => {
+        if (config.permissionMode === "reject")
+          return;
+        await ctx.ask({
+          permission: "bash",
+          patterns: [`acp:${args.agent}:${title}`],
+          always: [],
+          metadata
+        });
+      });
+      const timeoutMs = args.timeout_ms ?? config.timeoutMs;
+      let timer;
+      const timeout = new Promise((_, reject) => timer = setTimeout(() => reject(new Error(`ACP agent '${args.agent}' timed out after ${timeoutMs}ms`)), timeoutMs));
+      const abort = () => client.close();
+      ctx.abort.addEventListener("abort", abort, { once: true });
+      try {
+        return await Promise.race([client.run(args.prompt), timeout]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+        ctx.abort.removeEventListener("abort", abort);
+        client.close();
+      }
+    }
+  });
+}
+function readSessionId(value) {
+  if (!isRecord2(value) || typeof value.sessionId !== "string") {
+    throw new Error("ACP agent did not return a sessionId");
+  }
+  return value.sessionId;
+}
+function readAuthMethods(value) {
+  if (!isRecord2(value) || !Array.isArray(value.authMethods))
+    return [];
+  const methods = value.authMethods;
+  return methods.filter(isRecord2);
+}
+function rpcError(error) {
+  const err = new Error(error.message ?? "ACP request failed");
+  err.code = error.code;
+  err.data = error.data;
+  return err;
+}
+function isAuthError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const meta = error;
+  return meta.code === -32001 || error.message.toLowerCase().includes("auth_required") || error.message.toLowerCase().includes("auth required");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPermissionTitle(params) {
+  const tool2 = isRecord2(params?.toolCall) ? params.toolCall : undefined;
+  if (typeof tool2?.title === "string")
+    return tool2.title;
+  if (typeof params?.permission === "string")
+    return params.permission;
+  return "ACP permission request";
+}
+function selectPermissionOption(params, mode) {
+  const options = Array.isArray(params?.options) ? params.options : [];
+  const choices = options.filter(isRecord2).filter((item) => typeof item.optionId === "string");
+  const reject = choices.find((item) => typeof item.kind === "string" && item.kind.startsWith("reject"));
+  if (mode === "reject")
+    return reject?.optionId;
+  const allow = choices.find((item) => typeof item.kind === "string" && item.kind.startsWith("allow"));
+  return allow?.optionId ?? reject?.optionId;
+}
+function collectText(update, chunks) {
+  if (update.sessionUpdate !== "agent_message_chunk")
+    return;
+  const text = readText(update.delta) ?? readText(update.content);
+  if (text)
+    chunks.push(text);
+}
+function readText(value) {
+  if (typeof value === "string")
+    return value;
+  if (isRecord2(value) && typeof value.text === "string")
+    return value.text;
+  return;
+}
+// src/tools/ast-grep/tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/tools/ast-grep/cli.ts
-import { existsSync as existsSync10 } from "node:fs";
+init_compat();
+import { existsSync as existsSync11 } from "node:fs";
 
 // src/tools/ast-grep/constants.ts
-import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync10, statSync as statSync5 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { dirname as dirname9, join as join15 } from "node:path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync6, unlinkSync as unlinkSync4 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir5 } from "node:os";
-import { join as join13 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join14 } from "node:path";
+init_compat();
 var REPO = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
 function getAstGrepVersion() {
@@ -29923,19 +30806,19 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join13(homedir5(), "AppData", "Local");
-    return join13(base2, "oh-my-opencode-slim", "bin");
+    const base2 = localAppData || join14(homedir6(), "AppData", "Local");
+    return join14(base2, "oh-my-opencode-slim", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join13(homedir5(), ".cache");
-  return join13(base, "oh-my-opencode-slim", "bin");
+  const base = xdgCache || join14(homedir6(), ".cache");
+  return join14(base, "oh-my-opencode-slim", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath() {
-  const binaryPath2 = join13(getCacheDir2(), getBinaryName());
-  return existsSync8(binaryPath2) ? binaryPath2 : null;
+  const binaryPath = join14(getCacheDir2(), getBinaryName());
+  return existsSync9(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -29946,34 +30829,34 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath2 = join13(cacheDir, binaryName);
-  if (existsSync8(binaryPath2)) {
-    return binaryPath2;
+  const binaryPath = join14(cacheDir, binaryName);
+  if (existsSync9(binaryPath)) {
+    return binaryPath;
   }
   const { arch, os: os5 } = platformInfo;
   const assetName = `app-${arch}-${os5}.zip`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
-    if (!existsSync8(cacheDir)) {
-      mkdirSync6(cacheDir, { recursive: true });
+    if (!existsSync9(cacheDir)) {
+      mkdirSync7(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join13(cacheDir, assetName);
+    const archivePath = join14(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await crossWrite(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync8(archivePath)) {
+    if (existsSync9(archivePath)) {
       unlinkSync4(archivePath);
     }
-    if (process.platform !== "win32" && existsSync8(binaryPath2)) {
-      chmodSync(binaryPath2, 493);
+    if (process.platform !== "win32" && existsSync9(binaryPath)) {
+      chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode-slim] ast-grep binary ready.`);
-    return binaryPath2;
+    return binaryPath;
   } catch (err) {
     console.error(`[oh-my-opencode-slim] Failed to download ast-grep: ${err instanceof Error ? err.message : err}`);
     return null;
@@ -30021,13 +30904,13 @@ var CLI_LANGUAGES = [
 var MIN_BINARY_SIZE = 1e4;
 function isValidBinary(filePath) {
   try {
-    return statSync4(filePath).size > MIN_BINARY_SIZE;
+    return statSync5(filePath).size > MIN_BINARY_SIZE;
   } catch {
     return false;
   }
 }
 function getPlatformPackageName() {
-  const platform2 = process.platform;
+  const platform3 = process.platform;
   const arch = process.arch;
   const platformMap = {
     "darwin-arm64": "@ast-grep/cli-darwin-arm64",
@@ -30038,7 +30921,7 @@ function getPlatformPackageName() {
     "win32-arm64": "@ast-grep/cli-win32-arm64-msvc",
     "win32-ia32": "@ast-grep/cli-win32-ia32-msvc"
   };
-  return platformMap[`${platform2}-${arch}`] ?? null;
+  return platformMap[`${platform3}-${arch}`] ?? null;
 }
 var resolvedCliPath = null;
 function findSgCliPathSync() {
@@ -30050,9 +30933,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire3(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname8(cliPkgPath);
-    const sgPath = join14(cliDir, binaryName);
-    if (existsSync9(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname9(cliPkgPath);
+    const sgPath = join15(cliDir, binaryName);
+    if (existsSync10(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -30061,19 +30944,19 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire3(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname8(pkgPath);
+      const pkgDir = dirname9(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath2 = join14(pkgDir, astGrepName);
-      if (existsSync9(binaryPath2) && isValidBinary(binaryPath2)) {
-        return binaryPath2;
+      const binaryPath = join15(pkgDir, astGrepName);
+      if (existsSync10(binaryPath) && isValidBinary(binaryPath)) {
+        return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path16 of homebrewPaths) {
-      if (existsSync9(path16) && isValidBinary(path16)) {
-        return path16;
+    for (const path17 of homebrewPaths) {
+      if (existsSync10(path17) && isValidBinary(path17)) {
+        return path17;
       }
     }
   }
@@ -30090,8 +30973,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path16) {
-  resolvedCliPath = path16;
+function setSgCliPath(path17) {
+  resolvedCliPath = path17;
 }
 var DEFAULT_TIMEOUT_MS = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -30101,7 +30984,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync10(currentPath)) {
+  if (currentPath !== "sg" && existsSync11(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -30109,7 +30992,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync10(syncPath)) {
+    if (syncPath && existsSync11(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -30148,7 +31031,7 @@ async function runSg(options) {
   const paths2 = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths2);
   let cliPath = getSgCliPath();
-  if (!existsSync10(cliPath) && cliPath !== "sg") {
+  if (!existsSync11(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -30364,14 +31247,14 @@ function showOutputToUser(context, output) {
   const ctx = context;
   ctx.metadata?.({ metadata: { output } });
 }
-var ast_grep_search = tool({
+var ast_grep_search = tool2({
   description: "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. " + "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " + "IMPORTANT: Patterns must be complete AST nodes (valid code). " + "For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. " + "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
   args: {
-    pattern: tool.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
-    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search (default: ['.'])"),
-    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-    context: tool.schema.number().optional().describe("Context lines around match")
+    pattern: tool2.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
+    lang: tool2.schema.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: tool2.schema.array(tool2.schema.string()).optional().describe("Paths to search (default: ['.'])"),
+    globs: tool2.schema.array(tool2.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+    context: tool2.schema.number().optional().describe("Context lines around match")
   },
   execute: async (args, context) => {
     try {
@@ -30400,15 +31283,15 @@ ${hint}`;
     }
   }
 });
-var ast_grep_replace = tool({
+var ast_grep_replace = tool2({
   description: "Replace code patterns across filesystem with AST-aware rewriting. " + "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " + "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
   args: {
-    pattern: tool.schema.string().describe("AST pattern to match"),
-    rewrite: tool.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
-    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
-    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs"),
-    dryRun: tool.schema.boolean().optional().describe("Preview changes without applying (default: true)")
+    pattern: tool2.schema.string().describe("AST pattern to match"),
+    rewrite: tool2.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
+    lang: tool2.schema.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: tool2.schema.array(tool2.schema.string()).optional().describe("Paths to search"),
+    globs: tool2.schema.array(tool2.schema.string()).optional().describe("Include/exclude globs"),
+    dryRun: tool2.schema.boolean().optional().describe("Preview changes without applying (default: true)")
   },
   execute: async (args, context) => {
     try {
@@ -30432,20 +31315,20 @@ var ast_grep_replace = tool({
 });
 // src/tools/cancel-task.ts
 import {
-  tool as tool2
+  tool as tool3
 } from "@opencode-ai/plugin";
-var z4 = tool2.schema;
+var z5 = tool3.schema;
 
 class SessionStillRunningError extends Error {
 }
 function createCancelTaskTool(options) {
-  const cancel_task = tool2({
+  const cancel_task = tool3({
     description: `Cancel a tracked background specialist task.
 
 Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accepts either the native task_id/session ID or the parent-scoped alias shown in the Background Job Board. Cancellation is not rollback: if cancelling a writer, inspect and reconcile partial file changes before replacing the lane.`,
     args: {
-      task_id: z4.string().describe("Tracked background task ID or Background Job Board alias"),
-      reason: z4.string().optional().describe("Short cancellation reason")
+      task_id: z5.string().describe("Tracked background task ID or Background Job Board alias"),
+      reason: z5.string().optional().describe("Short cancellation reason")
     },
     async execute(args, toolContext) {
       const parentSessionID = toolContext?.sessionID;
@@ -30658,7 +31541,7 @@ async function abortAndVerifySession(options, taskID) {
         attempts,
         status: statusSnapshot.status
       });
-      await delay(retryIntervalMs);
+      await delay2(retryIntervalMs);
       continue;
     }
     stableStoppedSince ??= Date.now();
@@ -30671,7 +31554,7 @@ async function abortAndVerifySession(options, taskID) {
       });
       return;
     }
-    await delay(retryIntervalMs);
+    await delay2(retryIntervalMs);
   }
   log("[cancel-task] abort verification timed out", {
     taskID,
@@ -30739,13 +31622,13 @@ async function deleteAndVerifySession(options, taskID, reason) {
     });
     if (status.status === "busy" || status.status === "retry") {
       stableStoppedSince = undefined;
-      await delay(retryIntervalMs);
+      await delay2(retryIntervalMs);
       continue;
     }
     stableStoppedSince ??= Date.now();
     if (Date.now() - stableStoppedSince >= stableStoppedMs)
       return;
-    await delay(retryIntervalMs);
+    await delay2(retryIntervalMs);
   }
   throw new SessionStillRunningError(`Session delete returned but task did not stay stopped: ${taskID} (${lastStatus ?? "unknown"})`);
 }
@@ -30784,7 +31667,7 @@ async function getSessionStatus(client, taskID) {
     return { status: undefined, source: "lookup-error", keys: [] };
   }
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function isSessionID(value) {
@@ -30826,9 +31709,9 @@ function unknownTaskOutput(taskID, message) {
 }
 // src/tools/council.ts
 import {
-  tool as tool3
+  tool as tool4
 } from "@opencode-ai/plugin";
-var z5 = tool3.schema;
+var z6 = tool4.schema;
 function formatModelComposition(councillorResults) {
   return councillorResults.map((cr) => {
     const shortModel = shortModelLabel(cr.model);
@@ -30836,15 +31719,15 @@ function formatModelComposition(councillorResults) {
   }).join(", ");
 }
 function createCouncilTool(_ctx, councilManager) {
-  const council_session = tool3({
+  const council_session = tool4({
     description: `Launch a multi-LLM council session for consensus-based analysis.
 
 Sends the prompt to multiple models (councillors) in parallel and returns their formatted responses for you to synthesize.
 
 Returns the councillor responses with a summary footer.`,
     args: {
-      prompt: z5.string().describe("The prompt to send to all councillors"),
-      preset: z5.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
+      prompt: z6.string().describe("The prompt to send to all councillors"),
+      preset: z6.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
     },
     async execute(args, toolContext) {
       if (!toolContext || typeof toolContext !== "object" || !("sessionID" in toolContext)) {
@@ -30896,14 +31779,14 @@ import * as fs10 from "node:fs";
 // src/tui-state.ts
 import * as fs9 from "node:fs";
 import * as os5 from "node:os";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 var STATE_DIR = "oh-my-opencode-slim";
 var STATE_FILE = "tui-state.json";
 function dataDir() {
-  return process.env.XDG_DATA_HOME ?? path16.join(os5.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME ?? path17.join(os5.homedir(), ".local", "share");
 }
 function getTuiStatePath() {
-  return path16.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
+  return path17.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
 }
 function emptySnapshot() {
   return {
@@ -30939,7 +31822,7 @@ async function readTuiSnapshotAsync() {
 function writeTuiSnapshot(snapshot) {
   try {
     const filePath = getTuiStatePath();
-    fs9.mkdirSync(path16.dirname(filePath), { recursive: true });
+    fs9.mkdirSync(path17.dirname(filePath), { recursive: true });
     fs9.writeFileSync(filePath, `${JSON.stringify(snapshot)}
 `);
   } catch {}
@@ -31139,14 +32022,14 @@ var BINARY_PREFIXES = [
 var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";
 // src/tools/smartfetch/tool.ts
 import os6 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 import {
-  tool as tool4
+  tool as tool5
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -31167,10 +32050,10 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
 async function saveBinary(binaryDir, data, contentType, filename) {
   await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path17.parse(initialName);
+  const parsed = path18.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path17.join(binaryDir, candidateName);
+    const file = path18.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -31309,7 +32192,7 @@ var M = class u2 {
     return this.#S;
   }
   constructor(e) {
-    let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z6, perf: x } = e;
+    let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z7, perf: x } = e;
     if (x !== undefined && typeof x?.now != "function")
       throw new TypeError("perf option must have a now() method if specified");
     if (this.#m = x ?? C, t !== 0 && !F(t))
@@ -31327,7 +32210,7 @@ var M = class u2 {
       throw new TypeError("memoMethod must be a function if defined");
     if (this.#U = m, a !== undefined && typeof a != "function")
       throw new TypeError("fetchMethod must be a function if specified");
-    if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({ length: t }).fill(undefined), this.#t = Array.from({ length: t }).fill(undefined), this.#a = new v(t), this.#c = new v(t), this.#l = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof l == "function" && (this.#w = l), typeof c == "function" && (this.#x = c), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#j = !!this.#x, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z6, this.maxEntrySize !== 0) {
+    if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({ length: t }).fill(undefined), this.#t = Array.from({ length: t }).fill(undefined), this.#a = new v(t), this.#c = new v(t), this.#l = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof l == "function" && (this.#w = l), typeof c == "function" && (this.#x = c), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#j = !!this.#x, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z7, this.maxEntrySize !== 0) {
       if (this.#u !== 0 && !F(this.#u))
         throw new TypeError("maxSize must be a positive integer if specified");
       if (!F(this.maxEntrySize))
@@ -31707,8 +32590,8 @@ var M = class u2 {
       let A = this.#p(b);
       if (!y && !A)
         return a && (a.fetch = "hit"), this.#L(b), s && this.#D(b), a && this.#E(a, b), d;
-      let z6 = this.#P(e, b, _, w), v = z6.__staleWhileFetching !== undefined && i;
-      return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = true)), v ? z6.__staleWhileFetching : z6.__returned = z6;
+      let z7 = this.#P(e, b, _, w), v = z7.__staleWhileFetching !== undefined && i;
+      return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = true)), v ? z7.__staleWhileFetching : z7.__returned = z7;
     }
   }
   forceFetch(e, t = {}) {
@@ -31824,7 +32707,7 @@ var M = class u2 {
 };
 
 // src/tools/smartfetch/network.ts
-import path18 from "node:path";
+import path19 from "node:path";
 
 // src/tools/smartfetch/utils.ts
 var import_readability = __toESM(require_readability(), 1);
@@ -32549,7 +33432,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path18.parse(name);
+  const parsed = path19.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -32719,9 +33602,9 @@ function isInvalidLlmsResult(fetchResult) {
 }
 
 // src/tools/smartfetch/secondary-model.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -32747,8 +33630,8 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path19.join(baseDir, file);
-    if (existsSync11(fullPath))
+    const fullPath = path20.join(baseDir, file);
+    if (existsSync12(fullPath))
       return fullPath;
   }
   return;
@@ -32764,7 +33647,7 @@ async function readOpenCodeConfigFile(configPath) {
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path19.join(directory, ".opencode");
+  const projectDir = path20.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -32845,6 +33728,29 @@ function isUsableSecondaryText(text) {
     return false;
   return true;
 }
+var SESSION_DELETE_RETRIES = 3;
+var SESSION_DELETE_RETRY_DELAY_MS = 500;
+var SECONDARY_MODEL_TIMEOUT_MS = 30000;
+var _testConfig = {
+  deleteRetryDelayMs: SESSION_DELETE_RETRY_DELAY_MS
+};
+async function deleteSessionSafely(client, sessionId, directory) {
+  for (let attempt = 1;attempt <= SESSION_DELETE_RETRIES; attempt++) {
+    try {
+      await client.session.delete({
+        path: { id: sessionId },
+        query: { directory }
+      });
+      return;
+    } catch (error) {
+      if (attempt >= SESSION_DELETE_RETRIES) {
+        console.warn(`[smartfetch] Failed to clean up secondary session ${sessionId} ` + `after ${SESSION_DELETE_RETRIES} attempts: ` + (error instanceof Error ? error.message : String(error)));
+        return;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, _testConfig.deleteRetryDelayMs));
+    }
+  }
+}
 async function runSecondaryModel(client, directory, model, prompt, content) {
   const session2 = await client.session.create({
     responseStyle: "data",
@@ -32871,23 +33777,26 @@ Note: only the first ${inputChars} characters of a longer fetched document were
     const toolIDsData = toolIDsResponse;
     const toolIDs = Array.isArray(toolIDsData.data) ? toolIDsData.data : Array.isArray(toolIDsResponse) ? toolIDsResponse : [];
     const disabledTools = Object.fromEntries((toolIDs || []).map((id) => [id, false]));
-    const result = await client.session.prompt({
-      responseStyle: "data",
-      throwOnError: true,
-      path: { id: sessionId },
-      query: { directory },
-      body: {
-        model,
-        system: "Answer only from the supplied content. Do not use tools or outside knowledge.",
-        tools: disabledTools,
-        parts: [
-          {
-            type: "text",
-            text: buildPrompt(truncatedContent, effectivePrompt)
-          }
-        ]
-      }
-    });
+    const result = await Promise.race([
+      client.session.prompt({
+        responseStyle: "data",
+        throwOnError: true,
+        path: { id: sessionId },
+        query: { directory },
+        body: {
+          model,
+          system: "Answer only from the supplied content. Do not use tools or outside knowledge.",
+          tools: disabledTools,
+          parts: [
+            {
+              type: "text",
+              text: buildPrompt(truncatedContent, effectivePrompt)
+            }
+          ]
+        }
+      }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("Secondary model timed out")), SECONDARY_MODEL_TIMEOUT_MS))
+    ]);
     const parts = result?.data?.parts ?? result?.parts ?? [];
     const text = parts.map((part) => part?.type === "text" ? part.text || "" : "").join("").trim();
     return {
@@ -32897,12 +33806,7 @@ Note: only the first ${inputChars} characters of a longer fetched document were
       sourceChars
     };
   } finally {
-    await client.session.delete({
-      path: { id: sessionId },
-      query: { directory }
-    }).catch(() => {
-      return;
-    });
+    await deleteSessionSafely(client, sessionId, directory);
   }
 }
 async function runSecondaryModelWithFallback(client, directory, models, prompt, content) {
@@ -32923,20 +33827,20 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 }
 
 // src/tools/smartfetch/tool.ts
-var z6 = tool4.schema;
+var z7 = tool5.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path20.join(os6.tmpdir(), "opencode-smartfetch");
-  return tool4({
+  const binaryDir = options.binaryDir || path21.join(os6.tmpdir(), "opencode-smartfetch");
+  return tool5({
     description: WEBFETCH_DESCRIPTION,
     args: {
-      url: z6.httpUrl(),
-      format: z6.enum(["text", "markdown", "html"]).default("markdown"),
-      timeout: z6.number().positive().max(MAX_TIMEOUT_SECONDS).optional().describe("Timeout in seconds, max 120."),
-      prompt: z6.string().optional().describe("Optional extraction task to run on the fetched content using a cheap secondary model."),
-      extract_main: z6.boolean().default(true),
-      prefer_llms_txt: z6.enum(["auto", "always", "never"]).default("auto"),
-      include_metadata: z6.boolean().default(true),
-      save_binary: z6.boolean().default(false).describe("Save binary payload to disk when it fits within the active download limit.")
+      url: z7.httpUrl(),
+      format: z7.enum(["text", "markdown", "html"]).default("markdown"),
+      timeout: z7.number().positive().max(MAX_TIMEOUT_SECONDS).optional().describe("Timeout in seconds, max 120."),
+      prompt: z7.string().optional().describe("Optional extraction task to run on the fetched content using a cheap secondary model."),
+      extract_main: z7.boolean().default(true),
+      prefer_llms_txt: z7.enum(["auto", "always", "never"]).default("auto"),
+      include_metadata: z7.boolean().default(true),
+      save_binary: z7.boolean().default(false).describe("Save binary payload to disk when it fits within the active download limit.")
     },
     async execute(args, ctx) {
       const secondaryModels = await readSecondaryModelFromConfig(ctx.directory || pluginCtx.directory);
@@ -33481,7 +34385,7 @@ async function appLog(ctx, level, message) {
 }
 var HEALTH_CHECK = {
   minAgents: 5,
-  minTools: 5,
+  minTools: 4,
   minMcps: 1
 };
 async function probeJSDOM() {
@@ -33526,6 +34430,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let companionManager;
   let councilTools;
   let cancelTaskTools;
+  let acpRunTools;
   let webfetch;
   let rewriteDisplayNameMentions;
   let toolCount = 0;
@@ -33570,6 +34475,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     depthTracker = new SubagentDepthTracker;
     councilTools = config.council ? createCouncilTool(ctx, new CouncilManager(ctx, config, depthTracker, multiplexerEnabled)) : {};
     mcps = createBuiltinMcps(config.disabled_mcps, config.websearch);
+    acpRunTools = Object.keys(config.acpAgents ?? {}).length > 0 ? { acp_run: createAcpRunTool(config.acpAgents) } : {};
     webfetch = createWebfetchTool(ctx);
     backgroundJobBoard = new BackgroundJobBoard({
       maxReusablePerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? 2,
@@ -33578,7 +34484,8 @@ var OhMyOpenCodeLite = async (ctx) => {
     });
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig, backgroundJobBoard);
     autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
-      autoUpdate: config.autoUpdate ?? true
+      autoUpdate: config.autoUpdate ?? true,
+      companion: config.companion
     });
     phaseReminderHook = createPhaseReminderHook();
     filterAvailableSkillsHook = createFilterAvailableSkillsHook(ctx, config);
@@ -33608,7 +34515,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       backgroundJobBoard,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
     });
-    toolCount = Object.keys(councilTools).length + Object.keys(cancelTaskTools).length + 1 + 2;
+    toolCount = Object.keys(councilTools).length + Object.keys(cancelTaskTools).length + Object.keys(acpRunTools).length + 1 + 2;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
     await appLog(ctx, "error", `INIT FAILED: ${String(err)}. Report at github.com/alvinunreal/oh-my-opencode-slim/issues/310`);
@@ -33644,6 +34551,22 @@ var OhMyOpenCodeLite = async (ctx) => {
       appLog(ctx, "warn", msg).catch(() => {});
     }
   });
+  if (config.companion?.enabled === true) {
+    try {
+      const companionResult = await ensureCompanionVersion({
+        config: config.companion,
+        downloadTimeoutMs: 3000,
+        lockTimeoutMs: 500
+      });
+      if (companionResult.status === "installed") {
+        log("[companion] updated before startup", companionResult.version);
+      } else if (companionResult.status === "failed") {
+        log("[companion] startup update failed", companionResult.error);
+      }
+    } catch (err) {
+      log("[companion] startup update failed", String(err));
+    }
+  }
   companionManager.onLoad();
   return {
     name: "oh-my-opencode-slim",
@@ -33651,6 +34574,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     tool: {
       ...councilTools,
       ...cancelTaskTools,
+      ...acpRunTools,
       webfetch,
       ast_grep_search,
       ast_grep_replace