oh-my-opencode 4.0.0 → 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();
@@ -6794,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();
 });
@@ -6985,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",
@@ -7099,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: {
@@ -7114,7 +7293,9 @@ var init_model_requirements = __esm(() => {
           model: "claude-opus-4-7",
           variant: "max"
         },
-        { providers: ["openai", "github-copilot", "opencode", "vercel"], model: "gpt-5.5" }
+        { 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: {
@@ -7245,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();
 }
@@ -7254,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 });
     }
   }
@@ -7267,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));
@@ -7293,7 +7474,7 @@ function createJsonFileCacheStore(options) {
     if (writtenInCurrentProcess) {
       return true;
     }
-    return existsSync7(getCacheFilePath());
+    return existsSync8(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7325,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) {
@@ -7392,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;
@@ -7469,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();
@@ -50237,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",
@@ -50253,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) {
@@ -50271,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());
@@ -50282,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);
@@ -50303,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);
@@ -50320,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);
@@ -50368,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);
@@ -50459,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) {
@@ -50479,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;
@@ -50487,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);
@@ -50534,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)) {
@@ -50636,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";
 }
@@ -50662,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;
@@ -50708,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;
       }
     }
@@ -50747,13 +50934,15 @@ 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, SESSION_MISSING_GRACE_MS;
 var init_constants2 = __esm(() => {
   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();
@@ -50836,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) {
@@ -50850,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"];
@@ -50870,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"];
@@ -50896,7 +51085,7 @@ function tryInjectViaFetchWrapper(internal, auth) {
     return false;
   }
   const config = getConfig();
-  if (!isRecord4(config)) {
+  if (!isRecord6(config)) {
     return false;
   }
   const fetchValue = config["fetch"];
@@ -50910,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"];
@@ -50921,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"];
@@ -50969,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();
@@ -50976,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++) {
@@ -51005,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 = () => {};
@@ -51029,15 +51247,15 @@ var init_opencode_command_dirs = __esm(() => {
 });
 
 // src/shared/project-discovery-dirs.ts
-import { existsSync as existsSync11, realpathSync as realpathSync4 } from "fs";
-import { dirname as dirname3, join as join13, resolve as resolve4 } from "path";
-function normalizePath(path5) {
-  const resolvedPath = resolve4(path5);
-  if (!existsSync11(resolvedPath)) {
+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 realpathSync4(resolvedPath);
+    return realpathSync5(resolvedPath);
   } catch {
     return resolvedPath;
   }
@@ -51048,8 +51266,8 @@ function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
   let currentDirectory = normalizePath(startDirectory);
   const resolvedStopDirectory = stopDirectory ? normalizePath(stopDirectory) : undefined;
   while (true) {
-    const opencodeDirectory = join13(currentDirectory, ".opencode");
-    if (existsSync11(opencodeDirectory)) {
+    const opencodeDirectory = join14(currentDirectory, ".opencode");
+    if (existsSync12(opencodeDirectory)) {
       const detected = detectPluginConfigFile(opencodeDirectory);
       if (detected.format !== "none" && !seen.has(detected.path)) {
         seen.add(detected.path);
@@ -51059,7 +51277,7 @@ function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
     if (resolvedStopDirectory === currentDirectory) {
       return paths;
     }
-    const parentDirectory = dirname3(currentDirectory);
+    const parentDirectory = dirname4(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return paths;
     }
@@ -51075,6 +51293,11 @@ var init_project_discovery_dirs = __esm(() => {
 // 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(() => {
@@ -51161,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
@@ -51322,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();
@@ -51335,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();
@@ -51420,17 +51646,17 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname4 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname5 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync12(configPath)) {
+  if (!existsSync13(configPath)) {
     return { success: true };
   }
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp2}`;
   try {
-    const dir = dirname4(backupPath);
-    if (!existsSync12(dir)) {
+    const dir = dirname5(backupPath);
+    if (!existsSync13(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
@@ -51445,10 +51671,10 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync13(configDir)) {
+  if (!existsSync14(configDir)) {
     mkdirSync6(configDir, { recursive: true });
   }
 }
@@ -51486,14 +51712,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync14(configJsonc)) {
+  if (existsSync15(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync14(configJson)) {
+  if (existsSync15(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -51503,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(() => {
@@ -51619,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();
@@ -51630,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"
       };
     }
@@ -51659,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}`
         };
       }
@@ -51676,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) {
@@ -51685,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")
     };
   }
@@ -52036,12 +52262,12 @@ var init_generate_omo_config = __esm(() => {
 });
 
 // src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync15, readFileSync as readFileSync9, renameSync as renameSync2, rmSync } from "fs";
-import { join as join14, dirname as dirname5, 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 = dirname5(legacyPath);
+  const dir = dirname6(legacyPath);
   const ext = basename2(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join14(dir, `${CONFIG_BASENAME}${ext}`);
+  return join15(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -52074,13 +52300,13 @@ function archiveLegacyConfigFile(legacyPath) {
 }
 function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   const legacySidecarPath = getSidecarPath(legacyPath);
-  if (!existsSync15(legacySidecarPath))
+  if (!existsSync16(legacySidecarPath))
     return true;
   const canonicalSidecarPath = getSidecarPath(canonicalPath);
-  if (existsSync15(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,
@@ -52097,15 +52323,15 @@ function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync15(legacyPath))
+  if (!existsSync16(legacyPath))
     return false;
   if (!basename2(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync15(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);
@@ -52146,8 +52372,8 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename3, dirname as dirname6, extname, join as join15 } 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;
 }
@@ -52162,12 +52388,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join15(dirname6(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) || existsSync16(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync17(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync16(omoConfigPath)) {
+    if (existsSync17(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -52178,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) + `
 `);
@@ -52224,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";
@@ -52293,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 };
       }
@@ -52314,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();
@@ -52322,10 +52600,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync17(omoConfigPath)) {
+  if (!existsSync18(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -52336,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 {
@@ -52388,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;
   }
@@ -52425,16 +52703,16 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync18 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join17 } from "path";
 function getDefaultWorkspaceDir() {
-  return join16(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") {
@@ -52454,7 +52732,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync18(packageJsonPath)) {
+  if (!existsSync19(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -52597,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;
@@ -52608,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);
   }
 });
 
@@ -52635,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);
@@ -52672,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 = {};
@@ -52682,7 +52960,7 @@ var require_isexe = __commonJS((exports, module) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve5, reject) {
-        isexe(path6, options || {}, function(er, is) {
+        isexe(path7, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
@@ -52691,7 +52969,7 @@ var require_isexe = __commonJS((exports, module) => {
         });
       });
     }
-    core3(path6, options || {}, function(er, is) {
+    core3(path7, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -52701,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;
@@ -52717,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" });
@@ -52753,7 +53031,7 @@ var require_which = __commonJS((exports, module) => {
         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;
       resolve5(subStep(p2, i2, 0));
     });
@@ -52780,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];
@@ -52821,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) {
@@ -52838,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) {
@@ -52846,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;
   }
@@ -52891,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;
     }
@@ -52920,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();
@@ -52945,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(" ");
@@ -53049,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(() => {
@@ -53074,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);
       }
@@ -53155,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");
@@ -53170,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;
@@ -53245,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");
@@ -53254,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);
@@ -53270,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);
@@ -53414,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);
@@ -53431,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 };
@@ -53442,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 });
@@ -53518,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");
 }
@@ -53547,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);
   }
@@ -53561,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;
@@ -53622,8 +53900,8 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync30 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { join as join30 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
@@ -53673,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) {
@@ -53731,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();
@@ -53740,9 +54018,9 @@ var init_background_update_check = __esm(() => {
   init_constants3();
   init_checker();
   init_update_toasts();
-  defaultDeps = {
-    existsSync: existsSync30,
-    join: join29,
+  defaultDeps2 = {
+    existsSync: existsSync32,
+    join: join30,
     runBunInstallWithDetails,
     log,
     getOpenCodeCacheDir,
@@ -53927,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,
@@ -53984,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;
@@ -54004,7 +54282,7 @@ var init_hook = __esm(() => {
   init_model_capabilities_status();
   init_model_cache_warning();
   init_startup_toasts();
-  defaultDeps2 = {
+  defaultDeps3 = {
     getCachedVersion,
     getLocalDevVersion,
     showConfigErrorsIfAny,
@@ -54054,7 +54332,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.0.0",
+  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",
@@ -54088,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",
@@ -54114,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",
@@ -54135,19 +54413,25 @@ var package_default = {
     zod: "^4.3.0"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.0.0",
-    "oh-my-opencode-darwin-x64": "4.0.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.0.0",
-    "oh-my-opencode-linux-arm64": "4.0.0",
-    "oh-my-opencode-linux-arm64-musl": "4.0.0",
-    "oh-my-opencode-linux-x64": "4.0.0",
-    "oh-my-opencode-linux-x64-baseline": "4.0.0",
-    "oh-my-opencode-linux-x64-musl": "4.0.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.0.0",
-    "oh-my-opencode-windows-x64": "4.0.0",
-    "oh-my-opencode-windows-x64-baseline": "4.0.0"
+    "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",
@@ -55434,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") {
@@ -55946,8 +56230,8 @@ async function processEvents(ctx, stream, state) {
 }
 // src/plugin-config.ts
 import * as fs4 from "fs";
-import { homedir as homedir4 } from "os";
-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 = {};
@@ -56714,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);
@@ -57098,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;
   });
 }
@@ -57285,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) {
@@ -57295,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;
@@ -57327,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")
@@ -69075,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}`);
     }
@@ -69818,6 +70102,7 @@ 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
@@ -70000,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(),
@@ -70043,15 +70329,93 @@ 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 ?? homedir4();
+  return process.env.HOME ?? process.env.USERPROFILE ?? homedir5();
 }
 function resolveConfigPathAfterLegacyMigration(detectedPath) {
-  if (!path5.basename(detectedPath).startsWith(LEGACY_CONFIG_BASENAME)) {
+  if (!path6.basename(detectedPath).startsWith(LEGACY_CONFIG_BASENAME)) {
     return detectedPath;
   }
   const migrated = migrateLegacyConfigFile(detectedPath);
-  const canonicalPath = path5.join(path5.dirname(detectedPath), `${CONFIG_BASENAME}${path5.extname(detectedPath)}`);
+  const canonicalPath = path6.join(path6.dirname(detectedPath), `${CONFIG_BASENAME}${path6.extname(detectedPath)}`);
   if (migrated || fs4.existsSync(canonicalPath)) {
     return canonicalPath;
   }
@@ -70124,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;
       }
@@ -70135,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;
       }
@@ -70208,7 +70574,7 @@ 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,
@@ -70227,7 +70593,7 @@ function loadPluginConfig(directory, ctx) {
     stopDirectory
   });
   const canonicalAncestorPathsNearestFirst = ancestorConfigPathsNearestFirst.map((ancestorPath) => {
-    const opencodeDir = path5.dirname(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.", {
@@ -70250,8 +70616,8 @@ function loadPluginConfig(directory, ctx) {
     const ancestorConfig = loadConfigFromPath(ancestorPath, ctx);
     const ancestorOverrides = loadExplicitGitMasterOverrides(ancestorPath);
     if (ancestorConfig?.agent_definitions) {
-      const ancestorBasePath = path5.dirname(ancestorPath);
-      const ancestorDir = path5.dirname(ancestorBasePath);
+      const ancestorBasePath = path6.dirname(ancestorPath);
+      const ancestorDir = path6.dirname(ancestorBasePath);
       ancestorConfig.agent_definitions = resolveAgentDefinitionPaths(ancestorConfig.agent_definitions, ancestorBasePath, ancestorDir);
     }
     if (ancestorConfig) {
@@ -70522,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) {
@@ -70541,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;
       }
@@ -70572,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("?")) {
@@ -71807,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 dirname8, join as join18 } 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) {
@@ -71830,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(join18(entry, command));
+      addCandidate(join19(entry, command));
     }
   }
   return candidates;
@@ -71857,7 +72223,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe = can
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname8(binaryPath);
+  const preferredDir = dirname9(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter);
 }
@@ -72232,11 +72598,69 @@ 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 existsSync20, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
-import { basename as basename5, dirname as dirname9, isAbsolute as isAbsolute3, join as join19, relative as relative2, resolve as resolve5 } 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 join19(directory, BOULDER_DIR, BOULDER_FILE);
+  return join20(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function resolveTrackedPath(baseDirectory, trackedPath) {
   return isAbsolute3(trackedPath) ? resolve5(trackedPath) : resolve5(baseDirectory, trackedPath);
@@ -72254,15 +72678,15 @@ function resolveBoulderPlanPath(directory, state) {
   }
   const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
   const worktreePlanPath = resolve5(absoluteWorktreePath, relativePlanPath);
-  return existsSync20(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+  return existsSync21(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync20(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;
@@ -72282,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;
   }
@@ -72295,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 (!existsSync20(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) {
@@ -72307,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) {
@@ -72358,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;
@@ -72371,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 existsSync21, mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } 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 join20(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join21(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync21(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;
@@ -72442,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 join21 } from "path";
+import { readFileSync as readFileSync17, readdirSync as readdirSync4 } from "fs";
+import { join as join22 } from "path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -72491,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(join21(messageDir, fileName), "utf-8");
+        const content = readFileSync17(join22(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -72524,8 +73024,8 @@ init_agent_display_names();
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync22, readFileSync as readFileSync16, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname10, join as join22 } 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";
@@ -72534,15 +73034,15 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join22(directory, customPath) : join22(directory, DEFAULT_STATE_FILE);
+  return customPath ? join23(directory, customPath) : join23(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync22(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;
@@ -72987,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 dirname11, posix, sep } from "path";
+import { dirname as dirname12, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -72996,7 +73496,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(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)
@@ -73018,8 +73518,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(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
@@ -75334,9 +75834,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path6, ranges, output) {
+function getContextLinesFromFile(path7, ranges, output) {
   return new Promise((resolve6) => {
-    const stream = createReadStream(path6);
+    const stream = createReadStream(path7);
     const lineReaded = createInterface2({
       input: stream
     });
@@ -75352,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();
@@ -75420,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)
@@ -77434,11 +77934,11 @@ init_data_path();
 init_logger();
 init_plugin_identity();
 init_write_file_atomically();
-import { existsSync as existsSync23, mkdirSync as mkdirSync10, readFileSync as readFileSync17 } from "fs";
-import { join as join23 } 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 join23(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);
@@ -77448,11 +77948,11 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync23(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 {};
@@ -77469,7 +77969,7 @@ function readPostHogActivityState() {
 function writePostHogActivityState(nextState) {
   const stateFilePath = getPostHogActivityStateFilePath();
   try {
-    mkdirSync10(join23(getDataDir(), CACHE_DIR_NAME), { recursive: true });
+    mkdirSync10(join24(getDataDir(), CACHE_DIR_NAME), { recursive: true });
     writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}
 `);
   } catch (error48) {
@@ -77892,12 +78392,12 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync34, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync29 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-import { existsSync as existsSync31 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join30 } 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();
@@ -77931,22 +78431,22 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
 
 // src/cli/doctor/checks/system-binary.ts
 function getDesktopAppPaths(platform) {
-  const home = homedir7();
+  const home = homedir8();
   switch (platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join30(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(join30(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join31(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join30(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join31(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -77954,8 +78454,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join30(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join30(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 [];
@@ -77967,7 +78467,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync31) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync33) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -77977,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();
@@ -77990,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;
   }
@@ -78013,12 +78513,12 @@ function compareVersions3(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync32, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync27 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync32(paths.configJsonc))
+  if (existsSync34(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync32(paths.configJson))
+  if (existsSync34(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -78064,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) {
@@ -78102,37 +78602,37 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync33, readFileSync as readFileSync26 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join31 } 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 join31(homedir8(), "Library", "Caches");
+    return join32(homedir9(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join31(homedir8(), "AppData", "Local");
-  return join31(homedir8(), ".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 join31(xdgCacheHome, "opencode");
+    return join32(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join31(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync33(fromShared) || !existsSync33(platformDefault))
+  const platformDefault = join32(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync35(fromShared) || !existsSync35(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync33(dirPath))
+  if (!existsSync35(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync33(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;
@@ -78147,11 +78647,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join31(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join32(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync33(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]);
@@ -78163,16 +78663,16 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join31(configDir, "package.json"),
+      cachePackagePath: join32(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     {
       cacheDir,
-      cachePackagePath: join31(cacheDir, "package.json"),
+      cachePackagePath: join32(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync33(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;
@@ -78199,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,
@@ -78211,10 +78711,10 @@ var defaultDeps3 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync34(configPath))
+  if (!existsSync36(configPath))
     return false;
   try {
-    parseJsonc(readFileSync27(configPath, "utf-8"));
+    parseJsonc(readFileSync29(configPath, "utf-8"));
     return true;
   } catch {
     return false;
@@ -78234,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())
@@ -78253,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())
@@ -78336,32 +78836,32 @@ async function checkSystem(deps = defaultDeps3) {
 }
 
 // src/cli/doctor/checks/config.ts
-import { readFileSync as readFileSync30 } from "fs";
-import { join as join35 } 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 existsSync35, readFileSync as readFileSync28 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join32 } 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 join32(xdgConfig, "opencode");
-  return join32(homedir9(), ".config", "opencode");
+    return join33(xdgConfig, "opencode");
+  return join33(homedir10(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join32(configDir, "opencode.json"),
-    join32(configDir, "opencode.jsonc")
+    join33(configDir, "opencode.json"),
+    join33(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync35(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);
@@ -78371,16 +78871,16 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join32(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync35(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;
@@ -78403,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 join33 } from "path";
-var PROJECT_CONFIG_DIR = join33(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;
@@ -78420,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;
@@ -78431,7 +78931,7 @@ function loadOmoConfig() {
 
 // src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 
 // src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -78473,7 +78973,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join34(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) {
@@ -78628,7 +79128,7 @@ async function checkModels() {
 }
 
 // src/cli/doctor/checks/config.ts
-var PROJECT_CONFIG_DIR2 = join35(process.cwd(), ".opencode");
+var PROJECT_CONFIG_DIR2 = join36(process.cwd(), ".opencode");
 function findConfigPath() {
   const projectConfig = detectPluginConfigFile(PROJECT_CONFIG_DIR2);
   if (projectConfig.format !== "none")
@@ -78645,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) {
@@ -78748,27 +79248,27 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname15, join as join37 } from "path";
+import { dirname as dirname16, join as join38 } from "path";
 
 // src/hooks/comment-checker/downloader.ts
-import { join as join36 } from "path";
-import { homedir as homedir10, 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 = join36(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 || join36(homedir10(), "AppData", "Local");
-    return join36(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 || join36(homedir10(), ".cache");
-  return join36(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";
@@ -78780,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 };
@@ -78832,15 +79332,15 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync37 } = await import("fs");
-    const { join: join38 } = await import("path");
-    const { homedir: homedir11 } = await import("os");
+    const { existsSync: existsSync39 } = await import("fs");
+    const { join: join39 } = await import("path");
+    const { homedir: homedir12 } = await import("os");
     const pathsToCheck = [
-      join38(homedir11(), ".config", "opencode", "node_modules", "@ast-grep", "napi"),
-      join38(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 (existsSync37(napiPath)) {
+      if (existsSync39(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -78865,8 +79365,8 @@ function findCommentCheckerPackageBinary() {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
-    const binaryPath = join37(dirname15(pkgPath), "bin", binaryName);
-    if (existsSync36(binaryPath))
+    const binaryPath = join38(dirname16(pkgPath), "bin", binaryName);
+    if (existsSync38(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -79040,15 +79540,15 @@ var BUILTIN_SERVERS = {
   "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
 };
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync37, readFileSync as readFileSync31 } from "fs";
-import { join as join38 } 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 (!existsSync37(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;
   }
@@ -79057,9 +79557,9 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectPluginConfigFile(join38(cwd, ".opencode")).path,
+    project: detectPluginConfigFile(join39(cwd, ".opencode")).path,
     user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join38(configDir, "opencode")).path
+    opencode: detectConfigFile(join39(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -79128,21 +79628,21 @@ function getMergedServers() {
 }
 
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync38 } from "fs";
-import { delimiter as delimiter2, join as join40 } 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 join39 } from "path";
+import { join as join40 } from "path";
 function getLspServerAdditionalPathBases(workingDirectory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join39(getDataDir(), "opencode");
+  const dataDir = join40(getDataDir(), "opencode");
   return [
-    join39(workingDirectory, "node_modules", ".bin"),
-    join39(configDir, "bin"),
-    join39(configDir, "node_modules", ".bin"),
-    join39(dataDir, "bin"),
-    join39(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")
   ];
 }
 
@@ -79152,7 +79652,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync38(cmd))
+    if (existsSync40(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -79173,14 +79673,14 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(delimiter2);
   for (const p2 of paths) {
     for (const suffix of exts) {
-      if (existsSync38(join40(p2, cmd + suffix))) {
+      if (existsSync40(join41(p2, cmd + suffix))) {
         return true;
       }
     }
   }
   for (const base of getLspServerAdditionalPathBases(process.cwd())) {
     for (const suffix of exts) {
-      if (existsSync38(join40(base, cmd + suffix))) {
+      if (existsSync40(join41(base, cmd + suffix))) {
         return true;
       }
     }
@@ -79242,24 +79742,24 @@ function getInstalledLspServers() {
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync39, readFileSync as readFileSync32 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join41 } 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 [
-    join41(homedir11(), ".claude", ".mcp.json"),
-    join41(process.cwd(), ".mcp.json"),
-    join41(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 (!existsSync39(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);
@@ -79392,6 +79892,7 @@ async function checkTools() {
 }
 
 // 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"]);
@@ -79402,7 +79903,7 @@ async function checkTeamModeDependencies(config2) {
 }
 async function probeBinary(cmd, args) {
   try {
-    const proc = Bun.spawn({ cmd: [cmd, ...args], stdout: "pipe", stderr: "pipe" });
+    const proc = spawn({ cmd: [cmd, ...args], stdout: "pipe", stderr: "pipe" });
     const code = await proc.exited;
     return code === 0;
   } catch {
@@ -79412,16 +79913,16 @@ async function probeBinary(cmd, args) {
 
 // src/features/team-mode/team-registry/paths.ts
 init_logger();
-import { homedir as homedir12 } from "os";
-import path12 from "path";
+import { homedir as homedir13 } from "os";
+import path13 from "path";
 function resolveBaseDir(config2) {
-  return config2.base_dir ?? path12.join(homedir12(), ".omo");
+  return config2.base_dir ?? path13.join(homedir13(), ".omo");
 }
 
 // src/cli/doctor/checks/team-mode.ts
 init_shared();
-import { readFileSync as readFileSync33, promises as fs12 } from "fs";
-import path13 from "path";
+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 ?? {});
@@ -79432,8 +79933,8 @@ async function checkTeamMode() {
   const baseDir = resolveBaseDir(teamModeConfig);
   const [baseDirExists, teamCount, runtimeCount] = await Promise.all([
     pathExists(baseDir),
-    safeCount(path13.join(baseDir, "teams")),
-    safeCount(path13.join(baseDir, "runtime"))
+    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 {
@@ -79445,13 +79946,13 @@ async function checkTeamMode() {
   };
 }
 function loadTeamModeConfig() {
-  const projectConfig = detectPluginConfigFile(path13.join(process.cwd(), ".opencode"));
+  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(readFileSync33(configPath, "utf-8"));
+    return parseJsonc(readFileSync35(configPath, "utf-8"));
   } catch {
     return { team_mode: undefined };
   }
@@ -79854,11 +80355,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync as chmodSync2, existsSync as existsSync40, mkdirSync as mkdirSync12, readFileSync as readFileSync34, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname16, join as join42 } 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 join42(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join43(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost(serverHost) {
   let host = serverHost.trim();
@@ -79895,11 +80396,11 @@ function buildKey(serverHost, resource) {
 }
 function readStore() {
   const filePath = getMcpOauthStoragePath();
-  if (!existsSync40(filePath)) {
+  if (!existsSync42(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync34(filePath, "utf-8");
+    const content = readFileSync36(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -79908,8 +80409,8 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname16(filePath);
-    if (!existsSync40(dir)) {
+    const dir = dirname17(filePath);
+    if (!existsSync42(dir)) {
       mkdirSync12(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
@@ -79946,7 +80447,7 @@ function deleteToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getMcpOauthStoragePath();
-      if (existsSync40(filePath)) {
+      if (existsSync42(filePath)) {
         unlinkSync6(filePath);
       }
       return true;
@@ -80115,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)
@@ -80126,7 +80627,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -80141,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");
 }
@@ -80168,7 +80669,7 @@ var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
   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");
@@ -80525,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;
@@ -80651,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();