oh-my-opencode 3.17.15 → 4.1.0

package/dist/cli/index.js

@@ -6214,14 +6214,119 @@ var init_model_versions = __esm(() => {
 // src/shared/migration/agent-category.ts
 var init_agent_category = () => {};
 
+// src/shared/classify-path-environment.ts
+import { homedir as homedir2 } from "os";
+import path3 from "path";
+function normalizeInputPath(absolutePath) {
+  return absolutePath.replaceAll("\\", "/");
+}
+function isUnderPath(normalizedPath, normalizedParentPath) {
+  return normalizedPath === normalizedParentPath || normalizedPath.startsWith(`${normalizedParentPath}/`);
+}
+function classifyPathEnvironment(absolutePath) {
+  if (absolutePath.length === 0)
+    return "unknown";
+  const normalizedPath = normalizeInputPath(absolutePath);
+  const lowercasePath = normalizedPath.toLowerCase();
+  if (lowercasePath.includes("/onedrive") || lowercasePath.includes("/onedrive/")) {
+    return "onedrive";
+  }
+  if (normalizedPath.includes("/Library/Mobile Documents/")) {
+    return "icloud";
+  }
+  if (isUnderPath(normalizedPath, "/Volumes")) {
+    return "network-drive";
+  }
+  if (normalizedPath.startsWith("/Users/") && (normalizedPath.includes("/Desktop/") || normalizedPath.endsWith("/Desktop") || normalizedPath.includes("/Documents/") || normalizedPath.endsWith("/Documents"))) {
+    return "desktop-sync";
+  }
+  const normalizedHome = normalizeInputPath(homedir2());
+  const desktopPath = normalizeInputPath(path3.join(normalizedHome, "Desktop"));
+  const documentsPath = normalizeInputPath(path3.join(normalizedHome, "Documents"));
+  if (isUnderPath(normalizedPath, desktopPath) || isUnderPath(normalizedPath, documentsPath)) {
+    return "desktop-sync";
+  }
+  return "unknown";
+}
+var init_classify_path_environment = () => {};
+
+// src/shared/fsync-skip-tracker.ts
+function recordFsyncSkip(entry) {
+  fsyncSkips.push({ ...entry, timestamp: Date.now() });
+  if (fsyncSkips.length > MAX_SKIPS) {
+    fsyncSkips.splice(0, fsyncSkips.length - MAX_SKIPS);
+  }
+}
+var MAX_SKIPS = 200, fsyncSkips;
+var init_fsync_skip_tracker = __esm(() => {
+  fsyncSkips = [];
+});
+
+// src/shared/tolerant-fsync.ts
+import { fsyncSync } from "fs";
+function isToleratedFsyncError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const code = error.code;
+  return code !== undefined && TOLERATED_FSYNC_CODES.has(code);
+}
+function extractPathFromContextLabel(contextLabel) {
+  const separatorIndex = contextLabel.indexOf(":");
+  if (separatorIndex < 0)
+    return contextLabel;
+  return contextLabel.slice(separatorIndex + 1);
+}
+function tolerantFsyncSync(fileDescriptor, contextLabel, fsyncImpl = fsyncSync) {
+  try {
+    fsyncImpl(fileDescriptor);
+  } catch (error) {
+    if (!isToleratedFsyncError(error))
+      throw error;
+    const errorCode = error.code ?? "UNKNOWN";
+    const message = error instanceof Error ? error.message : String(error);
+    const filePath = extractPathFromContextLabel(contextLabel);
+    log("fsync skipped due to filesystem limitation", {
+      event: "fsync-skipped",
+      contextLabel,
+      code: errorCode,
+      message
+    });
+    recordFsyncSkip({
+      filePath,
+      contextLabel,
+      errorCode,
+      message,
+      pathClassification: classifyPathEnvironment(filePath)
+    });
+  }
+}
+var TOLERATED_FSYNC_CODES;
+var init_tolerant_fsync = __esm(() => {
+  init_classify_path_environment();
+  init_fsync_skip_tracker();
+  init_logger();
+  TOLERATED_FSYNC_CODES = new Set([
+    "EPERM",
+    "EACCES",
+    "ENOTSUP",
+    "EINVAL"
+  ]);
+});
+
 // src/shared/write-file-atomically.ts
-import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "fs";
-function writeFileAtomically(filePath, content) {
+import {
+  closeSync,
+  openSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+function writeFileAtomically(filePath, content, deps = {}) {
   const tempPath = `${filePath}.tmp`;
   writeFileSync(tempPath, content, "utf-8");
-  const tempFileDescriptor = openSync(tempPath, "r");
+  const tempFileDescriptor = openSync(tempPath, "r+");
   try {
-    fsyncSync(tempFileDescriptor);
+    tolerantFsyncSync(tempFileDescriptor, `writeFileAtomically:${filePath}`, deps.fsyncSync);
   } finally {
     closeSync(tempFileDescriptor);
   }
@@ -6238,11 +6343,18 @@ function writeFileAtomically(filePath, content) {
     }
   }
 }
-var init_write_file_atomically = () => {};
+var init_write_file_atomically = __esm(() => {
+  init_tolerant_fsync();
+});
+
+// src/shared/record-type-guard.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 
 // src/shared/migration/migrations-sidecar.ts
 import * as fs2 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 function getSidecarPath(configPath) {
   return `${configPath}.migrations.json`;
 }
@@ -6254,8 +6366,8 @@ function readAppliedMigrations(configPath) {
     }
     const content = fs2.readFileSync(sidecarPath, "utf-8");
     const parsed = JSON.parse(content);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && Array.isArray(parsed.appliedMigrations)) {
-      return new Set(parsed.appliedMigrations.filter((m) => typeof m === "string"));
+    if (isRecord(parsed) && Array.isArray(parsed.appliedMigrations)) {
+      return new Set(parsed.appliedMigrations.filter((migration) => typeof migration === "string"));
     }
     return new Set;
   } catch (err) {
@@ -6269,7 +6381,7 @@ function writeAppliedMigrations(configPath, migrations) {
     appliedMigrations: Array.from(migrations).sort()
   };
   try {
-    const parentDir = path3.dirname(sidecarPath);
+    const parentDir = path4.dirname(sidecarPath);
     if (!fs2.existsSync(parentDir)) {
       fs2.mkdirSync(parentDir, { recursive: true });
     }
@@ -6462,7 +6574,7 @@ var init_migration = __esm(() => {
 
 // src/shared/opencode-config-dir.ts
 import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join5, resolve as resolve2, win32 } from "path";
 function isDevBuild(version) {
   if (!version)
@@ -6473,14 +6585,14 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join5(homedir2(), "Library", "Application Support", identifier);
+      return join5(homedir3(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join5(homedir2(), "AppData", "Roaming");
+      const appData = process.env.APPDATA || join5(homedir3(), "AppData", "Roaming");
       return win32.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir3(), ".config");
       return join5(xdgConfig, identifier);
     }
   }
@@ -6500,7 +6612,7 @@ function getCliConfigDir() {
   if (envConfigDir) {
     return resolveConfigPath(envConfigDir);
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir2(), ".config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join5(homedir3(), ".config");
   return resolveConfigPath(join5(xdgConfig, "opencode"));
 }
 function getOpenCodeConfigDir(options) {
@@ -6537,11 +6649,11 @@ var init_opencode_config_dir = __esm(() => {
 });
 
 // src/shared/resolve-agent-definition-paths.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
 function resolveAgentDefinitionPaths(paths, baseDir, containmentDir) {
   return paths.flatMap((p) => {
-    const expanded = p.startsWith("~/") ? p.replace(/^~\//, `${homedir3()}/`) : p;
+    const expanded = p.startsWith("~/") ? p.replace(/^~\//, `${homedir4()}/`) : p;
     const resolved = isAbsolute2(expanded) ? expanded : resolve3(baseDir, expanded);
     if (containmentDir !== null && !isWithinProject(resolved, containmentDir)) {
       log(`agent_definitions path rejected (outside project boundary): ${p} -> ${resolved}`);
@@ -6557,6 +6669,8 @@ var init_resolve_agent_definition_paths = __esm(() => {
 
 // src/shared/opencode-version.ts
 import { execSync } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 function parseVersion(version) {
   const cleaned = version.replace(/^v/, "").split("-")[0];
   return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
@@ -6575,12 +6689,51 @@ function compareVersions(a, b) {
   }
   return 0;
 }
-function getOpenCodeVersion() {
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function parsePackageVersion(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!isRecord2(parsed))
+      return null;
+    const name = parsed.name;
+    const version = parsed.version;
+    if (typeof name !== "string" || !name.includes("opencode"))
+      return null;
+    if (typeof version !== "string" || version.length === 0)
+      return null;
+    return version;
+  } catch {
+    return null;
+  }
+}
+function getPackageVersionFromBinary(binaryPath, deps) {
+  try {
+    const realBinaryPath = deps.realpath(binaryPath);
+    const packagePath = join6(dirname3(dirname3(realBinaryPath)), "package.json");
+    if (!deps.exists(packagePath))
+      return null;
+    return parsePackageVersion(deps.readText(packagePath));
+  } catch {
+    return null;
+  }
+}
+function getOpenCodeVersion(deps = {}) {
   if (cachedVersion !== NOT_CACHED) {
     return cachedVersion;
   }
+  const resolvedDeps = { ...defaultDeps, ...deps };
+  const binaryPath = resolvedDeps.getBinaryPath();
+  if (binaryPath) {
+    const packageVersion = getPackageVersionFromBinary(binaryPath, resolvedDeps);
+    if (packageVersion) {
+      cachedVersion = packageVersion;
+      return cachedVersion;
+    }
+  }
   try {
-    const result = execSync("opencode --version", {
+    const result = resolvedDeps.execCommand("opencode --version", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -6599,15 +6752,27 @@ function isOpenCodeVersionAtLeast(version) {
     return true;
   return compareVersions(current, version) >= 0;
 }
-var OPENCODE_SQLITE_VERSION = "1.1.53", NOT_CACHED, cachedVersion;
+var OPENCODE_SQLITE_VERSION = "1.1.53", NOT_CACHED, cachedVersion, defaultDeps;
 var init_opencode_version = __esm(() => {
   NOT_CACHED = Symbol("NOT_CACHED");
   cachedVersion = NOT_CACHED;
+  defaultDeps = {
+    execCommand: (command, options) => execSync(command, options),
+    getBinaryPath: () => {
+      const envPath = process.env.OPENCODE_BIN_PATH;
+      if (envPath)
+        return envPath;
+      return globalThis.Bun?.which("opencode") ?? null;
+    },
+    exists: existsSync5,
+    realpath: realpathSync4,
+    readText: (filePath) => readFileSync4(filePath, "utf-8")
+  };
 });
 
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 function isSqliteBackend() {
   if (cachedResult === true)
     return true;
@@ -6615,8 +6780,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join6(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync5(dbPath);
+    const dbPath = join7(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync6(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -6738,7 +6903,8 @@ function spawn(cmdOrOpts, opts) {
     cwd: options.cwd,
     env: options.env,
     stdio: resolveStdio(options),
-    detached: options.detached
+    detached: options.detached,
+    signal: options.signal
   });
   return wrapNodeProcess(proc);
 }
@@ -6793,15 +6959,23 @@ var init_zip_extractor = __esm(() => {
   init_zip_entry_listing();
 });
 
+// src/shared/bun-file-shim.ts
+var runtime2, IS_BUN2;
+var init_bun_file_shim = __esm(() => {
+  runtime2 = globalThis;
+  IS_BUN2 = typeof runtime2.Bun !== "undefined";
+});
+
 // src/shared/binary-downloader.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
-import * as path4 from "path";
+import { chmodSync, existsSync as existsSync7, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import * as path5 from "path";
 function getCachedBinaryPath(cacheDir, binaryName) {
-  const binaryPath = path4.join(cacheDir, binaryName);
-  return existsSync6(binaryPath) ? binaryPath : null;
+  const binaryPath = path5.join(cacheDir, binaryName);
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 var init_binary_downloader = __esm(() => {
   init_bun_spawn_shim();
+  init_bun_file_shim();
   init_archive_entry_validator();
   init_zip_extractor();
 });
@@ -6811,7 +6985,7 @@ function stripInvisibleAgentCharacters(agentName) {
   return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
 }
 function stripAgentListSortPrefix(agentName) {
-  return stripInvisibleAgentCharacters(agentName);
+  return stripInvisibleAgentCharacters(agentName).replace(VISIBLE_AGENT_LIST_SORT_PREFIX_REGEX, "").replace(AGENT_WRAPPER_CHARS_REGEX, "");
 }
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_NAMES[configKey];
@@ -6840,7 +7014,7 @@ function getAgentConfigKey(agentName) {
   const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase();
   return resolveKnownAgentConfigKey(agentName) ?? lower;
 }
-var AGENT_DISPLAY_NAMES, INVISIBLE_AGENT_CHARACTERS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
+var AGENT_DISPLAY_NAMES, INVISIBLE_AGENT_CHARACTERS_REGEX, VISIBLE_AGENT_LIST_SORT_PREFIX_REGEX, AGENT_WRAPPER_CHARS_REGEX, REVERSE_DISPLAY_NAMES, LEGACY_DISPLAY_NAMES;
 var init_agent_display_names = __esm(() => {
   AGENT_DISPLAY_NAMES = {
     sisyphus: "Sisyphus - Ultraworker",
@@ -6859,6 +7033,8 @@ var init_agent_display_names = __esm(() => {
     "council-member": "council-member"
   };
   INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g;
+  VISIBLE_AGENT_LIST_SORT_PREFIX_REGEX = /^\d+\|/;
+  AGENT_WRAPPER_CHARS_REGEX = /^[\\/"']+|[\\/"']+$/g;
   REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
   LEGACY_DISPLAY_NAMES = {
     "sisyphus (ultraworker)": "sisyphus",
@@ -6883,7 +7059,7 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         { providers: ["kimi-for-coding"], model: "k2p5" },
         {
           providers: [
@@ -6930,13 +7106,14 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
       ]
     },
     librarian: {
       fallbackChain: [
         { providers: ["openai"], model: "gpt-5.4-mini-fast" },
-        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7-highspeed" },
+        { providers: ["opencode-go"], model: "qwen3.5-plus" },
+        { providers: ["vercel"], model: "minimax-m2.7-highspeed" },
         { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
         { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
         { providers: ["openai", "opencode", "vercel"], model: "gpt-5.4-nano" }
@@ -6945,7 +7122,8 @@ var init_model_requirements = __esm(() => {
     explore: {
       fallbackChain: [
         { providers: ["openai"], model: "gpt-5.4-mini-fast" },
-        { providers: ["opencode-go", "vercel"], model: "minimax-m2.7-highspeed" },
+        { providers: ["opencode-go"], model: "qwen3.5-plus" },
+        { providers: ["vercel"], model: "minimax-m2.7-highspeed" },
         { providers: ["opencode-go", "vercel"], model: "minimax-m2.7" },
         { providers: ["anthropic", "opencode", "vercel"], model: "claude-haiku-4-5" },
         { providers: ["openai", "opencode", "vercel"], model: "gpt-5.4-nano" }
@@ -6954,7 +7132,7 @@ var init_model_requirements = __esm(() => {
     "multimodal-looker": {
       fallbackChain: [
         { providers: ["openai", "opencode", "vercel"], model: "gpt-5.5", variant: "medium" },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         { providers: ["zai-coding-plan", "vercel"], model: "glm-4.6v" },
         { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5-nano" }
       ]
@@ -6971,7 +7149,7 @@ var init_model_requirements = __esm(() => {
           model: "gpt-5.5",
           variant: "high"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
         {
           providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro"
@@ -6980,6 +7158,10 @@ var init_model_requirements = __esm(() => {
     },
     metis: {
       fallbackChain: [
+        {
+          providers: ["anthropic", "github-copilot", "opencode", "vercel"],
+          model: "claude-sonnet-4-6"
+        },
         {
           providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-opus-4-7",
@@ -6990,7 +7172,7 @@ var init_model_requirements = __esm(() => {
           model: "gpt-5.5",
           variant: "high"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
         { providers: ["kimi-for-coding"], model: "k2p5" }
       ]
     },
@@ -7011,13 +7193,13 @@ var init_model_requirements = __esm(() => {
           model: "gemini-3.1-pro",
           variant: "high"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
       ]
     },
     atlas: {
       fallbackChain: [
         { providers: ["anthropic", "github-copilot", "opencode", "vercel"], model: "claude-sonnet-4-6" },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         {
           providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.5",
@@ -7029,7 +7211,7 @@ var init_model_requirements = __esm(() => {
     "sisyphus-junior": {
       fallbackChain: [
         { providers: ["anthropic", "github-copilot", "opencode", "vercel"], model: "claude-sonnet-4-6" },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         {
           providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.5",
@@ -7054,7 +7236,7 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
         { providers: ["kimi-for-coding"], model: "k2p5" }
       ]
     },
@@ -7075,7 +7257,7 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" }
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
       ]
     },
     deep: {
@@ -7094,7 +7276,9 @@ var init_model_requirements = __esm(() => {
           providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3.1-pro",
           variant: "high"
-        }
+        },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
       ]
     },
     artistry: {
@@ -7109,9 +7293,10 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.5" }
-      ],
-      requiresModel: "gemini-3.1-pro"
+        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" }
+      ]
     },
     quick: {
       fallbackChain: [
@@ -7142,7 +7327,7 @@ var init_model_requirements = __esm(() => {
           model: "gpt-5.3-codex",
           variant: "medium"
         },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         {
           providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3-flash"
@@ -7164,7 +7349,7 @@ var init_model_requirements = __esm(() => {
         },
         { providers: ["zai-coding-plan", "opencode", "vercel"], model: "glm-5" },
         { providers: ["kimi-for-coding"], model: "k2p5" },
-        { providers: ["opencode-go", "vercel"], model: "glm-5" },
+        { providers: ["opencode-go", "vercel"], model: "glm-5.1" },
         { providers: ["opencode", "vercel"], model: "kimi-k2.5" },
         {
           providers: [
@@ -7186,7 +7371,7 @@ var init_model_requirements = __esm(() => {
           providers: ["google", "github-copilot", "opencode", "vercel"],
           model: "gemini-3-flash"
         },
-        { providers: ["opencode-go", "vercel"], model: "kimi-k2.5" },
+        { providers: ["opencode-go", "vercel"], model: "kimi-k2.6" },
         {
           providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-sonnet-4-6"
@@ -7241,8 +7426,8 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join9 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
@@ -7250,11 +7435,11 @@ function createJsonFileCacheStore(options) {
   let memoryValue;
   let writtenInCurrentProcess = false;
   function getCacheFilePath() {
-    return join8(options.getCacheDir(), options.filename);
+    return join9(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync7(cacheDir)) {
+    if (!existsSync8(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
   }
@@ -7263,13 +7448,13 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync7(cacheFile)) {
+    if (!existsSync8(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
     }
     try {
-      const content = readFileSync4(cacheFile, "utf-8");
+      const content = readFileSync5(cacheFile, "utf-8");
       const value = JSON.parse(content);
       memoryValue = value;
       log(`[${options.logPrefix}] Read ${toLogLabel(options.cacheLabel)}`, options.describe(value));
@@ -7289,7 +7474,7 @@ function createJsonFileCacheStore(options) {
     if (writtenInCurrentProcess) {
       return true;
     }
-    return existsSync7(getCacheFilePath());
+    return existsSync8(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7321,7 +7506,7 @@ var init_json_file_cache_store = __esm(() => {
 });
 
 // src/shared/connected-providers-cache.ts
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDir) {
@@ -7388,7 +7573,7 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
       for (const provider of allProviders) {
         if (provider.models) {
           const modelMetadata = Object.entries(provider.models).map(([modelID, rawMetadata]) => {
-            if (!isRecord(rawMetadata)) {
+            if (!isRecord3(rawMetadata)) {
               return { id: modelID };
             }
             const normalizedID = typeof rawMetadata.id === "string" ? rawMetadata.id : modelID;
@@ -7465,14 +7650,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { join as join10 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join9(getOpenCodeCacheDir(), "models.json");
-  return existsSync8(cacheFile);
+  const cacheFile = join10(getOpenCodeCacheDir(), "models.json");
+  return existsSync9(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -50000,20 +50185,19 @@ var init_model_capabilities_generated = __esm(() => {
 var SUPPLEMENTAL_MODEL_CAPABILITIES;
 var init_supplemental_entries = __esm(() => {
   SUPPLEMENTAL_MODEL_CAPABILITIES = {
-    "gpt-5.4-mini-fast": {
-      id: "gpt-5.4-mini-fast",
-      family: "gpt-mini",
+    "kimi-k2.6": {
+      id: "kimi-k2.6",
+      family: "kimi",
       reasoning: true,
-      temperature: false,
+      temperature: true,
       toolCall: true,
       modalities: {
-        input: ["text", "image"],
+        input: ["text", "image", "video"],
         output: ["text"]
       },
       limit: {
-        context: 400000,
-        input: 272000,
-        output: 128000
+        context: 262144,
+        output: 262144
       }
     },
     "gpt-5.5": {
@@ -50031,6 +50215,22 @@ var init_supplemental_entries = __esm(() => {
         input: 272000,
         output: 128000
       }
+    },
+    "gpt-5.4-mini-fast": {
+      id: "gpt-5.4-mini-fast",
+      family: "gpt-mini",
+      reasoning: true,
+      temperature: false,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 400000,
+        input: 272000,
+        output: 128000
+      }
     }
   };
 });
@@ -50128,8 +50328,8 @@ var init_model_capability_aliases = __esm(() => {
   PATTERN_ALIAS_RULES = [
     {
       ruleID: "claude-thinking-legacy-alias",
-      description: "Normalizes legacy Claude Opus thinking suffixes (4-6, 4-7) to the canonical snapshot ID.",
-      match: (normalizedModelID) => /^claude-opus-4-(?:6|7)-thinking$/.test(normalizedModelID),
+      description: "Normalizes the legacy claude-opus-4-7-thinking id to the canonical snapshot ID.",
+      match: (normalizedModelID) => /^claude-opus-4-7-thinking$/.test(normalizedModelID),
       canonicalize: () => "claude-opus-4-7"
     },
     {
@@ -50179,7 +50379,7 @@ var init_model_capability_heuristics = __esm(() => {
       family: "gpt-5",
       includes: ["gpt-5"],
       variants: ["low", "medium", "high", "xhigh"],
-      reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh"]
+      reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"]
     },
     {
       family: "gpt-legacy",
@@ -50218,7 +50418,13 @@ var init_model_capability_heuristics = __esm(() => {
     {
       family: "deepseek",
       includes: ["deepseek"],
-      variants: ["low", "medium", "high"]
+      variants: ["low", "medium", "high"],
+      reasoningEfforts: ["high", "max"],
+      reasoningEffortAliases: {
+        low: "high",
+        medium: "high",
+        xhigh: "max"
+      }
     },
     {
       family: "mistral",
@@ -50234,7 +50440,7 @@ var init_model_capability_heuristics = __esm(() => {
 });
 
 // src/shared/model-capabilities/runtime-model-readers.ts
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readNumber(value) {
@@ -50252,7 +50458,7 @@ function normalizeVariantKeys(value) {
   if (arrayVariants) {
     return arrayVariants.map((variant) => variant.toLowerCase());
   }
-  if (!isRecord2(value)) {
+  if (!isRecord4(value)) {
     return;
   }
   const variants = Object.keys(value).map((variant) => variant.toLowerCase());
@@ -50263,14 +50469,14 @@ function readModalityKeys(value) {
   if (stringArray) {
     return stringArray.map((entry) => entry.toLowerCase());
   }
-  if (!isRecord2(value)) {
+  if (!isRecord4(value)) {
     return;
   }
   const enabled = Object.entries(value).filter(([, supported]) => supported === true).map(([modality]) => modality.toLowerCase());
   return enabled.length > 0 ? enabled : undefined;
 }
 function normalizeModalities(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord4(value)) {
     return;
   }
   const input = readModalityKeys(value.input);
@@ -50284,7 +50490,7 @@ function normalizeModalities(value) {
   };
 }
 function readRuntimeModelCapabilities(runtimeModel) {
-  return isRecord2(runtimeModel?.capabilities) ? runtimeModel.capabilities : undefined;
+  return isRecord4(runtimeModel?.capabilities) ? runtimeModel.capabilities : undefined;
 }
 function readRuntimeModelBoolean(runtimeModel, keys) {
   const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel);
@@ -50301,7 +50507,7 @@ function readRuntimeModelBoolean(runtimeModel, keys) {
   return;
 }
 function readRuntimeModel(runtimeModel) {
-  return isRecord2(runtimeModel) ? runtimeModel : undefined;
+  return isRecord4(runtimeModel) ? runtimeModel : undefined;
 }
 function readRuntimeModelVariants(runtimeModel) {
   const rootVariants = normalizeVariantKeys(runtimeModel?.variants);
@@ -50349,8 +50555,8 @@ function readRuntimeModelToolCallSupport(runtimeModel) {
   return readRuntimeModelBoolean(runtimeModel, ["toolCall", "tool_call", "toolcall"]);
 }
 function readRuntimeModelLimitOutput(runtimeModel) {
-  const limit = isRecord2(runtimeModel?.limit) ? runtimeModel.limit : readRuntimeModelCapabilities(runtimeModel)?.limit;
-  if (!isRecord2(limit)) {
+  const limit = isRecord4(runtimeModel?.limit) ? runtimeModel.limit : readRuntimeModelCapabilities(runtimeModel)?.limit;
+  if (!isRecord4(limit)) {
     return;
   }
   return readNumber(limit.output);
@@ -50440,7 +50646,7 @@ var init_model_capabilities = __esm(() => {
 });
 
 // src/shared/model-capabilities-cache.ts
-function isRecord3(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readBoolean(value) {
@@ -50460,7 +50666,7 @@ function readStringArray2(value) {
   return result.length > 0 ? result : undefined;
 }
 function normalizeSnapshotEntry(rawModelID, rawModel) {
-  if (!isRecord3(rawModel)) {
+  if (!isRecord5(rawModel)) {
     return;
   }
   const id = readString(rawModel.id) ?? rawModelID;
@@ -50468,14 +50674,14 @@ function normalizeSnapshotEntry(rawModelID, rawModel) {
   const reasoning = readBoolean(rawModel.reasoning);
   const temperature = readBoolean(rawModel.temperature);
   const toolCall = readBoolean(rawModel.tool_call);
-  const rawModalities = isRecord3(rawModel.modalities) ? rawModel.modalities : undefined;
+  const rawModalities = isRecord5(rawModel.modalities) ? rawModel.modalities : undefined;
   const modalitiesInput = readStringArray2(rawModalities?.input);
   const modalitiesOutput = readStringArray2(rawModalities?.output);
   const modalities = modalitiesInput || modalitiesOutput ? {
     ...modalitiesInput ? { input: modalitiesInput } : {},
     ...modalitiesOutput ? { output: modalitiesOutput } : {}
   } : undefined;
-  const rawLimit = isRecord3(rawModel.limit) ? rawModel.limit : undefined;
+  const rawLimit = isRecord5(rawModel.limit) ? rawModel.limit : undefined;
   const limitContext = readNumber2(rawLimit?.context);
   const limitInput = readNumber2(rawLimit?.input);
   const limitOutput = readNumber2(rawLimit?.output);
@@ -50515,13 +50721,13 @@ function mergeSnapshotEntries(existing, incoming) {
 }
 function buildModelCapabilitiesSnapshotFromModelsDev(raw) {
   const models = {};
-  const providers = isRecord3(raw) ? raw : {};
+  const providers = isRecord5(raw) ? raw : {};
   for (const providerValue of Object.values(providers)) {
-    if (!isRecord3(providerValue)) {
+    if (!isRecord5(providerValue)) {
       continue;
     }
     const providerModels = providerValue.models;
-    if (!isRecord3(providerModels)) {
+    if (!isRecord5(providerModels)) {
       continue;
     }
     for (const [rawModelID, rawModel] of Object.entries(providerModels)) {
@@ -50617,19 +50823,19 @@ var init_constants = __esm(() => {
 });
 
 // src/shared/opencode-storage-paths.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join10(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join10(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join10(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join11(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join11(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join11(OPENCODE_STORAGE, "session");
 });
 
 // src/shared/compaction-marker.ts
-import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync6 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
 }
@@ -50643,20 +50849,20 @@ function isCompactionMessage(message) {
   return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
 }
 function getCompactionPartStorageDir(messageID) {
-  return join11(PART_STORAGE, messageID);
+  return join12(PART_STORAGE, messageID);
 }
 function hasCompactionPartInStorage(messageID) {
   if (!messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync9(partDir)) {
+  if (!existsSync10(partDir)) {
     return false;
   }
   try {
     return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
       try {
-        const content = readFileSync6(join11(partDir, fileName), "utf-8");
+        const content = readFileSync7(join12(partDir, fileName), "utf-8");
         return isCompactionPart(JSON.parse(content));
       } catch {
         return false;
@@ -50689,23 +50895,23 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync2 } from "fs";
+import { join as join13 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync10(MESSAGE_STORAGE))
+  if (!existsSync11(MESSAGE_STORAGE))
     return null;
-  const directPath = join12(MESSAGE_STORAGE, sessionID);
-  if (existsSync10(directPath)) {
+  const directPath = join13(MESSAGE_STORAGE, sessionID);
+  if (existsSync11(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join12(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync10(sessionPath)) {
+      const sessionPath = join13(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync11(sessionPath)) {
         return sessionPath;
       }
     }
@@ -50728,10 +50934,18 @@ var init_session_utils = __esm(() => {
   init_logger();
   init_agent_display_names();
 });
+
+// src/shared/event-session-id.ts
+var init_event_session_id = () => {};
 // src/shared/tmux/constants.ts
-var SESSION_TIMEOUT_MS;
+var SESSION_TIMEOUT_MS, SESSION_MISSING_GRACE_MS;
 var init_constants2 = __esm(() => {
-  SESSION_TIMEOUT_MS = 10 * 60 * 1000;
+  SESSION_TIMEOUT_MS = 60 * 60 * 1000;
+  SESSION_MISSING_GRACE_MS = 30 * 1000;
+});
+// src/shared/tmux/runner.ts
+var init_runner = __esm(() => {
+  init_bun_spawn_shim();
 });
 // src/shared/tmux/tmux-utils/server-health.ts
 var SERVER_RUNNING_KEY;
@@ -50746,32 +50960,27 @@ var init_tmux_path_resolver = __esm(() => {
 
 // src/shared/tmux/tmux-utils/pane-dimensions.ts
 var init_pane_dimensions = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
 });
 
 // src/shared/tmux/tmux-utils/pane-spawn.ts
 var init_pane_spawn = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
   init_server_health();
 });
 // src/shared/tmux/tmux-utils/pane-replace.ts
 var init_pane_replace = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
 });
 
 // src/shared/tmux/tmux-utils/window-spawn.ts
 var init_window_spawn = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
   init_server_health();
 });
 
 // src/shared/tmux/tmux-utils/session-spawn.ts
 var init_session_spawn = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
   init_server_health();
 });
@@ -50780,7 +50989,6 @@ var init_stale_session_sweep = () => {};
 
 // src/shared/tmux/tmux-utils/layout.ts
 var init_layout = __esm(() => {
-  init_bun_spawn_shim();
   init_tmux_path_resolver();
 });
 
@@ -50799,6 +51007,7 @@ var init_tmux_utils = __esm(() => {
 // src/shared/tmux/index.ts
 var init_tmux = __esm(() => {
   init_constants2();
+  init_runner();
   init_tmux_utils();
 });
 // src/shared/model-suggestion-retry.ts
@@ -50816,7 +51025,7 @@ function getServerBasicAuthHeader() {
   const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
   return `Basic ${token}`;
 }
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function isRequestFetch(value) {
@@ -50830,11 +51039,11 @@ function wrapRequestFetch(baseFetch, auth) {
   };
 }
 function getInternalClient(client) {
-  if (!isRecord4(client)) {
+  if (!isRecord6(client)) {
     return null;
   }
   const internal = client["_client"];
-  return isRecord4(internal) ? internal : null;
+  return isRecord6(internal) ? internal : null;
 }
 function tryInjectViaSetConfigHeaders(internal, auth) {
   const setConfig = internal["setConfig"];
@@ -50850,11 +51059,11 @@ function tryInjectViaSetConfigHeaders(internal, auth) {
 }
 function tryInjectViaInterceptors(internal, auth) {
   const interceptors = internal["interceptors"];
-  if (!isRecord4(interceptors)) {
+  if (!isRecord6(interceptors)) {
     return false;
   }
   const requestInterceptors = interceptors["request"];
-  if (!isRecord4(requestInterceptors)) {
+  if (!isRecord6(requestInterceptors)) {
     return false;
   }
   const use = requestInterceptors["use"];
@@ -50876,7 +51085,7 @@ function tryInjectViaFetchWrapper(internal, auth) {
     return false;
   }
   const config = getConfig();
-  if (!isRecord4(config)) {
+  if (!isRecord6(config)) {
     return false;
   }
   const fetchValue = config["fetch"];
@@ -50890,7 +51099,7 @@ function tryInjectViaFetchWrapper(internal, auth) {
 }
 function tryInjectViaMutableInternalConfig(internal, auth) {
   const configValue = internal["_config"];
-  if (!isRecord4(configValue)) {
+  if (!isRecord6(configValue)) {
     return false;
   }
   const fetchValue = configValue["fetch"];
@@ -50901,7 +51110,7 @@ function tryInjectViaMutableInternalConfig(internal, auth) {
   return true;
 }
 function tryInjectViaTopLevelFetch(client, auth) {
-  if (!isRecord4(client)) {
+  if (!isRecord6(client)) {
     return false;
   }
   const fetchValue = client["fetch"];
@@ -50949,6 +51158,7 @@ var init_opencode_provider_auth = __esm(() => {
   init_data_path();
   init_logger();
 });
+
 // src/shared/opencode-http-api.ts
 var init_opencode_http_api = __esm(() => {
   init_opencode_server_auth();
@@ -50956,18 +51166,46 @@ var init_opencode_http_api = __esm(() => {
 });
 
 // src/shared/port-utils.ts
+import { createServer } from "net";
 async function isPortAvailable(port, hostname = "127.0.0.1") {
-  try {
-    const server = Bun.serve({
-      port,
-      hostname,
-      fetch: () => new Response
+  return new Promise((resolve4) => {
+    const server = createServer();
+    let timeoutId;
+    let resolved = false;
+    const finish = (isAvailable) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      server.removeAllListeners("error");
+      server.removeAllListeners("listening");
+      resolve4(isAvailable);
+    };
+    const closeThenFinish = (isAvailable) => {
+      try {
+        server.close(() => finish(isAvailable));
+      } catch {
+        finish(isAvailable);
+      }
+    };
+    timeoutId = setTimeout(() => {
+      closeThenFinish(false);
+    }, PORT_CHECK_TIMEOUT_MS);
+    server.once("error", () => {
+      finish(false);
     });
-    server.stop(true);
-    return true;
-  } catch {
-    return false;
-  }
+    server.once("listening", () => {
+      closeThenFinish(true);
+    });
+    try {
+      server.listen(port, hostname);
+    } catch {
+      finish(false);
+    }
+  });
 }
 async function findAvailablePort(startPort = DEFAULT_SERVER_PORT, hostname = "127.0.0.1") {
   for (let attempt = 0;attempt < MAX_PORT_ATTEMPTS; attempt++) {
@@ -50985,7 +51223,7 @@ async function getAvailableServerPort(preferredPort = DEFAULT_SERVER_PORT, hostn
   const port = await findAvailablePort(preferredPort + 1, hostname);
   return { port, wasAutoSelected: true };
 }
-var DEFAULT_SERVER_PORT = 4096, MAX_PORT_ATTEMPTS = 20;
+var DEFAULT_SERVER_PORT = 4096, MAX_PORT_ATTEMPTS = 20, PORT_CHECK_TIMEOUT_MS = 2000;
 var init_port_utils = () => {};
 // src/shared/git-worktree/parse-status-porcelain.ts
 var init_parse_status_porcelain = () => {};
@@ -51009,14 +51247,57 @@ var init_opencode_command_dirs = __esm(() => {
 });
 
 // src/shared/project-discovery-dirs.ts
+import { existsSync as existsSync12, realpathSync as realpathSync5 } from "fs";
+import { dirname as dirname4, join as join14, resolve as resolve4 } from "path";
+function normalizePath(path6) {
+  const resolvedPath = resolve4(path6);
+  if (!existsSync12(resolvedPath)) {
+    return resolvedPath;
+  }
+  try {
+    return realpathSync5(resolvedPath);
+  } catch {
+    return resolvedPath;
+  }
+}
+function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
+  const paths = [];
+  const seen = new Set;
+  let currentDirectory = normalizePath(startDirectory);
+  const resolvedStopDirectory = stopDirectory ? normalizePath(stopDirectory) : undefined;
+  while (true) {
+    const opencodeDirectory = join14(currentDirectory, ".opencode");
+    if (existsSync12(opencodeDirectory)) {
+      const detected = detectPluginConfigFile(opencodeDirectory);
+      if (detected.format !== "none" && !seen.has(detected.path)) {
+        seen.add(detected.path);
+        paths.push(detected.path);
+      }
+    }
+    if (resolvedStopDirectory === currentDirectory) {
+      return paths;
+    }
+    const parentDirectory = dirname4(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return paths;
+    }
+    currentDirectory = normalizePath(parentDirectory);
+  }
+}
 var worktreePathCache;
 var init_project_discovery_dirs = __esm(() => {
+  init_jsonc_parser();
   worktreePathCache = new Map;
 });
 
 // src/shared/session-directory-resolver.ts
 var init_session_directory_resolver = () => {};
 
+// src/shared/session-route.ts
+var init_session_route = __esm(() => {
+  init_model_suggestion_retry();
+});
+
 // src/shared/session-tools-store.ts
 var store;
 var init_session_tools_store = __esm(() => {
@@ -51103,6 +51384,7 @@ var init_mcp_server_loader = __esm(() => {
   init_scope_filter2();
   init_transformer();
   init_logger();
+  init_bun_file_shim();
 });
 
 // src/features/claude-code-plugin-loader/hook-loader.ts
@@ -51264,6 +51546,7 @@ var init_shared = __esm(() => {
   init_connected_providers_cache();
   init_context_limit_resolver();
   init_session_utils();
+  init_event_session_id();
   init_tmux();
   init_model_suggestion_retry();
   init_opencode_server_auth();
@@ -51277,6 +51560,7 @@ var init_shared = __esm(() => {
   init_opencode_command_dirs();
   init_project_discovery_dirs();
   init_session_directory_resolver();
+  init_session_route();
   init_prompt_tools();
   init_compaction_marker();
   init_internal_initiator_marker();
@@ -51362,17 +51646,17 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname3 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname5 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync11(configPath)) {
+  if (!existsSync13(configPath)) {
     return { success: true };
   }
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp2}`;
   try {
-    const dir = dirname3(backupPath);
-    if (!existsSync11(dir)) {
+    const dir = dirname5(backupPath);
+    if (!existsSync13(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
@@ -51387,10 +51671,10 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync12(configDir)) {
+  if (!existsSync14(configDir)) {
     mkdirSync6(configDir, { recursive: true });
   }
 }
@@ -51428,14 +51712,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync13(configJsonc)) {
+  if (existsSync15(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync13(configJson)) {
+  if (existsSync15(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -51445,33 +51729,33 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync7, statSync } from "fs";
+import { readFileSync as readFileSync8, statSync } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
-function parseOpenCodeConfigFileWithError(path5) {
+function parseOpenCodeConfigFileWithError(path6) {
   try {
-    const stat = statSync(path5);
+    const stat = statSync(path6);
     if (stat.size === 0) {
-      return { config: null, error: `Config file is empty: ${path5}. Delete it or add valid JSON content.` };
+      return { config: null, error: `Config file is empty: ${path6}. Delete it or add valid JSON content.` };
     }
-    const content = readFileSync7(path5, "utf-8");
+    const content = readFileSync8(path6, "utf-8");
     if (isEmptyOrWhitespace(content)) {
-      return { config: null, error: `Config file contains only whitespace: ${path5}. Delete it or add valid JSON content.` };
+      return { config: null, error: `Config file contains only whitespace: ${path6}. Delete it or add valid JSON content.` };
     }
     const config = parseJsonc(content);
     if (config == null) {
-      return { config: null, error: `Config file parsed to null/undefined: ${path5}. Ensure it contains valid JSON.` };
+      return { config: null, error: `Config file parsed to null/undefined: ${path6}. Ensure it contains valid JSON.` };
     }
     if (typeof config !== "object" || Array.isArray(config)) {
       return {
         config: null,
-        error: `Config file must contain a JSON object, not ${Array.isArray(config) ? "an array" : typeof config}: ${path5}`
+        error: `Config file must contain a JSON object, not ${Array.isArray(config) ? "an array" : typeof config}: ${path6}`
       };
     }
     return { config };
   } catch (err) {
-    return { config: null, error: formatErrorWithSuggestion(err, `parse config file ${path5}`) };
+    return { config: null, error: formatErrorWithSuggestion(err, `parse config file ${path6}`) };
   }
 }
 var init_parse_opencode_config_file = __esm(() => {
@@ -51561,7 +51845,7 @@ function extractVersionFromPluginEntry(entry) {
 }
 
 // src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 async function addPluginToOpenCodeConfig(currentVersion) {
   try {
     ensureConfigDirectoryExists();
@@ -51572,20 +51856,20 @@ async function addPluginToOpenCodeConfig(currentVersion) {
       error: formatErrorWithSuggestion(err, "create config directory")
     };
   }
-  const { format: format2, path: path5 } = detectConfigFormat();
+  const { format: format2, path: path6 } = detectConfigFormat();
   const pluginEntry = await getPluginNameWithVersion(currentVersion, PLUGIN_NAME);
   try {
     if (format2 === "none") {
       const config2 = { plugin: [pluginEntry] };
-      writeFileSync3(path5, JSON.stringify(config2, null, 2) + `
+      writeFileSync3(path6, JSON.stringify(config2, null, 2) + `
 `);
-      return { success: true, configPath: path5 };
+      return { success: true, configPath: path6 };
     }
-    const parseResult = parseOpenCodeConfigFileWithError(path5);
+    const parseResult = parseOpenCodeConfigFileWithError(path6);
     if (!parseResult.config) {
       return {
         success: false,
-        configPath: path5,
+        configPath: path6,
         error: parseResult.error ?? "Failed to parse config file"
       };
     }
@@ -51601,15 +51885,15 @@ async function addPluginToOpenCodeConfig(currentVersion) {
       if (!compatibility.canUpgrade) {
         return {
           success: false,
-          configPath: path5,
+          configPath: path6,
           error: compatibility.reason ?? "Version compatibility check failed"
         };
       }
-      const backupResult = backupConfigFile(path5);
+      const backupResult = backupConfigFile(path6);
       if (!backupResult.success) {
         return {
           success: false,
-          configPath: path5,
+          configPath: path6,
           error: `Failed to create backup: ${backupResult.error}`
         };
       }
@@ -51618,7 +51902,7 @@ async function addPluginToOpenCodeConfig(currentVersion) {
     normalizedPlugins.push(pluginEntry);
     config.plugin = normalizedPlugins;
     if (format2 === "jsonc") {
-      const content = readFileSync8(path5, "utf-8");
+      const content = readFileSync9(path6, "utf-8");
       const pluginArrayRegex = /((?:"plugin"|plugin)\s*:\s*)\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -51627,21 +51911,21 @@ async function addPluginToOpenCodeConfig(currentVersion) {
         const newContent = content.replace(pluginArrayRegex, `$1[
     ${formattedPlugins}
   ]`);
-        writeFileSync3(path5, newContent);
+        writeFileSync3(path6, newContent);
       } else {
         const newContent = content.replace(/(\{)/, `$1
   "plugin": ["${pluginEntry}"],`);
-        writeFileSync3(path5, newContent);
+        writeFileSync3(path6, newContent);
       }
     } else {
-      writeFileSync3(path5, JSON.stringify(config, null, 2) + `
+      writeFileSync3(path6, JSON.stringify(config, null, 2) + `
 `);
     }
-    return { success: true, configPath: path5 };
+    return { success: true, configPath: path6 };
   } catch (err) {
     return {
       success: false,
-      configPath: path5,
+      configPath: path6,
       error: formatErrorWithSuggestion(err, "update opencode config")
     };
   }
@@ -51878,7 +52162,7 @@ function generateModelConfig(config) {
       if (avail.native.openai) {
         agentConfig = { model: "openai/gpt-5.4-mini-fast" };
       } else if (avail.opencodeGo) {
-        agentConfig = { model: "opencode-go/minimax-m2.7" };
+        agentConfig = { model: "opencode-go/qwen3.5-plus" };
       } else if (avail.zai) {
         agentConfig = { model: ZAI_MODEL };
       } else if (avail.vercelAiGateway) {
@@ -51898,7 +52182,7 @@ function generateModelConfig(config) {
       } else if (avail.opencodeZen) {
         agentConfig = { model: "opencode/claude-haiku-4-5" };
       } else if (avail.opencodeGo) {
-        agentConfig = { model: "opencode-go/minimax-m2.7" };
+        agentConfig = { model: "opencode-go/qwen3.5-plus" };
       } else if (avail.copilot) {
         agentConfig = { model: "github-copilot/gpt-5-mini" };
       } else if (avail.vercelAiGateway) {
@@ -51978,12 +52262,12 @@ var init_generate_omo_config = __esm(() => {
 });
 
 // src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9, renameSync as renameSync2, rmSync } from "fs";
-import { join as join13, dirname as dirname4, basename as basename2 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync10, renameSync as renameSync2, rmSync } from "fs";
+import { join as join15, dirname as dirname6, basename as basename2 } from "path";
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname4(legacyPath);
+  const dir = dirname6(legacyPath);
   const ext = basename2(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join13(dir, `${CONFIG_BASENAME}${ext}`);
+  return join15(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -52016,13 +52300,13 @@ function archiveLegacyConfigFile(legacyPath) {
 }
 function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   const legacySidecarPath = getSidecarPath(legacyPath);
-  if (!existsSync14(legacySidecarPath))
+  if (!existsSync16(legacySidecarPath))
     return true;
   const canonicalSidecarPath = getSidecarPath(canonicalPath);
-  if (existsSync14(canonicalSidecarPath))
+  if (existsSync16(canonicalSidecarPath))
     return true;
   try {
-    const content = readFileSync9(legacySidecarPath, "utf-8");
+    const content = readFileSync10(legacySidecarPath, "utf-8");
     writeFileAtomically(canonicalSidecarPath, content);
     log("[migrateLegacyConfigFile] Migrated legacy migration sidecar to canonical path", {
       from: legacySidecarPath,
@@ -52039,15 +52323,15 @@ function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync14(legacyPath))
+  if (!existsSync16(legacyPath))
     return false;
   if (!basename2(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync14(canonicalPath))
+  if (existsSync16(canonicalPath))
     return false;
   try {
-    const content = readFileSync9(legacyPath, "utf-8");
+    const content = readFileSync10(legacyPath, "utf-8");
     writeFileAtomically(canonicalPath, content);
     const migratedSidecar = migrateLegacySidecarFile(legacyPath, canonicalPath);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
@@ -52088,8 +52372,8 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename3, dirname as dirname5, extname, join as join14 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync11, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename3, dirname as dirname7, extname, join as join16 } from "path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -52104,12 +52388,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join14(dirname5(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
+  const canonicalConfigPath = join16(dirname7(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
   const shouldMigrateLegacyPath = basename3(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
-  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync15(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync17(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync15(omoConfigPath)) {
+    if (existsSync17(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -52120,7 +52404,7 @@ function writeOmoConfig(installConfig) {
       }
       try {
         const stat = statSync2(omoConfigPath);
-        const content = readFileSync10(omoConfigPath, "utf-8");
+        const content = readFileSync11(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -52166,6 +52450,16 @@ var init_write_omo_config = __esm(() => {
   init_generate_omo_config();
 });
 
+// src/shared/extract-semver.ts
+function extractSemverFromOutput(output) {
+  const trimmed = output.trim();
+  if (!trimmed)
+    return null;
+  const semverPattern = /(?<![\d:])v?(\d+\.\d+\.\d+(?:[-+][\w.]+)*)/;
+  const match = trimmed.match(semverPattern);
+  return match?.[1] ?? null;
+}
+
 // src/shared/spawn-with-windows-hide.ts
 import { spawn as nodeSpawn2 } from "child_process";
 import { Readable as Readable2 } from "stream";
@@ -52178,8 +52472,8 @@ function toReadableStream2(stream) {
 function wrapNodeProcess2(proc) {
   let resolveExited;
   let exitCode = null;
-  const exited = new Promise((resolve4) => {
-    resolveExited = resolve4;
+  const exited = new Promise((resolve5) => {
+    resolveExited = resolve5;
   });
   proc.on("exit", (code) => {
     exitCode = code ?? 1;
@@ -52235,10 +52529,52 @@ async function findOpenCodeBinaryWithVersion() {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const output = await new Response(proc.stdout).text();
-      await proc.exited;
-      if (proc.exitCode === 0) {
-        const version = output.trim();
+      const outputPromise = new Response(proc.stdout).text();
+      let killTimer = null;
+      let killGraceTimer = null;
+      const timedExitResult = await Promise.race([
+        proc.exited.then((exitCode) => ({ type: "exit", exitCode })),
+        new Promise((resolve5) => {
+          killTimer = setTimeout(() => {
+            proc.kill("SIGTERM");
+            killGraceTimer = setTimeout(() => {
+              proc.kill("SIGKILL");
+            }, OPENCODE_VERSION_KILL_GRACE_MS);
+            resolve5({ type: "timeout" });
+          }, OPENCODE_VERSION_CHECK_TIMEOUT_MS);
+        })
+      ]);
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      if (timedExitResult.type === "timeout") {
+        outputPromise.catch(() => {});
+        continue;
+      }
+      if (killGraceTimer) {
+        clearTimeout(killGraceTimer);
+      }
+      let outputTimer = null;
+      const outputResult = await Promise.race([
+        outputPromise.then((output) => ({ type: "output", output })),
+        new Promise((resolve5) => {
+          outputTimer = setTimeout(() => {
+            resolve5({ type: "timeout" });
+          }, OPENCODE_OUTPUT_WAIT_TIMEOUT_MS);
+        })
+      ]).catch(() => ({ type: "timeout" }));
+      if (outputTimer) {
+        clearTimeout(outputTimer);
+      }
+      if (outputResult.type !== "output") {
+        continue;
+      }
+      if (timedExitResult.exitCode === 0 && proc.exitCode === 0) {
+        const output = outputResult.output;
+        const version = extractSemverFromOutput(output) ?? output.trim();
+        if (version.length === 0) {
+          continue;
+        }
         initConfigContext(binary2, version);
         return { binary: binary2, version };
       }
@@ -52256,7 +52592,7 @@ async function getOpenCodeVersion2() {
   const result = await findOpenCodeBinaryWithVersion();
   return result?.version ?? null;
 }
-var OPENCODE_BINARIES;
+var OPENCODE_BINARIES, OPENCODE_VERSION_CHECK_TIMEOUT_MS = 1500, OPENCODE_VERSION_KILL_GRACE_MS = 200, OPENCODE_OUTPUT_WAIT_TIMEOUT_MS = 200;
 var init_opencode_binary = __esm(() => {
   init_spawn_with_windows_hide();
   init_config_context();
@@ -52264,10 +52600,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync16(omoConfigPath)) {
+  if (!existsSync18(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -52278,7 +52614,7 @@ function detectProvidersFromOmoConfig() {
     };
   }
   try {
-    const content = readFileSync11(omoConfigPath, "utf-8");
+    const content = readFileSync12(omoConfigPath, "utf-8");
     const omoConfig = parseJsonc(content);
     if (!omoConfig || typeof omoConfig !== "object") {
       return {
@@ -52330,11 +52666,11 @@ function detectCurrentConfig() {
     hasOpencodeGo: false,
     hasVercelAiGateway: false
   };
-  const { format: format2, path: path5 } = detectConfigFormat();
+  const { format: format2, path: path6 } = detectConfigFormat();
   if (format2 === "none") {
     return result;
   }
-  const parseResult = parseOpenCodeConfigFileWithError(path5);
+  const parseResult = parseOpenCodeConfigFileWithError(path6);
   if (!parseResult.config) {
     return result;
   }
@@ -52367,16 +52703,16 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync17 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join17 } from "path";
 function getDefaultWorkspaceDir() {
-  return join15(getOpenCodeCacheDir(), "packages");
+  return join17(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
     return Promise.resolve("");
   }
-  return Bun.readableStreamToText(stream);
+  return new Response(stream).text();
 }
 function logCapturedOutputOnFailure(outputMode, output) {
   if (outputMode !== "pipe") {
@@ -52396,7 +52732,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync17(packageJsonPath)) {
+  if (!existsSync19(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -52411,8 +52747,8 @@ async function runBunInstallWithDetails(options) {
     });
     const outputPromise = Promise.all([readProcessOutput(proc.stdout), readProcessOutput(proc.stderr)]).then(([stdout, stderr]) => ({ stdout, stderr }));
     let timeoutId;
-    const timeoutPromise = new Promise((resolve4) => {
-      timeoutId = setTimeout(() => resolve4("timeout"), BUN_INSTALL_TIMEOUT_MS);
+    const timeoutPromise = new Promise((resolve5) => {
+      timeoutId = setTimeout(() => resolve5("timeout"), BUN_INSTALL_TIMEOUT_MS);
     });
     const exitPromise = proc.exited.then(() => "completed");
     const result = await Promise.race([exitPromise, timeoutPromise]);
@@ -52539,7 +52875,7 @@ var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs5 = __require("fs");
-  function checkPathExt(path6, options) {
+  function checkPathExt(path7, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -52550,25 +52886,25 @@ var require_windows = __commonJS((exports, module) => {
     }
     for (var i2 = 0;i2 < pathext.length; i2++) {
       var p2 = pathext[i2].toLowerCase();
-      if (p2 && path6.substr(-p2.length).toLowerCase() === p2) {
+      if (p2 && path7.substr(-p2.length).toLowerCase() === p2) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path6, options) {
+  function checkStat(stat, path7, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path6, options);
+    return checkPathExt(path7, options);
   }
-  function isexe(path6, options, cb) {
-    fs5.stat(path6, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path6, options));
+  function isexe(path7, options, cb) {
+    fs5.stat(path7, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path7, options));
     });
   }
-  function sync(path6, options) {
-    return checkStat(fs5.statSync(path6), path6, options);
+  function sync(path7, options) {
+    return checkStat(fs5.statSync(path7), path7, options);
   }
 });
 
@@ -52577,13 +52913,13 @@ var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
   var fs5 = __require("fs");
-  function isexe(path6, options, cb) {
-    fs5.stat(path6, function(er, stat) {
+  function isexe(path7, options, cb) {
+    fs5.stat(path7, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path6, options) {
-    return checkStat(fs5.statSync(path6), options);
+  function sync(path7, options) {
+    return checkStat(fs5.statSync(path7), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -52614,7 +52950,7 @@ var require_isexe = __commonJS((exports, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path6, options, cb) {
+  function isexe(path7, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -52623,17 +52959,17 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve4, reject) {
-        isexe(path6, options || {}, function(er, is) {
+      return new Promise(function(resolve5, reject) {
+        isexe(path7, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve4(is);
+            resolve5(is);
           }
         });
       });
     }
-    core3(path6, options || {}, function(er, is) {
+    core3(path7, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -52643,9 +52979,9 @@ var require_isexe = __commonJS((exports, module) => {
       cb(er, is);
     });
   }
-  function sync(path6, options) {
+  function sync(path7, options) {
     try {
-      return core3.sync(path6, options || {});
+      return core3.sync(path7, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -52659,7 +52995,7 @@ var require_isexe = __commonJS((exports, module) => {
 // node_modules/which/which.js
 var require_which = __commonJS((exports, module) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path6 = __require("path");
+  var path7 = __require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -52690,27 +53026,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve4, reject) => {
+    const step = (i2) => new Promise((resolve5, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve5(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path6.join(pathPart, cmd);
+      const pCmd = path7.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve4(subStep(p2, i2, 0));
+      resolve5(subStep(p2, i2, 0));
     });
-    const subStep = (p2, i2, ii) => new Promise((resolve4, reject) => {
+    const subStep = (p2, i2, ii) => new Promise((resolve5, reject) => {
       if (ii === pathExt.length)
-        return resolve4(step(i2 + 1));
+        return resolve5(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p2 + ext);
           else
-            return resolve4(p2 + ext);
+            return resolve5(p2 + ext);
         }
-        return resolve4(subStep(p2, i2, ii + 1));
+        return resolve5(subStep(p2, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -52722,7 +53058,7 @@ var require_which = __commonJS((exports, module) => {
     for (let i2 = 0;i2 < pathEnv.length; i2++) {
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path6.join(pathPart, cmd);
+      const pCmd = path7.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j2 = 0;j2 < pathExt.length; j2++) {
         const cur = p2 + pathExt[j2];
@@ -52763,7 +53099,7 @@ var require_path_key = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports, module) => {
-  var path6 = __require("path");
+  var path7 = __require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -52780,7 +53116,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path6.delimiter : undefined
+        pathExt: withoutPathExt ? path7.delimiter : undefined
       });
     } catch (e2) {} finally {
       if (shouldSwitchCwd) {
@@ -52788,7 +53124,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       }
     }
     if (resolved) {
-      resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -52833,8 +53169,8 @@ var require_shebang_command = __commonJS((exports, module) => {
     if (!match) {
       return null;
     }
-    const [path6, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary2 = path6.split("/").pop();
+    const [path7, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary2 = path7.split("/").pop();
     if (binary2 === "env") {
       return argument;
     }
@@ -52862,7 +53198,7 @@ var require_readShebang = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS((exports, module) => {
-  var path6 = __require("path");
+  var path7 = __require("path");
   var resolveCommand2 = require_resolveCommand();
   var escape = require_escape();
   var readShebang = require_readShebang();
@@ -52887,7 +53223,7 @@ var require_parse = __commonJS((exports, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path6.normalize(parsed.command);
+      parsed.command = path7.normalize(parsed.command);
       parsed.command = escape.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -52991,21 +53327,21 @@ var require_cross_spawn = __commonJS((exports, module) => {
 });
 
 // src/hooks/auto-update-checker/constants.ts
-import * as path6 from "path";
+import * as path7 from "path";
 import * as os4 from "os";
 function getWindowsAppdataDir() {
   if (process.platform !== "win32")
     return null;
-  return process.env.APPDATA ?? path6.join(os4.homedir(), "AppData", "Roaming");
+  return process.env.APPDATA ?? path7.join(os4.homedir(), "AppData", "Roaming");
 }
 function getUserConfigDir() {
   return getOpenCodeConfigDir({ binary: "opencode" });
 }
 function getUserOpencodeConfig() {
-  return path6.join(getUserConfigDir(), "opencode.json");
+  return path7.join(getUserConfigDir(), "opencode.json");
 }
 function getUserOpencodeConfigJsonc() {
-  return path6.join(getUserConfigDir(), "opencode.jsonc");
+  return path7.join(getUserConfigDir(), "opencode.jsonc");
 }
 var PACKAGE_NAME2, ACCEPTED_PACKAGE_NAMES2, NPM_REGISTRY_URL, NPM_FETCH_TIMEOUT = 5000, CACHE_ROOT_DIR, CACHE_DIR, VERSION_FILE, INSTALLED_PACKAGE_JSON, INSTALLED_PACKAGE_JSON_CANDIDATES;
 var init_constants3 = __esm(() => {
@@ -53016,30 +53352,30 @@ var init_constants3 = __esm(() => {
   ACCEPTED_PACKAGE_NAMES2 = ACCEPTED_PACKAGE_NAMES;
   NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`;
   CACHE_ROOT_DIR = getOpenCodeCacheDir();
-  CACHE_DIR = path6.join(CACHE_ROOT_DIR, "packages");
-  VERSION_FILE = path6.join(CACHE_ROOT_DIR, "version");
-  INSTALLED_PACKAGE_JSON = path6.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
-  INSTALLED_PACKAGE_JSON_CANDIDATES = ACCEPTED_PACKAGE_NAMES2.map((name) => path6.join(CACHE_DIR, "node_modules", name, "package.json"));
+  CACHE_DIR = path7.join(CACHE_ROOT_DIR, "packages");
+  VERSION_FILE = path7.join(CACHE_ROOT_DIR, "version");
+  INSTALLED_PACKAGE_JSON = path7.join(CACHE_DIR, "node_modules", PACKAGE_NAME2, "package.json");
+  INSTALLED_PACKAGE_JSON_CANDIDATES = ACCEPTED_PACKAGE_NAMES2.map((name) => path7.join(CACHE_DIR, "node_modules", name, "package.json"));
 });
 
 // src/hooks/auto-update-checker/checker/config-paths.ts
 import * as os5 from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 function getConfigPaths(directory) {
   const userConfigDir = getUserConfigDir();
   const paths = [
-    path7.join(directory, ".opencode", "opencode.json"),
-    path7.join(directory, ".opencode", "opencode.jsonc"),
+    path8.join(directory, ".opencode", "opencode.json"),
+    path8.join(directory, ".opencode", "opencode.jsonc"),
     getUserOpencodeConfig(),
     getUserOpencodeConfigJsonc()
   ];
   if (process.platform === "win32") {
-    const crossPlatformDir = path7.join(os5.homedir(), ".config");
+    const crossPlatformDir = path8.join(os5.homedir(), ".config");
     const appdataDir = getWindowsAppdataDir();
     if (appdataDir) {
       const alternateDir = userConfigDir === crossPlatformDir ? appdataDir : crossPlatformDir;
-      const alternateConfig = path7.join(alternateDir, "opencode", "opencode.json");
-      const alternateConfigJsonc = path7.join(alternateDir, "opencode", "opencode.jsonc");
+      const alternateConfig = path8.join(alternateDir, "opencode", "opencode.json");
+      const alternateConfigJsonc = path8.join(alternateDir, "opencode", "opencode.jsonc");
       if (!paths.includes(alternateConfig)) {
         paths.push(alternateConfig);
       }
@@ -53097,13 +53433,13 @@ var init_local_dev_path = __esm(() => {
 
 // src/hooks/auto-update-checker/checker/package-json-locator.ts
 import * as fs6 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 function findPackageJsonUp(startPath) {
   try {
     const stat = fs6.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path8.dirname(startPath);
+    let dir = stat.isDirectory() ? startPath : path9.dirname(startPath);
     for (let i2 = 0;i2 < 10; i2++) {
-      const pkgPath = path8.join(dir, "package.json");
+      const pkgPath = path9.join(dir, "package.json");
       if (fs6.existsSync(pkgPath)) {
         try {
           const content = fs6.readFileSync(pkgPath, "utf-8");
@@ -53112,7 +53448,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path8.dirname(dir);
+      const parent = path9.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -53187,7 +53523,7 @@ var init_plugin_entry = __esm(() => {
 
 // src/hooks/auto-update-checker/checker/cached-version.ts
 import * as fs9 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function readPackageVersion(packageJsonPath) {
   const content = fs9.readFileSync(packageJsonPath, "utf-8");
@@ -53196,7 +53532,7 @@ function readPackageVersion(packageJsonPath) {
 }
 function getCachedVersion() {
   try {
-    const currentDir = path9.dirname(fileURLToPath2(import.meta.url));
+    const currentDir = path10.dirname(fileURLToPath2(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
       return readPackageVersion(pkgPath);
@@ -53212,7 +53548,7 @@ function getCachedVersion() {
     } catch {}
   }
   try {
-    const execDir = path9.dirname(fs9.realpathSync(process.execPath));
+    const execDir = path10.dirname(fs9.realpathSync(process.execPath));
     const pkgPath = findPackageJsonUp(execDir);
     if (pkgPath) {
       return readPackageVersion(pkgPath);
@@ -53356,7 +53692,7 @@ var init_check_for_update = __esm(() => {
 // src/hooks/auto-update-checker/checker/sync-package-json.ts
 import * as crypto from "crypto";
 import * as fs10 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 function safeUnlink(filePath) {
   try {
     fs10.unlinkSync(filePath);
@@ -53373,7 +53709,7 @@ function getIntentVersion(pluginInfo) {
 function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
   const tmpPath = `${cachePackageJsonPath}.${crypto.randomUUID()}`;
   try {
-    fs10.mkdirSync(path10.dirname(cachePackageJsonPath), { recursive: true });
+    fs10.mkdirSync(path11.dirname(cachePackageJsonPath), { recursive: true });
     fs10.writeFileSync(tmpPath, JSON.stringify(pkgJson, null, 2));
     fs10.renameSync(tmpPath, cachePackageJsonPath);
     return { synced: true, error: null };
@@ -53384,7 +53720,7 @@ function writeCachePackageJson(cachePackageJsonPath, pkgJson) {
   }
 }
 function syncCachePackageJsonToIntent(pluginInfo) {
-  const cachePackageJsonPath = path10.join(CACHE_DIR, "package.json");
+  const cachePackageJsonPath = path11.join(CACHE_DIR, "package.json");
   const intentVersion = getIntentVersion(pluginInfo);
   if (!fs10.existsSync(cachePackageJsonPath)) {
     log("[auto-update-checker] Cache package.json missing, creating workspace package.json", { intentVersion });
@@ -53460,7 +53796,7 @@ var init_checker = __esm(() => {
 
 // src/hooks/auto-update-checker/cache.ts
 import * as fs11 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 function stripTrailingCommas(json3) {
   return json3.replace(/,(\s*[}\]])/g, "$1");
 }
@@ -53489,8 +53825,8 @@ function deleteBinaryBunLock(lockPath) {
   }
 }
 function removeFromBunLock(packageName) {
-  const textLockPath = path11.join(CACHE_DIR, "bun.lock");
-  const binaryLockPath = path11.join(CACHE_DIR, "bun.lockb");
+  const textLockPath = path12.join(CACHE_DIR, "bun.lock");
+  const binaryLockPath = path12.join(CACHE_DIR, "bun.lockb");
   if (fs11.existsSync(textLockPath)) {
     return removeFromTextBunLock(textLockPath, packageName);
   }
@@ -53503,8 +53839,8 @@ function invalidatePackage(packageName = PACKAGE_NAME2) {
   try {
     const userConfigDir = getUserConfigDir();
     const pkgDirs = [
-      path11.join(userConfigDir, "node_modules", packageName),
-      path11.join(CACHE_DIR, "node_modules", packageName)
+      path12.join(userConfigDir, "node_modules", packageName),
+      path12.join(CACHE_DIR, "node_modules", packageName)
     ];
     let packageRemoved = false;
     let lockRemoved = false;
@@ -53564,8 +53900,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync29 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { join as join30 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -53615,7 +53951,7 @@ async function primeCacheWorkspace(activeWorkspace, deps) {
   return runBunInstallSafe(cacheWorkspace, deps);
 }
 function createBackgroundUpdateCheckRunner(overrides = {}) {
-  const deps = { ...defaultDeps, ...overrides };
+  const deps = { ...defaultDeps2, ...overrides };
   return async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
     const pluginInfo = deps.findPluginEntry(ctx.directory);
     if (!pluginInfo) {
@@ -53673,7 +54009,7 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
     deps.log("[auto-update-checker] bun install failed; update not installed (falling back to notification-only)");
   };
 }
-var defaultDeps, runBackgroundUpdateCheck;
+var defaultDeps2, runBackgroundUpdateCheck;
 var init_background_update_check = __esm(() => {
   init_config_manager();
   init_logger();
@@ -53682,9 +54018,9 @@ var init_background_update_check = __esm(() => {
   init_constants3();
   init_checker();
   init_update_toasts();
-  defaultDeps = {
-    existsSync: existsSync29,
-    join: join28,
+  defaultDeps2 = {
+    existsSync: existsSync32,
+    join: join30,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -53843,7 +54179,7 @@ async function showSpinnerToast(ctx, version3, message) {
         duration: frameInterval + 50
       }
     }).catch(() => {});
-    await new Promise((resolve4) => setTimeout(resolve4, frameInterval));
+    await new Promise((resolve6) => setTimeout(resolve6, frameInterval));
   }
 }
 var SISYPHUS_SPINNER;
@@ -53869,7 +54205,7 @@ var init_startup_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook.ts
-function createAutoUpdateCheckerHook(ctx, options = {}, deps = defaultDeps2) {
+function createAutoUpdateCheckerHook(ctx, options = {}, deps = defaultDeps3) {
   const {
     showStartupToast = true,
     isSisyphusEnabled = false,
@@ -53926,13 +54262,13 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
     }
   };
 }
-var defaultDeps2, isRecord6 = (value) => {
+var defaultDeps3, isRecord7 = (value) => {
   return typeof value === "object" && value !== null;
 }, getParentID = (properties) => {
-  if (!isRecord6(properties))
+  if (!isRecord7(properties))
     return;
   const { info } = properties;
-  if (!isRecord6(info))
+  if (!isRecord7(info))
     return;
   const { parentID } = info;
   return typeof parentID === "string" && parentID.length > 0 ? parentID : undefined;
@@ -53946,7 +54282,7 @@ var init_hook = __esm(() => {
   init_model_capabilities_status();
   init_model_cache_warning();
   init_startup_toasts();
-  defaultDeps2 = {
+  defaultDeps3 = {
     getCachedVersion,
     getLocalDevVersion,
     showConfigErrorsIfAny,
@@ -53996,7 +54332,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.17.15",
+  version: "4.1.0",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -54030,7 +54366,7 @@ var package_default = {
     prepublishOnly: "bun run clean && bun run build",
     "test:model-capabilities": "bun test src/shared/model-capability-aliases.test.ts src/shared/model-capability-guardrails.test.ts src/shared/model-capabilities.test.ts src/cli/doctor/checks/model-resolution.test.ts --bail",
     typecheck: "tsc --noEmit",
-    test: "bun test"
+    test: "bun run script/run-ci-tests.ts"
   },
   keywords: [
     "opencode",
@@ -54056,7 +54392,7 @@ var package_default = {
     "@ast-grep/napi": "^0.41.1",
     "@clack/prompts": "^0.11.0",
     "@code-yeongyu/comment-checker": "^0.7.0",
-    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@opencode-ai/plugin": "^1.4.0",
     "@opencode-ai/sdk": "^1.4.0",
     commander: "^14.0.2",
@@ -54077,19 +54413,25 @@ var package_default = {
     zod: "^4.3.0"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.17.15",
-    "oh-my-opencode-darwin-x64": "3.17.15",
-    "oh-my-opencode-darwin-x64-baseline": "3.17.15",
-    "oh-my-opencode-linux-arm64": "3.17.15",
-    "oh-my-opencode-linux-arm64-musl": "3.17.15",
-    "oh-my-opencode-linux-x64": "3.17.15",
-    "oh-my-opencode-linux-x64-baseline": "3.17.15",
-    "oh-my-opencode-linux-x64-musl": "3.17.15",
-    "oh-my-opencode-linux-x64-musl-baseline": "3.17.15",
-    "oh-my-opencode-windows-x64": "3.17.15",
-    "oh-my-opencode-windows-x64-baseline": "3.17.15"
+    "oh-my-opencode-darwin-arm64": "4.1.0",
+    "oh-my-opencode-darwin-x64": "4.1.0",
+    "oh-my-opencode-darwin-x64-baseline": "4.1.0",
+    "oh-my-opencode-linux-arm64": "4.1.0",
+    "oh-my-opencode-linux-arm64-musl": "4.1.0",
+    "oh-my-opencode-linux-x64": "4.1.0",
+    "oh-my-opencode-linux-x64-baseline": "4.1.0",
+    "oh-my-opencode-linux-x64-musl": "4.1.0",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.1.0",
+    "oh-my-opencode-windows-x64": "4.1.0",
+    "oh-my-opencode-windows-x64-baseline": "4.1.0"
+  },
+  overrides: {
+    hono: "^4.12.18",
+    "@hono/node-server": "^1.19.13",
+    "express-rate-limit": "^8.5.1",
+    "fast-uri": "^3.1.2",
+    "path-to-regexp": "^8.4.2"
   },
-  overrides: {},
   trustedDependencies: [
     "@ast-grep/cli",
     "@ast-grep/napi",
@@ -54278,13 +54620,15 @@ var CHECK_IDS = {
   SYSTEM: "system",
   CONFIG: "config",
   TOOLS: "tools",
-  MODELS: "models"
+  MODELS: "models",
+  TEAM_MODE: "team-mode"
 };
 var CHECK_NAMES = {
   [CHECK_IDS.SYSTEM]: "System",
   [CHECK_IDS.CONFIG]: "Configuration",
   [CHECK_IDS.TOOLS]: "Tools",
-  [CHECK_IDS.MODELS]: "Models"
+  [CHECK_IDS.MODELS]: "Models",
+  [CHECK_IDS.TEAM_MODE]: "Team Mode"
 };
 var EXIT_CODES = {
   SUCCESS: 0,
@@ -55374,10 +55718,10 @@ function formatToolHeader(toolName, input) {
     };
   }
   if (toolName === "list") {
-    const path5 = str2(input.path);
+    const path6 = str2(input.path);
     return {
       icon: "\u2192",
-      title: path5 ? `List ${path5}` : "List"
+      title: path6 ? `List ${path6}` : "List"
     };
   }
   if (toolName === "read") {
@@ -55886,7 +56230,8 @@ async function processEvents(ctx, stream, state) {
 }
 // src/plugin-config.ts
 import * as fs4 from "fs";
-import * as path5 from "path";
+import { homedir as homedir5 } from "os";
+import * as path6 from "path";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -56653,10 +56998,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema2) {
   return mergeDefs(schema2._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -57037,11 +57382,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -57224,7 +57569,7 @@ function formatError2(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path6 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -57234,7 +57579,7 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -57266,8 +57611,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -69014,13 +69359,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path6 = ref.slice(1).split("/").filter(Boolean);
+  if (path6.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path6[0] === defsKey) {
+    const key = path6[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -69441,7 +69786,8 @@ var BuiltinSkillNameSchema = exports_external.enum([
   "frontend-ui-ux",
   "git-master",
   "review-work",
-  "ai-slop-remover"
+  "ai-slop-remover",
+  "team-mode"
 ]);
 var OverridableAgentNameSchema = exports_external.enum([
   "build",
@@ -69463,7 +69809,7 @@ var OverridableAgentNameSchema = exports_external.enum([
 var FallbackModelObjectSchema = exports_external.object({
   model: exports_external.string(),
   variant: exports_external.string().optional(),
-  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   top_p: exports_external.number().min(0).max(1).optional(),
   maxTokens: exports_external.number().optional(),
@@ -69519,7 +69865,7 @@ var AgentOverrideConfigSchema = exports_external.object({
     type: exports_external.enum(["enabled", "disabled"]),
     budgetTokens: exports_external.number().optional()
   }).optional(),
-  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
   textVerbosity: exports_external.enum(["low", "medium", "high"]).optional(),
   providerOptions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   ultrawork: exports_external.object({
@@ -69595,7 +69941,7 @@ var CategoryConfigSchema = exports_external.object({
     type: exports_external.enum(["enabled", "disabled"]),
     budgetTokens: exports_external.number().optional()
   }).optional(),
-  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+  reasoningEffort: exports_external.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
   textVerbosity: exports_external.enum(["low", "medium", "high"]).optional(),
   tools: exports_external.record(exports_external.string(), exports_external.boolean()).optional(),
   prompt_append: exports_external.string().optional(),
@@ -69637,7 +69983,8 @@ var BuiltinCommandNameSchema = exports_external.enum([
   "refactor",
   "start-work",
   "stop-continuation",
-  "remove-ai-slops"
+  "remove-ai-slops",
+  "hyperplan"
 ]);
 // src/config/schema/dynamic-context-pruning.ts
 var DynamicContextPruningConfigSchema = exports_external.object({
@@ -69738,6 +70085,7 @@ var HookNameSchema = exports_external.enum([
   "delegate-task-retry",
   "prometheus-md-only",
   "sisyphus-junior-notepad",
+  "team-tool-gating",
   "no-sisyphus-gpt",
   "no-hephaestus-non-gpt",
   "start-work",
@@ -69754,8 +70102,14 @@ var HookNameSchema = exports_external.enum([
   "read-image-resizer",
   "todo-description-override",
   "webfetch-redirect-guard",
+  "fsync-skip-warning",
   "legacy-plugin-toast"
 ]);
+// src/config/schema/keyword-detector.ts
+var KeywordTypeSchema = exports_external.enum(["ultrawork", "search", "analyze", "team", "hyperplan", "hyperplan-ultrawork"]);
+var KeywordDetectorConfigSchema = exports_external.object({
+  disabled_keywords: exports_external.array(KeywordTypeSchema).optional()
+});
 // src/config/schema/model-capabilities.ts
 var ModelCapabilitiesConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
@@ -69826,6 +70180,21 @@ var RuntimeFallbackConfigSchema = exports_external.object({
   notify_on_fallback: exports_external.boolean().optional()
 });
 
+// src/config/schema/team-mode.ts
+var TeamModeConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  tmux_visualization: exports_external.boolean().default(false),
+  max_parallel_members: exports_external.number().int().min(1).max(8).default(4),
+  max_members: exports_external.number().int().min(1).max(8).default(8),
+  max_messages_per_run: exports_external.number().int().min(1).default(1e4),
+  max_wall_clock_minutes: exports_external.number().int().min(1).default(120),
+  max_member_turns: exports_external.number().int().min(1).default(500),
+  base_dir: exports_external.string().optional(),
+  message_payload_max_bytes: exports_external.number().int().min(1024).default(32768),
+  recipient_unread_max_bytes: exports_external.number().int().min(1024).default(262144),
+  mailbox_poll_interval_ms: exports_external.number().int().min(500).default(3000)
+});
+
 // src/config/schema/skills.ts
 var SkillSourceSchema = exports_external.union([
   exports_external.string(),
@@ -69916,6 +70285,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   new_task_system_enabled: exports_external.boolean().optional(),
   default_run_agent: exports_external.string().optional(),
+  agent_order: exports_external.array(exports_external.string().max(128)).max(64).optional(),
   agent_definitions: AgentDefinitionsConfigSchema,
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
   disabled_agents: exports_external.array(exports_external.string()).optional(),
@@ -69940,6 +70310,8 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   notification: NotificationConfigSchema.optional(),
   model_capabilities: ModelCapabilitiesConfigSchema.optional(),
   openclaw: OpenClawConfigSchema.optional(),
+  team_mode: TeamModeConfigSchema.optional(),
+  keyword_detector: KeywordDetectorConfigSchema.optional(),
   babysitting: BabysittingConfigSchema.optional(),
   git_master: GitMasterConfigSchema.default({
     commit_footer: true,
@@ -69957,6 +70329,98 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 init_shared();
 init_migrate_legacy_config_file();
 init_plugin_identity();
+
+// src/shared/agent-ordering.ts
+init_agent_display_names();
+var DEFAULT_AGENT_ORDER = [
+  "sisyphus",
+  "hephaestus",
+  "prometheus",
+  "atlas"
+];
+var KNOWN_AGENT_KEYS = new Set(Object.keys(AGENT_DISPLAY_NAMES));
+function appendUnique(target, value) {
+  if (!target.includes(value)) {
+    target.push(value);
+  }
+}
+function validateAgentOrder(agentOrder) {
+  const order = [];
+  const invalid = [];
+  const duplicates = [];
+  const seen = new Set;
+  for (const rawName of agentOrder ?? []) {
+    const trimmed = rawName.trim();
+    if (trimmed.length === 0) {
+      invalid.push(rawName);
+      continue;
+    }
+    const configKey = getAgentConfigKey(trimmed);
+    if (!KNOWN_AGENT_KEYS.has(configKey)) {
+      invalid.push(rawName);
+      continue;
+    }
+    if (seen.has(configKey)) {
+      duplicates.push(rawName);
+      continue;
+    }
+    seen.add(configKey);
+    order.push(configKey);
+  }
+  for (const configKey of DEFAULT_AGENT_ORDER) {
+    appendUnique(order, configKey);
+  }
+  return { order, invalid, duplicates };
+}
+
+// src/plugin-config.ts
+var CONTROL_CHARACTERS_REGEX = /[\u0000-\u001F\u007F-\u009F\u202A-\u202E\u2066-\u2069]/g;
+var MAX_AGENT_ORDER_WARNING_VALUES = 10;
+var MAX_AGENT_ORDER_WARNING_VALUE_LENGTH = 80;
+function formatAgentOrderWarningValues(values) {
+  const displayedValues = values.slice(0, MAX_AGENT_ORDER_WARNING_VALUES).map((value) => {
+    const sanitized = value.replace(CONTROL_CHARACTERS_REGEX, "");
+    const truncated = sanitized.length > MAX_AGENT_ORDER_WARNING_VALUE_LENGTH ? `${sanitized.slice(0, MAX_AGENT_ORDER_WARNING_VALUE_LENGTH)}...` : sanitized;
+    return JSON.stringify(truncated);
+  });
+  const remaining = values.length - displayedValues.length;
+  if (remaining > 0) {
+    displayedValues.push(`(+${remaining} more)`);
+  }
+  return displayedValues.join(", ");
+}
+function addAgentOrderWarnings(configPath, agentOrder) {
+  if (!agentOrder)
+    return;
+  const validation = validateAgentOrder(agentOrder);
+  const messages = [];
+  if (validation.invalid.length > 0) {
+    messages.push(`unknown agent names ignored: ${formatAgentOrderWarningValues(validation.invalid)}`);
+  }
+  if (validation.duplicates.length > 0) {
+    messages.push(`duplicate agent names ignored: ${formatAgentOrderWarningValues(validation.duplicates)}`);
+  }
+  if (messages.length === 0)
+    return;
+  addConfigLoadError({
+    path: configPath,
+    error: `agent_order warning - ${messages.join("; ")}`
+  });
+}
+function resolveHomeDirectory() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? homedir5();
+}
+function resolveConfigPathAfterLegacyMigration(detectedPath) {
+  if (!path6.basename(detectedPath).startsWith(LEGACY_CONFIG_BASENAME)) {
+    return detectedPath;
+  }
+  const migrated = migrateLegacyConfigFile(detectedPath);
+  const canonicalPath = path6.join(path6.dirname(detectedPath), `${CONFIG_BASENAME}${path6.extname(detectedPath)}`);
+  if (migrated || fs4.existsSync(canonicalPath)) {
+    return canonicalPath;
+  }
+  return detectedPath;
+}
 function loadExplicitGitMasterOverrides(configPath) {
   try {
     if (!fs4.existsSync(configPath)) {
@@ -70024,6 +70488,7 @@ function loadConfigFromPath(configPath, _ctx) {
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
       if (result.success) {
+        addAgentOrderWarnings(configPath, result.data.agent_order);
         log(`Config loaded from ${configPath}`, { agents: result.data.agents });
         return result.data;
       }
@@ -70035,6 +70500,7 @@ function loadConfigFromPath(configPath, _ctx) {
       });
       const partialResult = parseConfigPartially(rawConfig);
       if (partialResult) {
+        addAgentOrderWarnings(configPath, partialResult.agent_order);
         log(`Partial config loaded from ${configPath}`, { agents: partialResult.agents });
         return partialResult;
       }
@@ -70053,6 +70519,7 @@ function mergeConfigs(base, override) {
     ...override,
     agents: deepMerge(base.agents, override.agents),
     categories: deepMerge(base.categories, override.categories),
+    team_mode: deepMerge(base.team_mode, override.team_mode),
     agent_definitions: [
       ...new Set([
         ...base.agent_definitions ?? [],
@@ -70107,58 +70574,70 @@ function mergeConfigs(base, override) {
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userDetected = detectPluginConfigFile(configDir);
-  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path5.join(configDir, `${CONFIG_BASENAME}.json`);
+  let userConfigPath = userDetected.format !== "none" ? userDetected.path : path6.join(configDir, `${CONFIG_BASENAME}.json`);
   if (userDetected.legacyPath) {
     log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
       canonicalPath: userDetected.path,
       legacyPath: userDetected.legacyPath
     });
   }
-  if (userDetected.format !== "none" && path5.basename(userDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    const migrated = migrateLegacyConfigFile(userDetected.path);
-    const canonicalPath = path5.join(path5.dirname(userDetected.path), `${CONFIG_BASENAME}${path5.extname(userDetected.path)}`);
-    if (migrated || fs4.existsSync(canonicalPath)) {
-      userConfigPath = canonicalPath;
-    }
-  }
-  const projectBasePath = path5.join(directory, ".opencode");
-  const projectDetected = detectPluginConfigFile(projectBasePath);
-  let projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : path5.join(projectBasePath, `${CONFIG_BASENAME}.json`);
-  if (projectDetected.legacyPath) {
-    log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
-      canonicalPath: projectDetected.path,
-      legacyPath: projectDetected.legacyPath
-    });
-  }
-  if (projectDetected.format !== "none" && path5.basename(projectDetected.path).startsWith(LEGACY_CONFIG_BASENAME)) {
-    const projectMigrated = migrateLegacyConfigFile(projectDetected.path);
-    const canonicalProjectPath = path5.join(path5.dirname(projectDetected.path), `${CONFIG_BASENAME}${path5.extname(projectDetected.path)}`);
-    if (projectMigrated || fs4.existsSync(canonicalProjectPath)) {
-      projectConfigPath = canonicalProjectPath;
+  if (userDetected.format !== "none") {
+    userConfigPath = resolveConfigPathAfterLegacyMigration(userConfigPath);
+  }
+  const homeDirectory = resolveHomeDirectory();
+  const stopDirectory = containsPath(homeDirectory, directory) ? homeDirectory : directory;
+  const ancestorConfigPathsNearestFirst = findProjectOpencodePluginConfigFiles(directory, stopDirectory);
+  log("Walked ancestor plugin configs", {
+    paths: ancestorConfigPathsNearestFirst,
+    count: ancestorConfigPathsNearestFirst.length,
+    stopDirectory
+  });
+  const canonicalAncestorPathsNearestFirst = ancestorConfigPathsNearestFirst.map((ancestorPath) => {
+    const opencodeDir = path6.dirname(ancestorPath);
+    const ancestorDetected = detectPluginConfigFile(opencodeDir);
+    if (ancestorDetected.legacyPath) {
+      log("Canonical plugin config detected alongside legacy config. Remove the legacy file to avoid confusion.", {
+        canonicalPath: ancestorDetected.path,
+        legacyPath: ancestorDetected.legacyPath
+      });
     }
-  }
+    return resolveConfigPathAfterLegacyMigration(ancestorPath);
+  });
   const userConfig = loadConfigFromPath(userConfigPath, ctx);
   const userGitMasterOverrides = loadExplicitGitMasterOverrides(userConfigPath);
   if (userConfig?.agent_definitions) {
     userConfig.agent_definitions = resolveAgentDefinitionPaths(userConfig.agent_definitions, configDir, null);
   }
   let config2 = userConfig ?? OhMyOpenCodeConfigSchema.parse({});
+  const canonicalAncestorPathsFarthestFirst = [...canonicalAncestorPathsNearestFirst].reverse();
   const defaultGitMaster = OhMyOpenCodeConfigSchema.parse({}).git_master;
-  const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
-  const projectGitMasterOverrides = loadExplicitGitMasterOverrides(projectConfigPath);
-  if (projectConfig?.agent_definitions) {
-    projectConfig.agent_definitions = resolveAgentDefinitionPaths(projectConfig.agent_definitions, projectBasePath, directory);
-  }
-  if (projectConfig) {
-    config2 = mergeConfigs(config2, projectConfig);
+  const ancestorGitMasterOverridesFarthestFirst = [];
+  for (const ancestorPath of canonicalAncestorPathsFarthestFirst) {
+    const ancestorConfig = loadConfigFromPath(ancestorPath, ctx);
+    const ancestorOverrides = loadExplicitGitMasterOverrides(ancestorPath);
+    if (ancestorConfig?.agent_definitions) {
+      const ancestorBasePath = path6.dirname(ancestorPath);
+      const ancestorDir = path6.dirname(ancestorBasePath);
+      ancestorConfig.agent_definitions = resolveAgentDefinitionPaths(ancestorConfig.agent_definitions, ancestorBasePath, ancestorDir);
+    }
+    if (ancestorConfig) {
+      config2 = mergeConfigs(config2, ancestorConfig);
+    }
+    if (ancestorOverrides) {
+      ancestorGitMasterOverridesFarthestFirst.push(ancestorOverrides);
+    }
   }
-  if (userGitMasterOverrides || projectGitMasterOverrides) {
+  if (userGitMasterOverrides || ancestorGitMasterOverridesFarthestFirst.length > 0) {
+    const mergedAncestorGitMaster = {};
+    for (const override of ancestorGitMasterOverridesFarthestFirst) {
+      Object.assign(mergedAncestorGitMaster, override);
+    }
     config2 = {
       ...config2,
       git_master: {
         ...defaultGitMaster,
         ...userGitMasterOverrides ?? {},
-        ...projectGitMasterOverrides ?? {}
+        ...mergedAncestorGitMaster
       }
     };
   }
@@ -70178,7 +70657,7 @@ function loadPluginConfig(directory, ctx) {
 // node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url2, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3000;
     let attempt = 0;
@@ -70409,7 +70888,7 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
 
 // node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path: path6, url: _url2 }) => {
+var defaultPathSerializer = ({ path: path7, url: _url2 }) => {
   let url2 = _url2;
   const matches = _url2.match(PATH_PARAM_RE);
   if (matches) {
@@ -70428,7 +70907,7 @@ var defaultPathSerializer = ({ path: path6, url: _url2 }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path6[name];
+      const value = path7[name];
       if (value === undefined || value === null) {
         continue;
       }
@@ -70459,11 +70938,11 @@ var defaultPathSerializer = ({ path: path6, url: _url2 }) => {
   }
   return url2;
 };
-var getUrl = ({ baseUrl, path: path6, query, querySerializer, url: _url2 }) => {
+var getUrl = ({ baseUrl, path: path7, query, querySerializer, url: _url2 }) => {
   const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
   let url2 = (baseUrl ?? "") + pathUrl;
-  if (path6) {
-    url2 = defaultPathSerializer({ path: path6, url: url2 });
+  if (path7) {
+    url2 = defaultPathSerializer({ path: path7, url: url2 });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -71613,7 +72092,7 @@ async function createOpencodeServer(options) {
     }
   });
   let clear = () => {};
-  const url2 = await new Promise((resolve4, reject) => {
+  const url2 = await new Promise((resolve5, reject) => {
     const id = setTimeout(() => {
       clear();
       stop(proc);
@@ -71639,7 +72118,7 @@ async function createOpencodeServer(options) {
           }
           clearTimeout(id);
           resolved = true;
-          resolve4(match[1]);
+          resolve5(match[1]);
           return;
         }
       }
@@ -71694,7 +72173,7 @@ var import_picocolors10 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/opencode-binary-resolver.ts
 init_spawn_with_windows_hide();
-import { delimiter, dirname as dirname7, join as join17 } from "path";
+import { delimiter, dirname as dirname9, join as join19 } from "path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -71717,7 +72196,7 @@ function collectCandidateBinaryPaths(pathEnv, which = Bun.which, platform = proc
   }
   for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
     for (const command of commandCandidates) {
-      addCandidate(join17(entry, command));
+      addCandidate(join19(entry, command));
     }
   }
   return candidates;
@@ -71744,7 +72223,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname7(binaryPath);
+  const preferredDir = dirname9(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -71897,7 +72376,7 @@ async function resolveSession(options) {
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
         console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-        await new Promise((resolve4) => setTimeout(resolve4, delay));
+        await new Promise((resolve5) => setTimeout(resolve5, delay));
       }
       continue;
     }
@@ -71908,7 +72387,7 @@ async function resolveSession(options) {
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay = SESSION_CREATE_RETRY_DELAY_MS * attempt;
       console.log(import_picocolors11.default.dim(`  Retrying in ${delay}ms...`));
-      await new Promise((resolve4) => setTimeout(resolve4, delay));
+      await new Promise((resolve5) => setTimeout(resolve5, delay));
     }
   }
   throw new Error("Failed to create session after all retries");
@@ -72119,19 +72598,95 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
-import { dirname as dirname8, join as join18, basename as basename5 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
+import { basename as basename5, dirname as dirname10, isAbsolute as isAbsolute3, join as join20, relative as relative2, resolve as resolve5 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+function parseIsoToMs(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function buildWorkFromMirror(state) {
+  const planName = state.plan_name ?? getPlanName(state.active_plan);
+  const workId = `${planName}-legacy`;
+  return {
+    work_id: workId,
+    active_plan: state.active_plan,
+    plan_name: planName,
+    status: state.status,
+    started_at: state.started_at,
+    ended_at: state.ended_at,
+    elapsed_ms: state.elapsed_ms,
+    updated_at: state.updated_at,
+    session_ids: Array.isArray(state.session_ids) ? [...state.session_ids] : [],
+    session_origins: state.session_origins,
+    agent: state.agent,
+    worktree_path: state.worktree_path,
+    task_sessions: state.task_sessions
+  };
+}
+function projectWorkToMirror(state, work) {
+  state.active_plan = work.active_plan;
+  state.plan_name = work.plan_name;
+  state.status = work.status;
+  state.started_at = work.started_at;
+  state.ended_at = work.ended_at;
+  state.elapsed_ms = work.elapsed_ms;
+  state.updated_at = work.updated_at;
+  state.session_ids = [...work.session_ids];
+  state.session_origins = work.session_origins ? { ...work.session_origins } : {};
+  state.agent = work.agent;
+  state.worktree_path = work.worktree_path;
+  state.task_sessions = work.task_sessions ? { ...work.task_sessions } : {};
+}
+function selectMirrorWork(state) {
+  const works = getBoulderWorks(state);
+  if (works.length === 0) {
+    return null;
+  }
+  if (state.active_work_id) {
+    const matched = works.find((work) => work.work_id === state.active_work_id);
+    if (matched) {
+      return matched;
+    }
+  }
+  const sorted = [...works].sort((left, right) => {
+    const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0;
+    const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0;
+    return rightMs - leftMs;
+  });
+  return sorted[0] ?? null;
+}
 function getBoulderFilePath(directory) {
-  return join18(directory, BOULDER_DIR, BOULDER_FILE);
+  return join20(directory, BOULDER_DIR, BOULDER_FILE);
+}
+function resolveTrackedPath(baseDirectory, trackedPath) {
+  return isAbsolute3(trackedPath) ? resolve5(trackedPath) : resolve5(baseDirectory, trackedPath);
+}
+function resolveBoulderPlanPath(directory, state) {
+  const absolutePlanPath = resolveTrackedPath(directory, state.active_plan);
+  const worktreePath = state.worktree_path?.trim();
+  if (!worktreePath) {
+    return absolutePlanPath;
+  }
+  const absoluteDirectory = resolve5(directory);
+  const relativePlanPath = relative2(absoluteDirectory, absolutePlanPath);
+  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute3(relativePlanPath)) {
+    return absolutePlanPath;
+  }
+  const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
+  const worktreePlanPath = resolve5(absoluteWorktreePath, relativePlanPath);
+  return existsSync21(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync19(filePath)) {
+  if (!existsSync21(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
@@ -72151,7 +72706,13 @@ function readBoulderState(directory) {
     if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) {
       parsed.task_sessions = {};
     }
-    return parsed;
+    const state = parsed;
+    const mirrorWork = selectMirrorWork(state);
+    if (mirrorWork) {
+      state.active_work_id = mirrorWork.work_id;
+      projectWorkToMirror(state, mirrorWork);
+    }
+    return state;
   } catch {
     return null;
   }
@@ -72164,11 +72725,11 @@ var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
 var TODO_TASK_PATTERN = /^\d+\.\s+/;
 var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync19(planPath)) {
-    return { total: 0, completed: 0, isComplete: true };
+  if (!existsSync21(planPath)) {
+    return { total: 0, completed: 0, isComplete: false };
   }
   try {
-    const content = readFileSync13(planPath, "utf-8");
+    const content = readFileSync14(planPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line));
     if (hasStructuredSections) {
@@ -72176,7 +72737,7 @@ function getPlanProgress(planPath) {
     }
     return getSimplePlanProgress(content);
   } catch {
-    return { total: 0, completed: 0, isComplete: true };
+    return { total: 0, completed: 0, isComplete: false };
   }
 }
 function getStructuredPlanProgress(lines) {
@@ -72227,6 +72788,76 @@ function getSimplePlanProgress(content) {
     isComplete: total > 0 && completed === total
   };
 }
+function getPlanName(planPath) {
+  return basename5(planPath, ".md");
+}
+function getBoulderWorks(state) {
+  if (state.works && typeof state.works === "object") {
+    return Object.values(state.works);
+  }
+  if (!state.active_plan || !state.plan_name || !state.started_at) {
+    return [];
+  }
+  return [buildWorkFromMirror(state)];
+}
+function resolveBoulderPlanPathForWork(directory, work) {
+  return resolveBoulderPlanPath(directory, work);
+}
+// src/features/boulder-state/top-level-task.ts
+import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
+var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
+var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
+var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
+var UNCHECKED_CHECKBOX_PATTERN2 = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
+var TODO_TASK_PATTERN2 = /^(\d+)\.\s+(.+)$/;
+var FINAL_WAVE_TASK_PATTERN2 = /^(F\d+)\.\s+(.+)$/i;
+function buildTaskRef(section, taskLabel) {
+  const pattern = section === "todo" ? TODO_TASK_PATTERN2 : FINAL_WAVE_TASK_PATTERN2;
+  const match = taskLabel.match(pattern);
+  if (!match) {
+    return null;
+  }
+  const rawLabel = match[1];
+  const title = match[2].trim();
+  return {
+    key: `${section}:${rawLabel.toLowerCase()}`,
+    section,
+    label: rawLabel,
+    title
+  };
+}
+function readCurrentTopLevelTask(planPath) {
+  if (!existsSync22(planPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync15(planPath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    let section = "other";
+    for (const line of lines) {
+      if (SECOND_LEVEL_HEADING_PATTERN2.test(line)) {
+        section = TODO_HEADING_PATTERN2.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN2.test(line) ? "final-wave" : "other";
+      }
+      const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN2);
+      if (!uncheckedTaskMatch) {
+        continue;
+      }
+      if (uncheckedTaskMatch[1].length > 0) {
+        continue;
+      }
+      if (section !== "todo" && section !== "final-wave") {
+        continue;
+      }
+      const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim());
+      if (taskRef) {
+        return taskRef;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 // src/features/claude-code-session-state/state.ts
 init_agent_display_names();
 var subagentSessions = new Set;
@@ -72240,17 +72871,17 @@ function getSessionAgent(sessionID) {
 // src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync16, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join21 } from "path";
 function getMarkerPath(directory, sessionID) {
-  return join19(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join21(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync20(markerPath))
+  if (!existsSync23(markerPath))
     return null;
   try {
-    const raw = readFileSync14(markerPath, "utf-8");
+    const raw = readFileSync16(markerPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -72311,8 +72942,8 @@ async function isSessionInBoulderLineage(input) {
 // src/hooks/atlas/session-last-agent.ts
 init_shared();
 init_compaction_marker();
-import { readFileSync as readFileSync15, readdirSync as readdirSync4 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync17, readdirSync as readdirSync4 } from "fs";
+import { join as join22 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -72360,7 +72991,7 @@ async function getLastAgentFromSession(sessionID, client3, deps = {}) {
   try {
     const messages = readdirSync4(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync15(join20(messageDir, fileName), "utf-8");
+        const content = readFileSync17(join22(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -72393,8 +73024,8 @@ init_agent_display_names();
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname9, join as join21 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync18, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9 } from "fs";
+import { dirname as dirname11, join as join23 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
@@ -72403,15 +73034,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join21(directory, customPath) : join21(directory, DEFAULT_STATE_FILE);
+  return customPath ? join23(directory, customPath) : join23(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync21(filePath)) {
+  if (!existsSync24(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync18(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -72467,7 +73098,7 @@ async function hasActiveBoulderContinuation(directory, sessionID, client3) {
   const boulder = readBoulderState(directory);
   if (!boulder)
     return false;
-  const progress = getPlanProgress(boulder.active_plan);
+  const progress = getPlanProgress(resolveBoulderPlanPath(directory, boulder));
   if (progress.isComplete)
     return false;
   if (!client3)
@@ -72625,7 +73256,7 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
   let secondaryTimeoutChecked = false;
   const pollStartTimestamp = Date.now();
   while (!abortController.signal.aborted) {
-    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
+    await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
     if (abortController.signal.aborted) {
       return 130;
     }
@@ -72856,7 +73487,7 @@ import os3 from "os";
 import { createHash } from "crypto";
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname10, posix, sep } from "path";
+import { dirname as dirname12, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -72865,7 +73496,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname10(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname12(process.argv[1]) : process.cwd(), isWindows = sep === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -72887,8 +73518,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname10(proc
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path6) {
-  return path6.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path7) {
+  return path7.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -75203,15 +75834,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path6, ranges, output) {
-  return new Promise((resolve4) => {
-    const stream = createReadStream(path6);
+function getContextLinesFromFile(path7, ranges, output) {
+  return new Promise((resolve6) => {
+    const stream = createReadStream(path7);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve4();
+      resolve6();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -75221,7 +75852,7 @@ function getContextLinesFromFile(path6, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path6, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path7, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -75289,8 +75920,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path6) {
-  return path6.startsWith("node:") || path6.endsWith(".min.js") || path6.endsWith(".min.cjs") || path6.endsWith(".min.mjs") || path6.startsWith("data:");
+function shouldSkipContextLinesForFile(path7) {
+  return path7.startsWith("node:") || path7.endsWith(".min.js") || path7.endsWith(".min.cjs") || path7.endsWith(".min.mjs") || path7.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (frame.lineno !== undefined && frame.lineno > MAX_CONTEXTLINES_LINENO)
@@ -76451,9 +77082,9 @@ class PostHogBackendClient extends PostHogCoreStateless {
     if (this.disabled || this.optedOut)
       return;
     if (!this._waitUntilCycle) {
-      let resolve4;
+      let resolve6;
       const promise2 = new Promise((r2) => {
-        resolve4 = r2;
+        resolve6 = r2;
       });
       try {
         waitUntil(promise2);
@@ -76461,7 +77092,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve4,
+        resolve: resolve6,
         startedAt: Date.now(),
         timer: undefined
       };
@@ -76487,11 +77118,11 @@ class PostHogBackendClient extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve4 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {} finally {
-      resolve4?.();
+      resolve6?.();
     }
   }
   getPersistedProperty(key) {
@@ -76591,15 +77222,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve4(false);
+        resolve6(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve4(count > 0);
+        resolve6(count > 0);
       });
     });
   }
@@ -76943,13 +77574,13 @@ class PostHogBackendClient extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve4 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
-      resolve4?.();
+      resolve6?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -77303,11 +77934,11 @@ init_data_path();
 init_logger();
 init_plugin_identity();
 init_write_file_atomically();
-import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync17 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync10, readFileSync as readFileSync19 } from "fs";
+import { join as join24 } from "path";
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
 function getPostHogActivityStateFilePath() {
-  return join22(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
+  return join24(getDataDir(), CACHE_DIR_NAME, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getUtcDayString(date5) {
   return date5.toISOString().slice(0, 10);
@@ -77317,11 +77948,11 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync22(stateFilePath)) {
+  if (!existsSync25(stateFilePath)) {
     return {};
   }
   try {
-    const content = readFileSync17(stateFilePath, "utf-8");
+    const content = readFileSync19(stateFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isPostHogActivityState(parsed)) {
       return {};
@@ -77338,7 +77969,7 @@ function readPostHogActivityState() {
 function writePostHogActivityState(nextState) {
   const stateFilePath = getPostHogActivityStateFilePath();
   try {
-    mkdirSync10(join22(getDataDir(), CACHE_DIR_NAME), { recursive: true });
+    mkdirSync10(join24(getDataDir(), CACHE_DIR_NAME), { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error48) {
@@ -77366,9 +77997,13 @@ function getPostHogActivityCaptureState(now = new Date) {
 
 // src/shared/posthog.ts
 var activityStateProviderOverride = null;
+var osProviderOverride = null;
 function resolveActivityState() {
   return (activityStateProviderOverride ?? getPostHogActivityCaptureState)();
 }
+function resolveOsProvider() {
+  return osProviderOverride ?? os3;
+}
 var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
 var DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
 var NO_OP_POSTHOG = {
@@ -77399,7 +78034,7 @@ function getPostHogHost() {
 }
 function safeCpus() {
   try {
-    const cpus = os3.cpus();
+    const cpus = resolveOsProvider().cpus();
     return { length: cpus.length, model: cpus[0]?.model };
   } catch {
     return { length: 0, model: undefined };
@@ -77407,6 +78042,7 @@ function safeCpus() {
 }
 function getSharedProperties(source) {
   const cpus = safeCpus();
+  const osProvider = resolveOsProvider();
   return {
     platform: "oh-my-opencode",
     package_name: PUBLISHED_PACKAGE_NAME,
@@ -77415,13 +78051,13 @@ function getSharedProperties(source) {
     runtime: "bun",
     runtime_version: process.versions.bun ?? process.version,
     source,
-    $os: os3.platform(),
-    $os_version: os3.release(),
-    os_arch: os3.arch(),
-    os_type: os3.type(),
+    $os: osProvider.platform(),
+    $os_version: osProvider.release(),
+    os_arch: osProvider.arch(),
+    os_type: osProvider.type(),
     cpu_count: cpus.length,
     cpu_model: cpus.model,
-    total_memory_gb: Math.round(os3.totalmem() / 1024 / 1024 / 1024),
+    total_memory_gb: Math.round(osProvider.totalmem() / 1024 / 1024 / 1024),
     locale: Intl.DateTimeFormat().resolvedOptions().locale,
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     shell: process.env.SHELL,
@@ -77464,11 +78100,14 @@ function createPostHogClient(source, options) {
   };
 }
 function getPostHogDistinctId() {
-  return createHash("sha256").update(`${PUBLISHED_PACKAGE_NAME}:${os3.hostname()}`).digest("hex");
+  return createHash("sha256").update(`${PUBLISHED_PACKAGE_NAME}:${resolveOsProvider().hostname()}`).digest("hex");
 }
 function createCliPostHog() {
   return createPostHogClient("cli", {
     enableExceptionAutocapture: false,
+    enableLocalEvaluation: false,
+    strictLocalEvaluation: true,
+    disableRemoteConfig: true,
     flushAt: 1,
     flushInterval: 0
   });
@@ -77479,7 +78118,7 @@ var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
     eventProcessor.then(() => true),
-    new Promise((resolve4) => setTimeout(() => resolve4(false), timeoutMs))
+    new Promise((resolve6) => setTimeout(() => resolve6(false), timeoutMs))
   ]);
 }
 async function run(options) {
@@ -77753,12 +78392,12 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync29 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-import { existsSync as existsSync30 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join29 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join31 } from "path";
 
 // src/cli/doctor/spawn-with-timeout.ts
 init_spawn_with_windows_hide();
@@ -77771,8 +78410,8 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
     return { stdout: "", stderr: "", exitCode: 1, timedOut: false };
   }
   let timer;
-  const timeoutPromise = new Promise((resolve4) => {
-    timer = setTimeout(() => resolve4("timeout"), timeoutMs);
+  const timeoutPromise = new Promise((resolve6) => {
+    timer = setTimeout(() => resolve6("timeout"), timeoutMs);
   });
   const processPromise = (async () => {
     await proc.exited;
@@ -77792,22 +78431,22 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
 
 // src/cli/doctor/checks/system-binary.ts
 function getDesktopAppPaths(platform) {
-  const home = homedir6();
+  const home = homedir8();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join29(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join31(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join29(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join31(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join29(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join31(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -77815,8 +78454,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join29(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join29(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join31(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join31(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -77828,7 +78467,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync30) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync33) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -77838,9 +78477,9 @@ function findDesktopBinary(platform = process.platform, checkExists = existsSync
 }
 async function findOpenCodeBinary() {
   for (const binary2 of OPENCODE_BINARIES2) {
-    const path12 = Bun.which(binary2);
-    if (path12) {
-      return { binary: binary2, path: path12 };
+    const path13 = Bun.which(binary2);
+    if (path13) {
+      return { binary: binary2, path: path13 };
     }
   }
   return findDesktopBinary();
@@ -77851,7 +78490,7 @@ async function getOpenCodeVersion3(binaryPath, platform = process.platform) {
     const result = await spawnWithTimeout(command, { stdout: "pipe", stderr: "pipe" });
     if (result.timedOut || result.exitCode !== 0)
       return null;
-    return result.stdout.trim() || null;
+    return extractSemverFromOutput(result.stdout);
   } catch {
     return null;
   }
@@ -77874,12 +78513,12 @@ function compareVersions3(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync31, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync27 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync31(paths.configJsonc))
+  if (existsSync34(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync31(paths.configJson))
+  if (existsSync34(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -77925,7 +78564,7 @@ function getPluginInfo() {
     };
   }
   try {
-    const content = readFileSync25(configPath, "utf-8");
+    const content = readFileSync27(configPath, "utf-8");
     const parsedConfig = parseJsonc(content);
     const pluginEntry = findPluginEntry2(parsedConfig.plugin ?? []);
     if (!pluginEntry) {
@@ -77963,37 +78602,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync28 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join32 } from "path";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join30(homedir7(), "Library", "Caches");
+    return join32(homedir9(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join30(homedir7(), "AppData", "Local");
-  return join30(homedir7(), ".cache");
+    return process.env.LOCALAPPDATA ?? join32(homedir9(), "AppData", "Local");
+  return join32(homedir9(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join30(xdgCacheHome, "opencode");
+    return join32(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join30(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync32(fromShared) || !existsSync32(platformDefault))
+  const platformDefault = join32(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync35(fromShared) || !existsSync35(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync32(dirPath))
+  if (!existsSync35(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync32(filePath))
+  if (!existsSync35(filePath))
     return null;
   try {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     return parseJsonc(content);
   } catch {
     return null;
@@ -78008,11 +78647,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join30(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join32(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync32(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
+  return candidate.packageCandidates.find((packageCandidate) => existsSync35(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -78024,16 +78663,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join30(configDir, "package.json"),
+      cachePackagePath: join32(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     {
       cacheDir,
-      cachePackagePath: join30(cacheDir, "package.json"),
+      cachePackagePath: join32(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync32(packageCandidate.installedPackagePath))) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync35(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const installedPackagePath = selectedPackage.installedPackagePath;
@@ -78060,7 +78699,7 @@ function getSuggestedInstallTag(currentVersion) {
 // src/cli/doctor/checks/system.ts
 init_shared();
 init_plugin_identity();
-var defaultDeps3 = {
+var defaultDeps4 = {
   findOpenCodeBinary,
   getOpenCodeVersion: getOpenCodeVersion3,
   compareVersions: compareVersions3,
@@ -78072,10 +78711,10 @@ var defaultDeps3 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync33(configPath))
+  if (!existsSync36(configPath))
     return false;
   try {
-    parseJsonc(readFileSync27(configPath, "utf-8"));
+    parseJsonc(readFileSync29(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -78095,7 +78734,7 @@ function buildMessage(status, issues) {
     return `${issues.length} system issue(s) detected`;
   return `${issues.length} system warning(s) detected`;
 }
-async function gatherSystemInfo(deps = defaultDeps3) {
+async function gatherSystemInfo(deps = defaultDeps4) {
   const [binaryInfo, pluginInfo] = await Promise.all([
     deps.findOpenCodeBinary(),
     Promise.resolve(deps.getPluginInfo())
@@ -78114,7 +78753,7 @@ async function gatherSystemInfo(deps = defaultDeps3) {
     isLocalDev: pluginInfo.isLocalDev
   };
 }
-async function checkSystem(deps = defaultDeps3) {
+async function checkSystem(deps = defaultDeps4) {
   const [systemInfo, pluginInfo] = await Promise.all([
     gatherSystemInfo(deps),
     Promise.resolve(deps.getPluginInfo())
@@ -78197,32 +78836,32 @@ async function checkSystem(deps = defaultDeps3) {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync30 } from "fs";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync32 } from "fs";
+import { join as join36 } from "path";
 init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync30 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join33 } from "path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join31(xdgConfig, "opencode");
-  return join31(homedir8(), ".config", "opencode");
+    return join33(xdgConfig, "opencode");
+  return join33(homedir10(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join31(configDir, "opencode.json"),
-    join31(configDir, "opencode.jsonc")
+    join33(configDir, "opencode.json"),
+    join33(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync34(configPath))
+    if (!existsSync37(configPath))
       continue;
     try {
-      const content = readFileSync28(configPath, "utf-8");
+      const content = readFileSync30(configPath, "utf-8");
       const data = parseJsonc(content);
       if (data?.provider && typeof data.provider === "object") {
         return Object.keys(data.provider);
@@ -78232,16 +78871,16 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join31(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync34(cacheFile)) {
+  if (!existsSync37(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
     return { providers: [], modelCount: 0, cacheExists: false };
   }
   try {
-    const content = readFileSync28(cacheFile, "utf-8");
+    const content = readFileSync30(cacheFile, "utf-8");
     const data = parseJsonc(content);
     const cacheProviders = Object.keys(data);
     let modelCount = 0;
@@ -78264,14 +78903,14 @@ init_model_capabilities();
 
 // src/cli/doctor/checks/model-resolution-config.ts
 init_shared();
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join32 } from "path";
-var PROJECT_CONFIG_DIR = join32(process.cwd(), ".opencode");
+import { readFileSync as readFileSync31 } from "fs";
+import { join as join34 } from "path";
+var PROJECT_CONFIG_DIR = join34(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR);
   if (projectDetected.format !== "none") {
     try {
-      const content = readFileSync29(projectDetected.path, "utf-8");
+      const content = readFileSync31(projectDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -78281,7 +78920,7 @@ function loadOmoConfig() {
   const userDetected = detectPluginConfigFile(userConfigDir);
   if (userDetected.format !== "none") {
     try {
-      const content = readFileSync29(userDetected.path, "utf-8");
+      const content = readFileSync31(userDetected.path, "utf-8");
       return parseJsonc(content);
     } catch {
       return null;
@@ -78292,7 +78931,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -78334,7 +78973,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join35(getOpenCodeCacheDir(), "models.json");
   details.push("\u2550\u2550\u2550 Available Models (from cache) \u2550\u2550\u2550");
   details.push("");
   if (options.available.cacheExists) {
@@ -78489,7 +79128,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join34(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join36(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -78506,7 +79145,7 @@ function validateConfig() {
     return { exists: false, path: null, valid: true, config: null, errors: [] };
   }
   try {
-    const content = readFileSync30(configPath, "utf-8");
+    const content = readFileSync32(configPath, "utf-8");
     const rawConfig = parseJsonc(content);
     const schemaResult = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     if (!schemaResult.success) {
@@ -78609,27 +79248,27 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname14, join as join36 } from "path";
+import { dirname as dirname16, join as join38 } from "path";
 
 // src/hooks/comment-checker/downloader.ts
-import { join as join35 } from "path";
-import { homedir as homedir9, tmpdir as tmpdir3 } from "os";
+import { join as join37 } from "path";
+import { homedir as homedir11, tmpdir as tmpdir3 } from "os";
 init_binary_downloader();
 init_logger();
 init_plugin_identity();
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join35(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE = join37(tmpdir3(), "comment-checker-debug.log");
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join35(homedir9(), "AppData", "Local");
-    return join35(base2, CACHE_DIR_NAME, "bin");
+    const base2 = localAppData || join37(homedir11(), "AppData", "Local");
+    return join37(base2, CACHE_DIR_NAME, "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join35(homedir9(), ".cache");
-  return join35(base, CACHE_DIR_NAME, "bin");
+  const base = xdgCache || join37(homedir11(), ".cache");
+  return join37(base, CACHE_DIR_NAME, "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
@@ -78641,9 +79280,9 @@ function getCachedBinaryPath2() {
 // src/cli/doctor/checks/dependencies.ts
 async function checkBinaryExists(binary2) {
   try {
-    const path12 = Bun.which(binary2);
-    if (path12) {
-      return { exists: true, path: path12 };
+    const path13 = Bun.which(binary2);
+    if (path13) {
+      return { exists: true, path: path13 };
     }
   } catch {}
   return { exists: false, path: null };
@@ -78693,15 +79332,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync36 } = await import("fs");
-    const { join: join37 } = await import("path");
-    const { homedir: homedir10 } = await import("os");
+    const { existsSync: existsSync39 } = await import("fs");
+    const { join: join39 } = await import("path");
+    const { homedir: homedir12 } = await import("os");
     const pathsToCheck = [
-      join37(homedir10(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join37(process.cwd(), "node_modules", "@ast-grep", "napi")
+      join39(homedir12(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
+      join39(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync36(napiPath)) {
+      if (existsSync39(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -78726,8 +79365,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join36(dirname14(pkgPath), "bin", binaryName);
-    if (existsSync35(binaryPath))
+    const binaryPath = join38(dirname16(pkgPath), "bin", binaryName);
+    if (existsSync38(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -78823,6 +79462,19 @@ async function getGhAuthStatus() {
 async function getGhCliInfo() {
   const binaryStatus = await checkBinaryExists2("gh");
   if (!binaryStatus.exists) {
+    const version4 = await getGhVersion();
+    if (version4) {
+      const authStatus2 = await getGhAuthStatus();
+      return {
+        installed: true,
+        version: version4,
+        path: null,
+        authenticated: authStatus2.authenticated,
+        username: authStatus2.username,
+        scopes: authStatus2.scopes,
+        error: authStatus2.error
+      };
+    }
     return {
       installed: false,
       version: null,
@@ -78888,15 +79540,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync33 } from "fs";
+import { join as join39 } from "path";
 init_shared();
 init_jsonc_parser();
-function loadJsonFile(path12) {
-  if (!existsSync36(path12))
+function loadJsonFile(path13) {
+  if (!existsSync39(path13))
     return null;
   try {
-    return parseJsonc(readFileSync31(path12, "utf-8"));
+    return parseJsonc(readFileSync33(path13, "utf-8"));
   } catch {
     return null;
   }
@@ -78905,9 +79557,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join37(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join39(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join37(configDir, "opencode")).path
+    opencode: detectConfigFile(join39(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -78976,21 +79628,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync37 } from "fs";
-import { delimiter as delimiter2, join as join39 } from "path";
+import { existsSync as existsSync40 } from "fs";
+import { delimiter as delimiter2, join as join41 } from "path";
 
 // src/tools/lsp/server-path-bases.ts
 init_shared();
-import { join as join38 } from "path";
+import { join as join40 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join38(getDataDir(), "opencode");
+  const dataDir = join40(getDataDir(), "opencode");
   return [
-    join38(workingDirectory, "node_modules", ".bin"),
-    join38(configDir, "bin"),
-    join38(configDir, "node_modules", ".bin"),
-    join38(dataDir, "bin"),
-    join38(dataDir, "bin", "node_modules", ".bin")
+    join40(workingDirectory, "node_modules", ".bin"),
+    join40(configDir, "bin"),
+    join40(configDir, "node_modules", ".bin"),
+    join40(dataDir, "bin"),
+    join40(dataDir, "bin", "node_modules", ".bin")
   ];
 }
 
@@ -79000,7 +79652,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync37(cmd))
+    if (existsSync40(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -79021,14 +79673,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync37(join39(p2, cmd + suffix))) {
+      if (existsSync40(join41(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync37(join39(base, cmd + suffix))) {
+      if (existsSync40(join41(base, cmd + suffix))) {
         return true;
       }
     }
@@ -79090,24 +79742,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync38, readFileSync as readFileSync32 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join40 } from "path";
+import { existsSync as existsSync41, readFileSync as readFileSync34 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join42 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join40(homedir10(), ".claude", ".mcp.json"),
-    join40(process.cwd(), ".mcp.json"),
-    join40(process.cwd(), ".claude", ".mcp.json")
+    join42(homedir12(), ".claude", ".mcp.json"),
+    join42(process.cwd(), ".mcp.json"),
+    join42(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync38(configPath))
+    if (!existsSync41(configPath))
       continue;
     try {
-      const content = readFileSync32(configPath, "utf-8");
+      const content = readFileSync34(configPath, "utf-8");
       const config2 = parseJsonc(content);
       if (config2.mcpServers) {
         Object.assign(servers, config2.mcpServers);
@@ -79238,6 +79890,89 @@ async function checkTools() {
     issues
   };
 }
+
+// src/features/team-mode/deps.ts
+init_bun_spawn_shim();
+async function checkTeamModeDependencies(config2) {
+  const tmuxAvailable = Boolean(process.env["TMUX"]) || await probeBinary("tmux", ["-V"]);
+  const gitAvailable = await probeBinary("git", ["--version"]);
+  if (config2.tmux_visualization && !tmuxAvailable) {
+    console.warn("[team-mode] tmux_visualization=true but tmux not available; layout will be skipped at runtime");
+  }
+  return { tmuxAvailable, gitAvailable };
+}
+async function probeBinary(cmd, args) {
+  try {
+    const proc = spawn({ cmd: [cmd, ...args], stdout: "pipe", stderr: "pipe" });
+    const code = await proc.exited;
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/features/team-mode/team-registry/paths.ts
+init_logger();
+import { homedir as homedir13 } from "os";
+import path13 from "path";
+function resolveBaseDir(config2) {
+  return config2.base_dir ?? path13.join(homedir13(), ".omo");
+}
+
+// src/cli/doctor/checks/team-mode.ts
+init_shared();
+import { readFileSync as readFileSync35, promises as fs12 } from "fs";
+import path14 from "path";
+async function checkTeamMode() {
+  const config2 = loadTeamModeConfig();
+  const teamModeConfig = TeamModeConfigSchema.parse(config2.team_mode ?? {});
+  if (!teamModeConfig.enabled) {
+    return { name: CHECK_NAMES[CHECK_IDS.TEAM_MODE], status: "skip", message: "team_mode: disabled", issues: [] };
+  }
+  const deps = await checkTeamModeDependencies(teamModeConfig);
+  const baseDir = resolveBaseDir(teamModeConfig);
+  const [baseDirExists, teamCount, runtimeCount] = await Promise.all([
+    pathExists(baseDir),
+    safeCount(path14.join(baseDir, "teams")),
+    safeCount(path14.join(baseDir, "runtime"))
+  ]);
+  const baseDirMessage = baseDirExists ? `base dir: ok` : `base dir: missing (plugin init will create it on first use)`;
+  return {
+    name: CHECK_NAMES[CHECK_IDS.TEAM_MODE],
+    status: deps.tmuxAvailable && deps.gitAvailable ? "pass" : "warn",
+    message: `team_mode: enabled | tmux: ${deps.tmuxAvailable ? "ok" : "missing"} | git: ${deps.gitAvailable ? "ok" : "missing"} | ${baseDirMessage} | declared: ${teamCount} | runtime dirs: ${runtimeCount}`,
+    details: undefined,
+    issues: []
+  };
+}
+function loadTeamModeConfig() {
+  const projectConfig = detectPluginConfigFile(path14.join(process.cwd(), ".opencode"));
+  const userConfig = detectPluginConfigFile(getOpenCodeConfigDir({ binary: "opencode" }));
+  const configPath = projectConfig.format !== "none" ? projectConfig.path : userConfig.path;
+  if (!configPath)
+    return { team_mode: undefined };
+  try {
+    return parseJsonc(readFileSync35(configPath, "utf-8"));
+  } catch {
+    return { team_mode: undefined };
+  }
+}
+async function safeCount(dir) {
+  try {
+    const entries = await fs12.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).length;
+  } catch {
+    return 0;
+  }
+}
+async function pathExists(dir) {
+  try {
+    const stats = await fs12.stat(dir);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
 // src/cli/doctor/checks/index.ts
 function getAllCheckDefinitions() {
   return [
@@ -79261,6 +79996,11 @@ function getAllCheckDefinitions() {
       id: CHECK_IDS.MODELS,
       name: CHECK_NAMES[CHECK_IDS.MODELS],
       check: checkModels
+    },
+    {
+      id: CHECK_IDS.TEAM_MODE,
+      name: CHECK_NAMES[CHECK_IDS.TEAM_MODE],
+      check: checkTeamMode
     }
   ];
 }
@@ -79567,8 +80307,18 @@ async function runDoctor(options) {
 
 // src/cli/doctor/index.ts
 async function doctor(options = { mode: "default" }) {
-  const result = await runDoctor(options);
-  return result.exitCode;
+  try {
+    const result = await runDoctor(options);
+    return result.exitCode;
+  } catch (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    console.error(`
+Doctor failed unexpectedly:`, message);
+    console.error("This may indicate memory pressure (OOM/SIGKILL) or a corrupted installation.");
+    console.error(`Try: OMO_DISABLE_POSTHOG=1 bunx oh-my-opencode doctor --verbose
+`);
+    return EXIT_CODES.FAILURE;
+  }
 }
 
 // src/cli/refresh-model-capabilities.ts
@@ -79605,11 +80355,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync as chmodSync2, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync33, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname15, join as join41 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync42, mkdirSync as mkdirSync12, readFileSync as readFileSync36, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname17, join as join43 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join41(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join43(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -79646,11 +80396,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync39(filePath)) {
+  if (!existsSync42(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync33(filePath, "utf-8");
+    const content = readFileSync36(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -79659,8 +80409,8 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname15(filePath);
-    if (!existsSync39(dir)) {
+    const dir = dirname17(filePath);
+    if (!existsSync42(dir)) {
       mkdirSync12(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
@@ -79697,7 +80447,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync39(filePath)) {
+      if (existsSync42(filePath)) {
         unlinkSync6(filePath);
       }
       return true;
@@ -79866,7 +80616,7 @@ async function getOrRegisterClient(options) {
   }
 }
 function parseRegistrationResponse(data) {
-  if (!isRecord7(data))
+  if (!isRecord8(data))
     return null;
   const clientId = data.client_id;
   if (typeof clientId !== "string" || clientId.length === 0)
@@ -79877,7 +80627,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -79892,7 +80642,7 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 // src/features/mcp-oauth/oauth-authorization-flow.ts
 import { spawn as spawn2 } from "child_process";
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 function generateCodeVerifier() {
   return randomBytes2(32).toString("base64url");
 }
@@ -79917,9 +80667,9 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     let timeoutId;
-    const server2 = createServer((request, response) => {
+    const server2 = createServer2((request, response) => {
       clearTimeout(timeoutId);
       const requestUrl = new URL(request.url ?? "/", `http://localhost:${port}`);
       const code = requestUrl.searchParams.get("code");
@@ -79943,7 +80693,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve4({ code, state: state2 });
+      resolve6({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -80276,6 +81026,163 @@ function createMcpOAuthCommand() {
   return mcp;
 }
 
+// src/cli/boulder/boulder.ts
+import { existsSync as existsSync43 } from "fs";
+
+// src/cli/boulder/formatter.ts
+var import_picocolors21 = __toESM(require_picocolors(), 1);
+function colorizeStatus(status2) {
+  if (status2 === "active") {
+    return import_picocolors21.default.cyan(status2);
+  }
+  if (status2 === "completed") {
+    return import_picocolors21.default.green(status2);
+  }
+  if (status2 === "paused") {
+    return import_picocolors21.default.yellow(status2);
+  }
+  return import_picocolors21.default.red(status2);
+}
+function formatCurrentTask(work) {
+  if (!work.current_task) {
+    return "-";
+  }
+  const elapsed = work.current_task.elapsed_human ? ` (${work.current_task.elapsed_human})` : "";
+  return `${work.current_task.task_title}${elapsed}`;
+}
+function formatWorkBlock(work) {
+  const elapsed = work.elapsed_human ?? "-";
+  const progress = `${work.percentage}% (${work.completed_tasks}/${work.total_tasks})`;
+  return [
+    `plan: ${work.plan_name}`,
+    `status: ${colorizeStatus(work.status)}`,
+    `progress: ${progress}`,
+    `elapsed: ${elapsed}`,
+    `sessions: ${work.session_count}`,
+    `current task: ${formatCurrentTask(work)}`
+  ].join(`
+`);
+}
+function formatTextOutput(result) {
+  const separator = import_picocolors21.default.dim("----------------------------------------");
+  const blocks = result.works.map((work) => formatWorkBlock(work));
+  return ["boulder progress", ...blocks].join(`
+${separator}
+`);
+}
+function formatJsonOutput3(result) {
+  return JSON.stringify(result, null, 2);
+}
+function formatNoBoulderMessage(isJson) {
+  if (isJson) {
+    return JSON.stringify({
+      error: "No boulder state found."
+    });
+  }
+  return "No boulder state found.";
+}
+function formatReadErrorMessage(isJson) {
+  if (isJson) {
+    return JSON.stringify({
+      error: "Failed to read boulder state."
+    });
+  }
+  return "Failed to read boulder state.";
+}
+
+// src/cli/boulder/boulder.ts
+function formatDurationHuman(durationMs) {
+  if (durationMs < 1000) {
+    return `${durationMs}ms`;
+  }
+  const totalSeconds = Math.floor(durationMs / 1000);
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function getElapsedMs(work) {
+  if (work.elapsed_ms !== undefined) {
+    return work.elapsed_ms;
+  }
+  const startedAtMs = Date.parse(work.started_at);
+  if (Number.isNaN(startedAtMs)) {
+    return;
+  }
+  const endedAtMs = work.ended_at ? Date.parse(work.ended_at) : Date.now();
+  if (Number.isNaN(endedAtMs)) {
+    return;
+  }
+  return Math.max(0, endedAtMs - startedAtMs);
+}
+function buildCliWork(directory, work) {
+  const planPath = resolveBoulderPlanPathForWork(directory, work);
+  const progress = getPlanProgress(planPath);
+  const elapsedMs = getElapsedMs(work);
+  const currentTask = readCurrentTopLevelTask(planPath);
+  const taskSession = currentTask ? work.task_sessions?.[currentTask.key] : undefined;
+  let currentTaskElapsedHuman;
+  if (taskSession?.elapsed_ms !== undefined) {
+    currentTaskElapsedHuman = formatDurationHuman(taskSession.elapsed_ms);
+  } else if (taskSession?.started_at) {
+    const startedAtMs = Date.parse(taskSession.started_at);
+    if (!Number.isNaN(startedAtMs)) {
+      currentTaskElapsedHuman = formatDurationHuman(Math.max(0, Date.now() - startedAtMs));
+    }
+  }
+  return {
+    work_id: work.work_id,
+    plan_name: work.plan_name,
+    active_plan: work.active_plan,
+    worktree_path: work.worktree_path,
+    status: work.status ?? "active",
+    started_at: work.started_at,
+    ended_at: work.ended_at,
+    elapsed_ms: elapsedMs,
+    elapsed_human: elapsedMs !== undefined ? formatDurationHuman(elapsedMs) : undefined,
+    total_tasks: progress.total,
+    completed_tasks: progress.completed,
+    remaining_tasks: Math.max(0, progress.total - progress.completed),
+    percentage: progress.total > 0 ? Math.round(progress.completed / progress.total * 100) : 0,
+    session_count: work.session_ids.length,
+    current_task: currentTask ? {
+      task_key: currentTask.key,
+      task_title: currentTask.title,
+      elapsed_human: currentTaskElapsedHuman
+    } : undefined
+  };
+}
+async function boulder(options) {
+  const directory = options.directory ?? process.cwd();
+  const boulderFilePath = getBoulderFilePath(directory);
+  const state2 = readBoulderState(directory);
+  if (!state2) {
+    const message = existsSync43(boulderFilePath) ? formatReadErrorMessage(options.json) : formatNoBoulderMessage(options.json);
+    process.stderr.write(`${message}
+`);
+    return existsSync43(boulderFilePath) ? 2 : 1;
+  }
+  const works = getBoulderWorks(state2);
+  const filteredWorks = options.workId ? works.filter((work) => work.work_id === options.workId) : works;
+  if (filteredWorks.length === 0) {
+    process.stderr.write(`${formatNoBoulderMessage(options.json)}
+`);
+    return 1;
+  }
+  const cliWorks = filteredWorks.map((work) => buildCliWork(directory, work));
+  const result = { works: cliWorks };
+  const output = options.json ? formatJsonOutput3(result) : formatTextOutput(result);
+  process.stdout.write(`${output}
+`);
+  return 0;
+}
 // src/cli/cli-program.ts
 var VERSION2 = package_default.version;
 var program2 = new Command;
@@ -80402,6 +81309,14 @@ program2.command("refresh-model-capabilities").description("Refresh the cached m
 program2.command("version").description("Show version information").action(() => {
   console.log(`oh-my-opencode v${VERSION2}`);
 });
+program2.command("boulder").description("Show boulder progress, elapsed time, and per-task statistics").option("-d, --directory <path>", "Working directory").option("-w, --work-id <id>", "Filter to a specific work").option("--json", "Output as JSON").action(async (options) => {
+  const exitCode = await boulder({
+    directory: options.directory,
+    workId: options.workId,
+    json: options.json ?? false
+  });
+  process.exit(exitCode);
+});
 program2.addCommand(createMcpOAuthCommand());
 function runCli() {
   program2.parse();