oh-my-opencode 3.8.4 → 3.9.0

package/README.ja.md

@@ -217,9 +217,9 @@ MCPサーバーがあなたのコンテキスト予算を食いつぶしてい
 [oh-my-pi](https://github.com/can1357/oh-my-pi) に触発され、**Hashline**を実装しました。エージェントが読むすべての行にコンテンツハッシュがタグ付けされて返されます：
 
 ```
-11#VK: function hello() {
-22#XJ:   return "world";
-33#MB: }
+11#VK| function hello() {
+22#XJ|   return "world";
+33#MB| }
 ```
 
 エージェントはこのタグを参照して編集します。最後に読んだ後でファイルが変更されていた場合、ハッシュが一致せず、コードが壊れる前に編集が拒否されます。空白を正確に再現する必要もなく、間違った行を編集するエラー (stale-line) もありません。

package/README.ko.md

@@ -216,9 +216,9 @@ MCP 서버들이 당신의 컨텍스트 예산을 다 잡아먹죠. 우리가
 [oh-my-pi](https://github.com/can1357/oh-my-pi)에서 영감을 받아, **Hashline**을 구현했습니다. 에이전트가 읽는 모든 줄에는 콘텐츠 해시 태그가 붙어 나옵니다:
 
 ```
-11#VK: function hello() {
-22#XJ:   return "world";
-33#MB: }
+11#VK| function hello() {
+22#XJ|   return "world";
+33#MB| }
 ```
 
 에이전트는 이 태그를 참조해서 편집합니다. 마지막으로 읽은 후 파일이 변경되었다면 해시가 일치하지 않아 코드가 망가지기 전에 편집이 거부됩니다. 공백을 똑같이 재현할 필요도 없고, 엉뚱한 줄을 수정하는 에러(stale-line)도 없습니다.

package/README.md

@@ -220,9 +220,9 @@ The harness problem is real. Most agent failures aren't the model. It's the edit
 Inspired by [oh-my-pi](https://github.com/can1357/oh-my-pi), we implemented **Hashline**. Every line the agent reads comes back tagged with a content hash:
 
 ```
-11#VK: function hello() {
-22#XJ:   return "world";
-33#MB: }
+11#VK| function hello() {
+22#XJ|   return "world";
+33#MB| }
 ```
 
 The agent edits by referencing those tags. If the file changed since the last read, the hash won't match and the edit is rejected before corruption. No whitespace reproduction. No stale-line errors.

package/README.zh-cn.md

@@ -218,9 +218,9 @@ Harness 问题是真的。绝大多数所谓的 Agent 故障，其实并不是
 受 [oh-my-pi](https://github.com/can1357/oh-my-pi) 的启发，我们实现了 **Hashline** 技术。Agent 读到的每一行代码，末尾都会打上一个强绑定的内容哈希值：
 
 ```
-11#VK: function hello() {
-22#XJ:   return "world";
-33#MB: }
+11#VK| function hello() {
+22#XJ|   return "world";
+33#MB| }
 ```
 
 Agent 发起修改时，必须通过这些标签引用目标行。如果在此期间文件发生过变化，哈希验证就会失败，从而在代码被污染前直接驳回。不再有缩进空格错乱，彻底告别改错行的惨剧。

package/bin/oh-my-opencode.js

@@ -3,8 +3,9 @@
 // Wrapper script that detects platform and spawns the correct binary
 
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { getPlatformPackage, getBinaryPath } from "./platform.js";
+import { getPlatformPackageCandidates, getBinaryPath } from "./platform.js";
 
 const require = createRequire(import.meta.url);
 
@@ -26,55 +27,116 @@ function getLibcFamily() {
   }
 }
 
+function supportsAvx2() {
+  if (process.arch !== "x64") {
+    return null;
+  }
+
+  if (process.env.OH_MY_OPENCODE_FORCE_BASELINE === "1") {
+    return false;
+  }
+
+  if (process.platform === "linux") {
+    try {
+      const cpuInfo = readFileSync("/proc/cpuinfo", "utf8").toLowerCase();
+      return cpuInfo.includes("avx2");
+    } catch {
+      return null;
+    }
+  }
+
+  if (process.platform === "darwin") {
+    const probe = spawnSync("sysctl", ["-n", "machdep.cpu.leaf7_features"], {
+      encoding: "utf8",
+    });
+
+    if (probe.error || probe.status !== 0) {
+      return null;
+    }
+
+    return probe.stdout.toUpperCase().includes("AVX2");
+  }
+
+  return null;
+}
+
+function getSignalExitCode(signal) {
+  const signalCodeByName = {
+    SIGINT: 2,
+    SIGILL: 4,
+    SIGKILL: 9,
+    SIGTERM: 15,
+  };
+
+  return 128 + (signalCodeByName[signal] ?? 1);
+}
+
 function main() {
   const { platform, arch } = process;
   const libcFamily = getLibcFamily();
+  const avx2Supported = supportsAvx2();
   
-  // Get platform package name
-  let pkg;
+  let packageCandidates;
   try {
-    pkg = getPlatformPackage({ platform, arch, libcFamily });
+    packageCandidates = getPlatformPackageCandidates({
+      platform,
+      arch,
+      libcFamily,
+      preferBaseline: avx2Supported === false,
+    });
   } catch (error) {
     console.error(`\noh-my-opencode: ${error.message}\n`);
     process.exit(1);
   }
-  
-  // Resolve binary path
-  const binRelPath = getBinaryPath(pkg, platform);
-  
-  let binPath;
-  try {
-    binPath = require.resolve(binRelPath);
-  } catch {
+
+  const resolvedBinaries = packageCandidates
+    .map((pkg) => {
+      try {
+        return { pkg, binPath: require.resolve(getBinaryPath(pkg, platform)) };
+      } catch {
+        return null;
+      }
+    })
+    .filter((entry) => entry !== null);
+
+  if (resolvedBinaries.length === 0) {
     console.error(`\noh-my-opencode: Platform binary not installed.`);
     console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
-    console.error(`Expected package: ${pkg}`);
+    console.error(`Expected packages (in order): ${packageCandidates.join(", ")}`);
     console.error(`\nTo fix, run:`);
-    console.error(`  npm install ${pkg}\n`);
+    console.error(`  npm install ${packageCandidates[0]}\n`);
     process.exit(1);
   }
-  
-  // Spawn the binary
-  const result = spawnSync(binPath, process.argv.slice(2), {
-    stdio: "inherit",
-  });
-  
-  // Handle spawn errors
-  if (result.error) {
-    console.error(`\noh-my-opencode: Failed to execute binary.`);
-    console.error(`Error: ${result.error.message}\n`);
-    process.exit(2);
-  }
-  
-  // Handle signals
-  if (result.signal) {
-    const signalNum = result.signal === "SIGTERM" ? 15 : 
-                      result.signal === "SIGKILL" ? 9 :
-                      result.signal === "SIGINT" ? 2 : 1;
-    process.exit(128 + signalNum);
+
+  for (let index = 0; index < resolvedBinaries.length; index += 1) {
+    const currentBinary = resolvedBinaries[index];
+    const hasFallback = index < resolvedBinaries.length - 1;
+    const result = spawnSync(currentBinary.binPath, process.argv.slice(2), {
+      stdio: "inherit",
+    });
+
+    if (result.error) {
+      if (hasFallback) {
+        continue;
+      }
+
+      console.error(`\noh-my-opencode: Failed to execute binary.`);
+      console.error(`Error: ${result.error.message}\n`);
+      process.exit(2);
+    }
+
+    if (result.signal === "SIGILL" && hasFallback) {
+      continue;
+    }
+
+    if (result.signal) {
+      process.exit(getSignalExitCode(result.signal));
+    }
+
+    process.exit(result.status ?? 1);
   }
 
-  process.exit(result.status ?? 1);
+  process.exit(1);
 }
 
 main();

package/bin/platform.d.ts

@@ -0,0 +1,14 @@
+export declare function getPlatformPackage(options: {
+  platform: string;
+  arch: string;
+  libcFamily?: string | null;
+}): string;
+
+export declare function getPlatformPackageCandidates(options: {
+  platform: string;
+  arch: string;
+  libcFamily?: string | null;
+  preferBaseline?: boolean;
+}): string[];
+
+export declare function getBinaryPath(pkg: string, platform: string): string;

package/bin/platform.js

@@ -26,6 +26,50 @@ export function getPlatformPackage({ platform, arch, libcFamily }) {
   return `oh-my-opencode-${os}-${arch}${suffix}`;
 }
 
+/** @param {{ platform: string, arch: string, libcFamily?: string | null, preferBaseline?: boolean }} options */
+export function getPlatformPackageCandidates({ platform, arch, libcFamily, preferBaseline = false }) {
+  const primaryPackage = getPlatformPackage({ platform, arch, libcFamily });
+  const baselinePackage = getBaselinePlatformPackage({ platform, arch, libcFamily });
+
+  if (!baselinePackage) {
+    return [primaryPackage];
+  }
+
+  return preferBaseline ? [baselinePackage, primaryPackage] : [primaryPackage, baselinePackage];
+}
+
+/** @param {{ platform: string, arch: string, libcFamily?: string | null }} options */
+function getBaselinePlatformPackage({ platform, arch, libcFamily }) {
+  if (arch !== "x64") {
+    return null;
+  }
+
+  if (platform === "darwin") {
+    return "oh-my-opencode-darwin-x64-baseline";
+  }
+
+  if (platform === "win32") {
+    return "oh-my-opencode-windows-x64-baseline";
+  }
+
+  if (platform === "linux") {
+    if (libcFamily === null || libcFamily === undefined) {
+      throw new Error(
+        "Could not detect libc on Linux. " +
+        "Please ensure detect-libc is installed or report this issue."
+      );
+    }
+
+    if (libcFamily === "musl") {
+      return "oh-my-opencode-linux-x64-musl-baseline";
+    }
+
+    return "oh-my-opencode-linux-x64-baseline";
+  }
+
+  return null;
+}
+
 /**
  * Get the path to the binary within a platform package
  * @param {string} pkg Package name

package/bin/platform.test.ts

@@ -1,6 +1,6 @@
 // bin/platform.test.ts
 import { describe, expect, test } from "bun:test";
-import { getPlatformPackage, getBinaryPath } from "./platform.js";
+import { getBinaryPath, getPlatformPackage, getPlatformPackageCandidates } from "./platform.js";
 
 describe("getPlatformPackage", () => {
   // #region Darwin platforms
@@ -146,3 +146,58 @@ describe("getBinaryPath", () => {
     expect(result).toBe("oh-my-opencode-linux-x64/bin/oh-my-opencode");
   });
 });
+
+describe("getPlatformPackageCandidates", () => {
+  test("returns x64 and baseline candidates for Linux glibc", () => {
+    // #given Linux x64 with glibc
+    const input = { platform: "linux", arch: "x64", libcFamily: "glibc" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then returns modern first then baseline fallback
+    expect(result).toEqual([
+      "oh-my-opencode-linux-x64",
+      "oh-my-opencode-linux-x64-baseline",
+    ]);
+  });
+
+  test("returns x64 musl and baseline candidates for Linux musl", () => {
+    // #given Linux x64 with musl
+    const input = { platform: "linux", arch: "x64", libcFamily: "musl" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then returns musl modern first then musl baseline fallback
+    expect(result).toEqual([
+      "oh-my-opencode-linux-x64-musl",
+      "oh-my-opencode-linux-x64-musl-baseline",
+    ]);
+  });
+
+  test("returns baseline first when preferBaseline is true", () => {
+    // #given Windows x64 and baseline preference
+    const input = { platform: "win32", arch: "x64", preferBaseline: true };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then baseline package is preferred first
+    expect(result).toEqual([
+      "oh-my-opencode-windows-x64-baseline",
+      "oh-my-opencode-windows-x64",
+    ]);
+  });
+
+  test("returns only one candidate for ARM64", () => {
+    // #given non-x64 platform
+    const input = { platform: "linux", arch: "arm64", libcFamily: "glibc" };
+
+    // #when getting package candidates
+    const result = getPlatformPackageCandidates(input);
+
+    // #then baseline fallback is not included
+    expect(result).toEqual(["oh-my-opencode-linux-arm64"]);
+  });
+});

package/dist/agents/atlas/agent.d.ts

@@ -30,6 +30,6 @@ export interface OrchestratorContext {
 export declare function getAtlasPrompt(model?: string): string;
 export declare function createAtlasAgent(ctx: OrchestratorContext): AgentConfig;
 export declare namespace createAtlasAgent {
-    var mode: "primary";
+    var mode: "all";
 }
 export declare const atlasPromptMetadata: AgentPromptMetadata;

package/dist/agents/env-context.d.ts

@@ -1,5 +1,5 @@
 /**
- * Creates OmO-specific environment context (time, timezone, locale).
+ * Creates OmO-specific environment context (timezone, locale).
  * Note: Working directory, platform, and date are already provided by OpenCode's system.ts,
  * so we only include fields that OpenCode doesn't provide to avoid duplication.
  * See: https://github.com/code-yeongyu/oh-my-opencode/issues/379

package/dist/agents/hephaestus.d.ts

@@ -2,5 +2,5 @@ import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AvailableAgent, AvailableSkill, AvailableCategory } from "./dynamic-agent-prompt-builder";
 export declare function createHephaestusAgent(model: string, availableAgents?: AvailableAgent[], availableToolNames?: string[], availableSkills?: AvailableSkill[], availableCategories?: AvailableCategory[], useTaskSystem?: boolean): AgentConfig;
 export declare namespace createHephaestusAgent {
-    var mode: "primary";
+    var mode: "all";
 }

package/dist/agents/sisyphus.d.ts

@@ -4,5 +4,5 @@ export declare const SISYPHUS_PROMPT_METADATA: AgentPromptMetadata;
 import type { AvailableAgent, AvailableSkill, AvailableCategory } from "./dynamic-agent-prompt-builder";
 export declare function createSisyphusAgent(model: string, availableAgents?: AvailableAgent[], availableToolNames?: string[], availableSkills?: AvailableSkill[], availableCategories?: AvailableCategory[], useTaskSystem?: boolean): AgentConfig;
 export declare namespace createSisyphusAgent {
-    var mode: "primary";
+    var mode: "all";
 }

package/dist/cli/config-manager/antigravity-provider-configuration.d.ts

@@ -4,10 +4,10 @@
  * IMPORTANT: Model names MUST use `antigravity-` prefix for stability.
  *
  * Since opencode-antigravity-auth v1.3.0, models use a variant system:
- * - `antigravity-gemini-3-pro` with variants: low, high
+ * - `antigravity-gemini-3.1-pro` with variants: low, high
  * - `antigravity-gemini-3-flash` with variants: minimal, low, medium, high
  *
- * Legacy tier-suffixed names (e.g., `antigravity-gemini-3-pro-high`) still work
+ * Legacy tier-suffixed names (e.g., `antigravity-gemini-3.1-pro-high`) still work
  * but variants are the recommended approach.
  *
  * @see https://github.com/NoeFabris/opencode-antigravity-auth#models
@@ -16,7 +16,7 @@ export declare const ANTIGRAVITY_PROVIDER_CONFIG: {
     google: {
         name: string;
         models: {
-            "antigravity-gemini-3-pro": {
+            "antigravity-gemini-3.1-pro": {
                 name: string;
                 limit: {
                     context: number;