oh-my-opencode 4.18.1 → 4.18.2

package/dist/plugin/messages-transform.d.ts

@@ -13,6 +13,7 @@ type MessagesTransformHooks = {
     teamMailboxInjector?: CreatedHooks["teamMailboxInjector"];
     toolPairValidator?: CreatedHooks["toolPairValidator"];
     monitorStatusInjector?: CreatedHooks["monitorStatusInjector"];
+    categorySkillReminder?: CreatedHooks["categorySkillReminder"];
 };
 export declare function createMessagesTransformHandler(args: {
     hooks: MessagesTransformHooks;

package/dist/plugin-handlers/prometheus-agent-config-builder.d.ts

@@ -1,4 +1,5 @@
 import type { CategoryConfig } from "../config/schema";
+import type { FallbackModels } from "../config/schema/fallback-models";
 type PrometheusOverride = Record<string, unknown> & {
     category?: string;
     model?: string;
@@ -12,6 +13,7 @@ type PrometheusOverride = Record<string, unknown> & {
     temperature?: number;
     top_p?: number;
     maxTokens?: number;
+    fallback_models?: FallbackModels;
     prompt?: string;
     prompt_append?: string;
 };

package/dist/tui.js

@@ -20695,7 +20695,7 @@ var init_agent_model_requirements = __esm(() => {
     hephaestus: {
       fallbackChain: [
         {
-          providers: ["openai", "vercel"],
+          providers: ["openai", "github-copilot", "vercel"],
           model: "gpt-5.6-sol",
           variant: "high"
         },
@@ -20806,6 +20806,11 @@ var init_agent_model_requirements = __esm(() => {
           model: "gpt-5.6-sol",
           variant: "xhigh"
         },
+        {
+          providers: ["github-copilot"],
+          model: "gpt-5.6-sol",
+          variant: "high"
+        },
         {
           providers: ["openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.5",
@@ -20884,6 +20889,11 @@ var init_category_model_requirements = __esm(() => {
           model: "gpt-5.6-sol",
           variant: "xhigh"
         },
+        {
+          providers: ["github-copilot"],
+          model: "gpt-5.6-sol",
+          variant: "high"
+        },
         {
           providers: ["openai", "opencode", "vercel"],
           model: "gpt-5.5",
@@ -20910,7 +20920,12 @@ var init_category_model_requirements = __esm(() => {
           variant: "xhigh"
         },
         {
-          providers: ["openai", "vercel"],
+          providers: ["github-copilot"],
+          model: "gpt-5.6-terra",
+          variant: "high"
+        },
+        {
+          providers: ["openai", "github-copilot", "vercel"],
           model: "gpt-5.6-sol",
           variant: "high"
         },
@@ -20977,6 +20992,11 @@ var init_category_model_requirements = __esm(() => {
           model: "gpt-5.6-luna",
           variant: "xhigh"
         },
+        {
+          providers: ["github-copilot"],
+          model: "gpt-5.6-luna",
+          variant: "high"
+        },
         {
           providers: ["anthropic", "github-copilot", "opencode", "vercel"],
           model: "claude-sonnet-4-6"
@@ -21066,9 +21086,12 @@ function stripProviderPrefixForAliasLookup(normalizedModelID) {
   }
   return normalizedModelID.slice(slashIndex + 1);
 }
-function resolveModelIDAlias(modelID) {
+function resolveModelIDAlias(modelID, providerID) {
   const requestedModelID = normalizeLookupModelID(modelID);
   const aliasLookupModelID = stripProviderPrefixForAliasLookup(requestedModelID);
+  const normalizedProviderID = providerID ? normalizeLookupModelID(providerID) : undefined;
+  const providerPrefixEnd = requestedModelID.indexOf("/");
+  const embeddedProviderID = providerPrefixEnd > 0 ? requestedModelID.slice(0, providerPrefixEnd) : undefined;
   const exactRule = EXACT_ALIAS_RULES_BY_MODEL.get(aliasLookupModelID);
   if (exactRule) {
     return {
@@ -21079,6 +21102,13 @@ function resolveModelIDAlias(modelID) {
     };
   }
   for (const rule of PATTERN_ALIAS_RULES) {
+    if (rule.providerIDs) {
+      const matchesProviderID = normalizedProviderID !== undefined && rule.providerIDs.includes(normalizedProviderID);
+      const matchesEmbeddedProviderID = normalizedProviderID !== undefined && rule.allowedSubproviderHosts?.includes(normalizedProviderID) === true && embeddedProviderID !== undefined && rule.providerIDs.includes(embeddedProviderID);
+      if (!matchesProviderID && !matchesEmbeddedProviderID) {
+        continue;
+      }
+    }
     if (!rule.match(aliasLookupModelID)) {
       continue;
     }
@@ -21119,6 +21149,14 @@ var init_model_capability_aliases = __esm(() => {
   ];
   EXACT_ALIAS_RULES_BY_MODEL = new Map(EXACT_ALIAS_RULES.map((rule) => [rule.aliasModelID, rule]));
   PATTERN_ALIAS_RULES = [
+    {
+      ruleID: "openai-gpt-5.6-fast-service-tier-alias",
+      description: "Normalizes OpenCode's OpenAI GPT-5.6 fast service-tier IDs to canonical snapshot IDs.",
+      providerIDs: ["openai"],
+      allowedSubproviderHosts: ["vercel"],
+      match: (normalizedModelID) => /^gpt-5\.6-(?:sol|terra|luna)-fast$/.test(normalizedModelID),
+      canonicalize: (normalizedModelID) => normalizedModelID.slice(0, -"-fast".length)
+    },
     {
       ruleID: "claude-thinking-legacy-alias",
       description: "Normalizes the legacy claude-opus-4-7-thinking id to the canonical snapshot ID.",
@@ -21596,7 +21634,7 @@ function getProviderOverride(providerID, modelID) {
   return GITHUB_COPILOT_GPT5_MODEL.test(normalizeLookupModelID2(modelID)) ? GITHUB_COPILOT_GPT5_OVERRIDE : undefined;
 }
 function getModelCapabilities(input) {
-  const canonicalization = resolveModelIDAlias(input.modelID);
+  const canonicalization = resolveModelIDAlias(input.modelID, input.providerID);
   const override = getOverride(input.modelID);
   const providerOverride = getProviderOverride(input.providerID, canonicalization.canonicalModelID);
   const runtimeModel = readRuntimeModel(input.runtimeModel ?? input.providerCache?.findProviderModelMetadata(input.providerID, input.modelID));
@@ -22460,6 +22498,7 @@ var init_opencode_storage_detection = __esm(() => {
 var opencodePluginsCache;
 var init_load_opencode_plugins = __esm(() => {
   init_jsonc_parser2();
+  init_opencode_config_dir();
   opencodePluginsCache = new Map;
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "4.18.1",
+  "version": "4.18.2",
   "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",
@@ -212,18 +212,18 @@
     "typescript": "^6.0.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "4.18.1",
-    "oh-my-opencode-darwin-x64": "4.18.1",
-    "oh-my-opencode-darwin-x64-baseline": "4.18.1",
-    "oh-my-opencode-linux-arm64": "4.18.1",
-    "oh-my-opencode-linux-arm64-musl": "4.18.1",
-    "oh-my-opencode-linux-x64": "4.18.1",
-    "oh-my-opencode-linux-x64-baseline": "4.18.1",
-    "oh-my-opencode-linux-x64-musl": "4.18.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.18.1",
-    "oh-my-opencode-windows-arm64": "4.18.1",
-    "oh-my-opencode-windows-x64": "4.18.1",
-    "oh-my-opencode-windows-x64-baseline": "4.18.1"
+    "oh-my-opencode-darwin-arm64": "4.18.2",
+    "oh-my-opencode-darwin-x64": "4.18.2",
+    "oh-my-opencode-darwin-x64-baseline": "4.18.2",
+    "oh-my-opencode-linux-arm64": "4.18.2",
+    "oh-my-opencode-linux-arm64-musl": "4.18.2",
+    "oh-my-opencode-linux-x64": "4.18.2",
+    "oh-my-opencode-linux-x64-baseline": "4.18.2",
+    "oh-my-opencode-linux-x64-musl": "4.18.2",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.18.2",
+    "oh-my-opencode-windows-arm64": "4.18.2",
+    "oh-my-opencode-windows-x64": "4.18.2",
+    "oh-my-opencode-windows-x64-baseline": "4.18.2"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.80.3",

package/packages/git-bash-mcp/dist/cli.js

@@ -17,6 +17,9 @@ function errorResponse(id, code, message, data) {
 function jsonRpcId(value) {
   return typeof value === "string" || typeof value === "number" || value === null ? value : null;
 }
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 // ../mcp-stdio-core/src/transport.ts
 var HEADER_SEPARATOR = Buffer.from(`\r
 \r
@@ -39,16 +42,45 @@ async function* readStdioJsonRpcMessages(input) {
     yield parseJsonPayload(trailing, "line");
   }
 }
-function writeStdioJsonRpcResponse(output, response, responseMode) {
+async function writeStdioJsonRpcResponse(output, response, responseMode) {
   const body = JSON.stringify(response);
-  if (responseMode === "framed") {
-    output.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+  const payload = responseMode === "framed" ? `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
-${body}`);
-    return;
-  }
-  output.write(`${body}
-`);
+${body}` : `${body}
+`;
+  await writeChunk(output, payload);
+}
+function writeChunk(output, chunk) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onError = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    };
+    output.once("error", onError);
+    try {
+      output.write(chunk, (error) => {
+        if (settled)
+          return;
+        settled = true;
+        if (error) {
+          queueMicrotask(() => output.removeListener("error", onError));
+          reject(error);
+          return;
+        }
+        output.removeListener("error", onError);
+        resolve();
+      });
+    } catch (error) {
+      output.removeListener("error", onError);
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    }
+  });
 }
 function readNextMessage(buffer) {
   if (buffer.length === 0)
@@ -144,40 +176,70 @@ async function runJsonRpcStdioServer(config) {
         break;
       idleTimer.arm();
       if (message.kind === "parse_error") {
-        handleParseError(message, config, log);
+        if (!await handleParseError(message, config, log))
+          break;
         continue;
       }
-      await handleRequest(message, config, log);
+      if (!await handleRequest(message, config, log))
+        break;
     }
   } finally {
     idleTimer.clear();
     log("stdio_stopped");
   }
 }
-function handleParseError(message, config, log) {
+async function handleParseError(message, config, log) {
   log("parse_error", { message: message.message });
   const response = config.parseErrorResponse?.(message.message) ?? errorResponse(null, -32700, "Parse error", message.message);
-  if (response !== undefined) {
-    writeStdioJsonRpcResponse(config.output, response, message.responseMode);
-  }
+  if (response === undefined)
+    return true;
+  return writeResponse(response, {
+    output: config.output,
+    responseMode: message.responseMode,
+    log
+  });
 }
 async function handleRequest(message, config, log) {
   const parsed = message.payload;
   const id = isPlainRecord(parsed) ? jsonRpcId(parsed["id"]) : null;
   const method = isPlainRecord(parsed) && typeof parsed["method"] === "string" ? parsed["method"] : null;
   log("request", { id: id === null ? null : String(id), method });
+  let response;
   try {
-    const response = await config.handler(parsed, config.handlerOptions);
-    if (response === undefined)
-      return;
-    writeStdioJsonRpcResponse(config.output, response, message.responseMode);
-    log("response", { id: String(response.id), method, is_error: response.error !== undefined });
+    response = await config.handler(parsed, config.handlerOptions);
   } catch (error) {
     if (config.onHandlerError === undefined)
       throw error;
     config.onHandlerError(error);
+    return true;
+  }
+  if (response === undefined)
+    return true;
+  if (!await writeResponse(response, {
+    output: config.output,
+    responseMode: message.responseMode,
+    log
+  }))
+    return false;
+  log("response", { id: String(response.id), method, is_error: response.error !== undefined });
+  return true;
+}
+async function writeResponse(response, context) {
+  try {
+    await writeStdioJsonRpcResponse(context.output, response, context.responseMode);
+    return true;
+  } catch (error) {
+    if (!isTerminalOutputError(error))
+      throw error;
+    context.log("output_error", { message: messageFromError(error) });
+    return false;
   }
 }
+function isTerminalOutputError(error) {
+  if (!(error instanceof Error) || !("code" in error))
+    return false;
+  return error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED" || error.code === "ERR_STREAM_WRITE_AFTER_END";
+}
 function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
   let timer = null;
   let isClosed = false;

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -148,7 +148,7 @@ describe("LspClient diagnostics freshness", () => {
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
 				diagnosticResponses: [
 					{
-						delayMs: 20,
+						delayMs: 200,
 						report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
 					},
 					{
@@ -156,7 +156,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 800, versionlessPublishQuiescenceMs: 5 },
 		);
 		await context.client.openFile(context.source);
 
@@ -209,7 +209,7 @@ describe("LspClient diagnostics freshness", () => {
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
 				diagnosticResponses: [{ action: "close" }],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
 		);
 		await context.client.openFile(context.source);
 
@@ -229,7 +229,7 @@ describe("LspClient diagnostics freshness", () => {
 				],
 				diagnosticResponses: [{ error: { code: -32601, message: "Method not found" } }],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 500, versionlessPublishQuiescenceMs: 5 },
 		);
 
 		const result = await context.client.diagnostics(context.source);

package/packages/lsp-core/src/lsp/directory-diagnostics.test.ts

@@ -5,7 +5,8 @@ import { join } from "node:path";
 import { describe, expect, it } from "bun:test";
 
 import { aggregateDiagnosticsForDirectory } from "./directory-diagnostics.js";
-import type { LspClient } from "./client.js";
+import { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
 import type { Diagnostic, ResolvedServer } from "./types.js";
 
 describe("directory diagnostics", () => {
@@ -94,8 +95,124 @@ describe("directory diagnostics", () => {
 			rmSync(workspace, { recursive: true, force: true });
 		}
 	});
+
+	it("#given cold client acquisition is pending #when directory diagnostics are aborted #then acquisition settles and cleans up before startup releases", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cold-cancel-"));
+		const controller = new AbortController();
+		const startupStarted = deferred();
+		const startupRelease = deferred();
+		const server: ResolvedServer = {
+			id: "typescript",
+			command: ["typescript-language-server"],
+			extensions: [".ts"],
+			priority: 1,
+		};
+		const client = new PendingStartLspClient({
+			root: workspace,
+			server,
+			startupStarted,
+			startupRelease,
+		});
+		const manager = new LspManager({
+			clientFactory: () => client,
+			reaperIntervalMs: 60_000,
+		});
+		const aggregation = aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 1, {
+			manager,
+			listFiles: () => [join(workspace, "a.ts")],
+			workspaceRoot: workspace,
+			server,
+			signal: controller.signal,
+		});
+
+		try {
+			await startupStarted.promise;
+			controller.abort();
+
+			const settledBeforeStartupRelease = await settlesWithin(aggregation, 100);
+
+			expect(settledBeforeStartupRelease).toBe(true);
+			await expect(aggregation).rejects.toHaveProperty("name", "AbortError");
+			expect(manager.clientCount()).toBe(0);
+			expect(client.stopCallCount).toBe(1);
+		} finally {
+			startupRelease.resolve();
+			await aggregation.catch(() => undefined);
+			await manager.stopAll();
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
 });
 
+class PendingStartLspClient extends LspClient {
+	stopCallCount = 0;
+	private readonly startupStarted: Deferred;
+	private readonly startupRelease: Deferred;
+
+	constructor(options: PendingStartLspClientOptions) {
+		super(options.root, options.server);
+		this.startupStarted = options.startupStarted;
+		this.startupRelease = options.startupRelease;
+	}
+
+	override async start(): Promise<void> {
+		this.startupStarted.resolve();
+		await this.startupRelease.promise;
+	}
+
+	override async initialize(): Promise<void> {}
+
+	override async stop(): Promise<void> {
+		this.stopCallCount += 1;
+	}
+
+	override isAlive(): boolean {
+		return true;
+	}
+
+	override async diagnostics(): Promise<{ readonly items: Diagnostic[] }> {
+		return { items: [] };
+	}
+}
+
+interface PendingStartLspClientOptions {
+	readonly root: string;
+	readonly server: ResolvedServer;
+	readonly startupStarted: Deferred;
+	readonly startupRelease: Deferred;
+}
+
+interface Deferred {
+	readonly promise: Promise<void>;
+	resolve(): void;
+}
+
+function deferred(): Deferred {
+	let resolvePromise: (() => void) | undefined;
+	const promise = new Promise<void>((resolve) => {
+		resolvePromise = resolve;
+	});
+	return { promise, resolve: () => resolvePromise?.() };
+}
+
+async function settlesWithin(promise: Promise<unknown>, timeoutMs: number): Promise<boolean> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			promise.then(
+				() => true,
+				() => true,
+			),
+			new Promise<boolean>((resolve) => {
+				timer = setTimeout(() => resolve(false), timeoutMs);
+				timer.unref();
+			}),
+		]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
 function diagnostic(message: string): Diagnostic {
 	return {
 		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },

package/packages/lsp-core/src/lsp/directory-diagnostics.ts

@@ -124,7 +124,7 @@ export async function aggregateDiagnosticsForDirectory(
 	const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
 
 	options.signal?.throwIfAborted();
-	const client = await manager.getClient(root, server);
+	const client = await manager.getClient(root, server, options.signal);
 	try {
 		let nextIndex = 0;
 		const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {