oh-my-opencode 4.8.0 → 4.8.1

package/dist/cli/index.js

@@ -62121,7 +62121,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.8.0",
+  version: "4.8.1",
   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",
@@ -62258,17 +62258,17 @@ var package_default = {
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.8.0",
-    "oh-my-opencode-darwin-x64": "4.8.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.8.0",
-    "oh-my-opencode-linux-arm64": "4.8.0",
-    "oh-my-opencode-linux-arm64-musl": "4.8.0",
-    "oh-my-opencode-linux-x64": "4.8.0",
-    "oh-my-opencode-linux-x64-baseline": "4.8.0",
-    "oh-my-opencode-linux-x64-musl": "4.8.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.8.0",
-    "oh-my-opencode-windows-x64": "4.8.0",
-    "oh-my-opencode-windows-x64-baseline": "4.8.0"
+    "oh-my-opencode-darwin-arm64": "4.8.1",
+    "oh-my-opencode-darwin-x64": "4.8.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.8.1",
+    "oh-my-opencode-linux-arm64": "4.8.1",
+    "oh-my-opencode-linux-arm64-musl": "4.8.1",
+    "oh-my-opencode-linux-x64": "4.8.1",
+    "oh-my-opencode-linux-x64-baseline": "4.8.1",
+    "oh-my-opencode-linux-x64-musl": "4.8.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.8.1",
+    "oh-my-opencode-windows-x64": "4.8.1",
+    "oh-my-opencode-windows-x64-baseline": "4.8.1"
   },
   overrides: {
     hono: "^4.12.18",
@@ -63921,19 +63921,10 @@ function ensureCodexMultiAgentV2Config(config) {
   const maxThreadsValue = CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION.toString();
   if (!section) {
     return appendBlock(normalizedConfig, `[${CODEX_MULTI_AGENT_V2_HEADER}]
-enabled = true
-max_concurrent_threads_per_session = ${maxThreadsValue}
-`);
-  }
-  const enabledConfig = replaceOrInsertSetting(normalizedConfig, section, "enabled", "true");
-  const updatedSection = findTomlSection(enabledConfig, CODEX_MULTI_AGENT_V2_HEADER);
-  if (!updatedSection) {
-    return appendBlock(enabledConfig, `[${CODEX_MULTI_AGENT_V2_HEADER}]
-enabled = true
 max_concurrent_threads_per_session = ${maxThreadsValue}
 `);
   }
-  return replaceOrInsertSetting(enabledConfig, updatedSection, "max_concurrent_threads_per_session", maxThreadsValue);
+  return replaceOrInsertSetting(normalizedConfig, section, "max_concurrent_threads_per_session", maxThreadsValue);
 }
 function removeFeatureFlagSetting(config, featureName) {
   const section = findTomlSection(config, "features");
@@ -86728,6 +86719,42 @@ function createCliPostHog2() {
 
 // src/cli/run/runner.ts
 init_prompt_async_gate();
+
+// src/cli/run/runnable-agent-resolver.ts
+init_shared();
+init_agent_display_names();
+async function resolveRunnableRunAgent(client3, resolvedAgent, config2 = {}) {
+  try {
+    const agentsRes = await client3.app.agents();
+    const agents = normalizeSDKResponse(agentsRes, [], {
+      preferResponseOnMissingData: true
+    });
+    const exactAgent = agents.find((agent) => agent.name === resolvedAgent)?.name;
+    if (exactAgent)
+      return exactAgent;
+    const resolvedConfigKey = getAgentConfigKey(resolvedAgent);
+    const configuredDisplayName = config2.agents?.[resolvedConfigKey]?.displayName;
+    const configuredAgent = agents.find((agent) => {
+      if (!agent.name || !configuredDisplayName)
+        return false;
+      return agent.name === configuredDisplayName;
+    })?.name;
+    if (configuredAgent)
+      return configuredAgent;
+    return agents.find((agent) => {
+      if (!agent.name)
+        return false;
+      return getAgentConfigKey(agent.name) === resolvedConfigKey;
+    })?.name ?? resolvedAgent;
+  } catch (error51) {
+    if (!(error51 instanceof Error)) {
+      throw error51;
+    }
+    return resolvedAgent;
+  }
+}
+
+// src/cli/run/runner.ts
 var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
@@ -86783,6 +86810,7 @@ Interrupted. Shutting down...`));
         sessionId: options.sessionId,
         directory
       });
+      const runnableAgent = await resolveRunnableRunAgent(client3, resolvedAgent, pluginConfig);
       console.log(import_picocolors16.default.dim(`Session: ${sessionID}`));
       if (resolvedModel) {
         console.log(import_picocolors16.default.dim(`Model: ${resolvedModel.providerID}/${resolvedModel.modelID}`));
@@ -86808,7 +86836,7 @@ Interrupted. Shutting down...`));
         input: {
           path: { id: sessionID },
           body: {
-            agent: resolvedAgent,
+            agent: runnableAgent,
             ...resolvedModel ? { model: resolvedModel } : {},
             tools: {
               question: false

package/dist/cli/install-codex/codex-multi-agent-v2-config.d.ts

@@ -1 +1,12 @@
+/**
+ * Configure multi_agent_v2 thread limits without forcing the feature on.
+ *
+ * Whether V2 is active is determined at runtime by the model's server-side
+ * catalog entry (`ModelInfo.multi_agent_version`).  Forcing `enabled = true`
+ * in config breaks models whose API does not support encrypted tool
+ * parameters (e.g. gpt-5.5-medium, API-key-only models, third-party
+ * providers).  The installer therefore only sets the tuning knob
+ * (`max_concurrent_threads_per_session`) so that sessions that DO activate
+ * V2 benefit from the higher limit.
+ */
 export declare function ensureCodexMultiAgentV2Config(config: string): string;

package/dist/cli/run/runnable-agent-resolver.d.ts

@@ -0,0 +1,11 @@
+export interface RunAgentListClient {
+    readonly app: {
+        readonly agents: () => Promise<unknown>;
+    };
+}
+export interface RunAgentDisplayNameConfig {
+    readonly agents?: Readonly<Record<string, {
+        readonly displayName?: string;
+    } | undefined>>;
+}
+export declare function resolveRunnableRunAgent(client: RunAgentListClient, resolvedAgent: string, config?: RunAgentDisplayNameConfig): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "4.8.0",
+  "version": "4.8.1",
   "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",
@@ -137,17 +137,17 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "4.8.0",
-    "oh-my-opencode-darwin-x64": "4.8.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.8.0",
-    "oh-my-opencode-linux-arm64": "4.8.0",
-    "oh-my-opencode-linux-arm64-musl": "4.8.0",
-    "oh-my-opencode-linux-x64": "4.8.0",
-    "oh-my-opencode-linux-x64-baseline": "4.8.0",
-    "oh-my-opencode-linux-x64-musl": "4.8.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.8.0",
-    "oh-my-opencode-windows-x64": "4.8.0",
-    "oh-my-opencode-windows-x64-baseline": "4.8.0"
+    "oh-my-opencode-darwin-arm64": "4.8.1",
+    "oh-my-opencode-darwin-x64": "4.8.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.8.1",
+    "oh-my-opencode-linux-arm64": "4.8.1",
+    "oh-my-opencode-linux-arm64-musl": "4.8.1",
+    "oh-my-opencode-linux-x64": "4.8.1",
+    "oh-my-opencode-linux-x64-baseline": "4.8.1",
+    "oh-my-opencode-linux-x64-musl": "4.8.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.8.1",
+    "oh-my-opencode-windows-x64": "4.8.1",
+    "oh-my-opencode-windows-x64-baseline": "4.8.1"
   },
   "overrides": {
     "hono": "^4.12.18",

package/packages/omo-codex/plugin/components/rules/src/rules/formatter.ts

@@ -1,4 +1,4 @@
-import { truncateBudget, truncateRule } from "./truncator.js";
+import { isNeverTruncatedRule, truncateBudget, truncateRule } from "./truncator.js";
 import type { LoadedRule } from "./types.js";
 
 export interface FormatOptions {
@@ -35,13 +35,12 @@ function truncateRules(rules: ReadonlyArray<LoadedRule>, options: FormatOptions)
 	const perRuleBudgeted = perRuleNormalized.map((rule) => ({
 		path: rule.path,
 		relativePath: rule.relativePath,
-		body:
-			rule.source === "plugin-bundled"
-				? truncateRule(rule.body, { maxChars: perRuleResultChars, relativePath: rule.relativePath }).body
-				: truncateRule(rule.body, {
-						maxChars: Math.min(options.maxRuleChars, perRuleResultChars),
-						relativePath: rule.relativePath,
-					}).body,
+		body: isNeverTruncatedRule(rule.relativePath)
+			? rule.body
+			: truncateRule(rule.body, {
+					maxChars: Math.min(options.maxRuleChars, perRuleResultChars),
+					relativePath: rule.relativePath,
+				}).body,
 	}));
 	const budgetedRules = truncateBudget({
 		rules: perRuleBudgeted.map((rule) => ({ body: rule.body, relativePath: rule.relativePath })),

package/packages/omo-codex/plugin/components/rules/src/rules/truncator.ts

@@ -14,6 +14,13 @@ function truncationNotice(relativePath: string): string {
 	return TRUNCATION_NOTICE.replace("{path}", relativePath);
 }
 
+export function isNeverTruncatedRule(relativePath: string): boolean {
+	const normalized = relativePath.replace(/\\/g, "/");
+	const segments = normalized.split("/").filter((segment) => segment.length > 0);
+	const filename = segments.at(-1) ?? normalized;
+	return filename.toLowerCase() === "hephaestus.md";
+}
+
 function safeSliceEnd(body: string, end: number): number {
 	if (end <= 0) {
 		return 0;
@@ -28,6 +35,10 @@ function safeSliceEnd(body: string, end: number): number {
 }
 
 export function truncateRule(body: string, options: { maxChars: number; relativePath: string }): TruncationResult {
+	if (isNeverTruncatedRule(options.relativePath)) {
+		return { body, truncated: false, originalLength: body.length };
+	}
+
 	if (body.length <= options.maxChars) {
 		return { body, truncated: false, originalLength: body.length };
 	}
@@ -46,6 +57,12 @@ export function truncateBudget(input: { rules: ReadonlyArray<BudgetRule>; maxRes
 	let remainingBudget = input.maxResultChars;
 
 	for (const rule of input.rules) {
+		if (isNeverTruncatedRule(rule.relativePath)) {
+			results.push({ body: rule.body, truncated: false, relativePath: rule.relativePath });
+			remainingBudget -= rule.body.length;
+			continue;
+		}
+
 		if (remainingBudget >= rule.body.length) {
 			results.push({ body: rule.body, truncated: false, relativePath: rule.relativePath });
 			remainingBudget -= rule.body.length;

package/packages/omo-codex/plugin/components/rules/test/formatter.test.ts

@@ -145,6 +145,26 @@ describe("rules formatter hook context", () => {
 		expect(block).not.toContain("must read project rules:");
 	});
 
+	it("#given an oversized Hephaestus static rule #when formatting under a tight result budget #then its body is never truncated", () => {
+		// given
+		const tailMarker = "HEPHAESTUS_TAIL_SENTINEL";
+		const rule = loadedRule({
+			path: "/repo/bundled-rules/hephaestus.md",
+			relativePath: "bundled-rules/hephaestus.md",
+			body: `${"H".repeat(500)}\n\n${tailMarker}`,
+		});
+
+		// when
+		const block = formatStaticBlock([rule], {
+			maxRuleChars: 120,
+			maxResultChars: 200,
+		});
+
+		// then
+		expect(block).toContain(tailMarker);
+		expect(block).not.toContain("[Truncated. Full:");
+	});
+
 	it("#given multiple oversized rules #when formatting under a tight result budget #then every rule receives a fair truncated share with a read-full guide", () => {
 		// given
 		const rules = [

package/packages/omo-codex/plugin/scripts/migrate-codex-config/multi-agent-v2-guard.mjs

@@ -0,0 +1,40 @@
+/**
+ * Runtime migration: undo the installer-forced `enabled = true` on
+ * `[features.multi_agent_v2]`.
+ *
+ * Whether V2 is active should be determined at runtime by the model's
+ * server-side catalog entry (`ModelInfo.multi_agent_version`).  Previous
+ * installer versions unconditionally set `enabled = true`, which forces
+ * V2 for ALL models --- including those whose API does not support
+ * encrypted tool parameters (spawn_agent).  This guard removes the
+ * forced flag so the Codex runtime can make the right decision per model.
+ */
+export function disableMultiAgentV2IfForced(config) {
+	const section = findMultiAgentV2Section(config);
+	if (!section) return config;
+
+	const enabledPattern = /^(\s*)enabled\s*=\s*true\s*$/m;
+	if (!enabledPattern.test(section.text)) return config;
+
+	const patched = section.text.replace(enabledPattern, "$1enabled = false");
+	return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+
+function findMultiAgentV2Section(config) {
+	const headerLine = "[features.multi_agent_v2]";
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const trimmed = line.trim();
+		if (start === -1) {
+			if (trimmed === headerLine) start = offset;
+		} else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+			return { start, end: offset, text: config.slice(start, offset) };
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config.mjs

@@ -6,6 +6,7 @@ import { pathToFileURL } from "node:url";
 
 import { FALLBACK_CATALOG, readModelCatalog } from "./migrate-codex-config/catalog.mjs";
 import { configPaths } from "./migrate-codex-config/config-paths.mjs";
+import { disableMultiAgentV2IfForced } from "./migrate-codex-config/multi-agent-v2-guard.mjs";
 import { ensureCodexReasoningConfig as applyReasoningProfile, readRootSettings } from "./migrate-codex-config/root-settings.mjs";
 import { readState, resolveStatePath, writeState } from "./migrate-codex-config/state.mjs";
 
@@ -41,12 +42,28 @@ export async function migrateCodexConfig({ env = process.env, cwd = process.cwd(
 export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG, previousState } = {}) {
 	const before = await readConfig(configPath);
 	const decision = shouldApplyCatalog(before, catalog, previousState);
-	if (!decision.apply) return { changed: false, written: readRootSettings(before), managed: decision.managed };
-	const after = ensureCodexReasoningConfig(before, catalog.current);
-	if (after === before) return { changed: false, written: catalog.current, managed: true };
-	await mkdir(dirname(configPath), { recursive: true });
-	await writeFile(configPath, `${after.trimEnd()}\n`);
-	return { changed: true, written: catalog.current, managed: true };
+
+	let config = before;
+	let reasoningApplied = false;
+
+	if (decision.apply) {
+		config = ensureCodexReasoningConfig(config, catalog.current);
+		reasoningApplied = config !== before;
+	}
+
+	const afterMultiAgentGuard = disableMultiAgentV2IfForced(config);
+	const multiAgentChanged = afterMultiAgentGuard !== config;
+	if (multiAgentChanged) config = afterMultiAgentGuard;
+
+	const changed = reasoningApplied || multiAgentChanged;
+	if (changed) {
+		await mkdir(dirname(configPath), { recursive: true });
+		await writeFile(configPath, `${config.trimEnd()}\n`);
+	}
+
+	const written = decision.apply ? catalog.current : readRootSettings(config);
+	const managed = decision.apply ? true : decision.managed;
+	return { changed, written, managed };
 }
 
 function shouldApplyCatalog(config, catalog, previousState) {

package/packages/omo-codex/plugin/test/migrate-codex-config.test.mjs

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
 
+import { disableMultiAgentV2IfForced } from "../scripts/migrate-codex-config/multi-agent-v2-guard.mjs";
 import { ensureCodexReasoningConfig, migrateCodexConfig } from "../scripts/migrate-codex-config.mjs";
 
 test("#given stale root reasoning config #when ensuring config #then replaces stale values without duplicate keys", () => {
@@ -361,6 +362,84 @@ test("#given config already matches current catalog #when catalog version advanc
 	assert.equal(state.files[configPath].catalogVersion, "test.role-only");
 });
 
+test("#given installer-forced multi_agent_v2 enabled #when migrating config #then disables it so runtime decides per model", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features.multi_agent_v2]",
+		"enabled = true",
+		"max_concurrent_threads_per_session = 10000",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.match(result, /enabled = false/);
+	assert.doesNotMatch(result, /enabled = true/);
+	assert.match(result, /max_concurrent_threads_per_session = 10000/);
+});
+
+test("#given no multi_agent_v2 section #when migrating config #then returns config unchanged", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features]",
+		"plugins = true",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.equal(result, config);
+});
+
+test("#given multi_agent_v2 already disabled #when migrating config #then returns config unchanged", () => {
+	const config = [
+		'model = "gpt-5.5"',
+		'model_reasoning_effort = "high"',
+		"",
+		"[features.multi_agent_v2]",
+		"enabled = false",
+		"max_concurrent_threads_per_session = 10000",
+		"",
+	].join("\n");
+
+	const result = disableMultiAgentV2IfForced(config);
+
+	assert.equal(result, config);
+});
+
+test("#given global config with forced multi_agent_v2 #when full migration runs #then disables it on disk", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-multi-agent-v2-guard-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	const configPath = join(codexHome, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.5"',
+			'model_reasoning_effort = "high"',
+			"",
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"max_concurrent_threads_per_session = 10000",
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	assert.deepEqual(result.changed, [configPath]);
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /enabled = false/);
+	assert.doesNotMatch(content, /enabled = true/);
+});
+
 async function canCreateSymlink(type) {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-symlink-capability-"));
 	const target = join(root, "target");

package/packages/omo-codex/scripts/install/config.mjs

@@ -253,3 +253,5 @@ function parseJsonString(value) {
 		return null;
 	}
 }
+
+

package/packages/omo-codex/scripts/install/multi-agent-v2-config.mjs

@@ -3,6 +3,16 @@ import { appendBlock, findTomlSection, removeSetting, replaceOrInsertSetting } f
 const CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
 const CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION = 10000;
 
+/**
+ * Configure multi_agent_v2 thread limits without forcing the feature on.
+ *
+ * Whether V2 is active is determined at runtime by the model's server-side
+ * catalog entry (ModelInfo.multi_agent_version).  Forcing enabled = true
+ * in config breaks models whose API does not support encrypted tool
+ * parameters.  The installer therefore only sets the tuning knob
+ * (max_concurrent_threads_per_session) so that sessions that DO activate
+ * V2 benefit from the higher limit.
+ */
 export function ensureCodexMultiAgentV2Config(config) {
 	const normalizedConfig = removeLegacyAgentsMaxThreadsSetting(removeFeatureFlagSetting(config, "multi_agent_v2"));
 	const section = findTomlSection(normalizedConfig, CODEX_MULTI_AGENT_V2_HEADER);
@@ -10,19 +20,11 @@ export function ensureCodexMultiAgentV2Config(config) {
 	if (!section) {
 		return appendBlock(
 			normalizedConfig,
-			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nenabled = true\nmax_concurrent_threads_per_session = ${maxThreadsValue}\n`,
+			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nmax_concurrent_threads_per_session = ${maxThreadsValue}\n`,
 		);
 	}
 
-	const enabledConfig = replaceOrInsertSetting(normalizedConfig, section, "enabled", "true");
-	const updatedSection = findTomlSection(enabledConfig, CODEX_MULTI_AGENT_V2_HEADER);
-	if (!updatedSection) {
-		return appendBlock(
-			enabledConfig,
-			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nenabled = true\nmax_concurrent_threads_per_session = ${maxThreadsValue}\n`,
-		);
-	}
-	return replaceOrInsertSetting(enabledConfig, updatedSection, "max_concurrent_threads_per_session", maxThreadsValue);
+	return replaceOrInsertSetting(normalizedConfig, section, "max_concurrent_threads_per_session", maxThreadsValue);
 }
 
 function removeFeatureFlagSetting(config, featureName) {