co-maintainer 0.5.1-beta.1 → 0.5.1-beta.2

package/README.md

@@ -43,8 +43,8 @@ co-maintainer review --output=github  # annotations and a job summary inside Git
 Settings live in `config.json`, so a flag you use every time can be saved once:
 
 ```sh
-co-maintainer config set ai openrouter             # or openai, or anthropic
-co-maintainer config set ai-key sk-or-...        # your provider's key (OpenRouter, OpenAI or Anthropic)
+co-maintainer config set ai openrouter             # or openai, anthropic, opencode-zen, opencode-go
+co-maintainer config set ai-key sk-or-...        # your provider's key (OpenRouter, OpenAI, Anthropic or OpenCode)
 co-maintainer config set high-model openai/gpt-5.6-luna
 co-maintainer config set low-model openai/gpt-oss-120b
 co-maintainer config list                        # every key, its value and its source

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.5.1-beta.1",
+    "version": "0.5.1-beta.2",
     "description": "An imitator of yours, A PR review tool like co-maintainer.",
     "keywords": [
         "ai",

package/dist/src/ai/opencode.d.ts

@@ -0,0 +1,10 @@
+import type { ChatHost } from "./openrouter.ts";
+import type { VerifyResult } from "./verify.ts";
+export type OpenCodeVariant = "opencode-zen" | "opencode-go";
+/** `CM_OPENCODE_URL` replaces the origin in tests. Zen and Go differ only in
+ * the path under it. */
+export declare function openCodeBase(variant: OpenCodeVariant): string;
+export declare function openCodeHost(variant: OpenCodeVariant): ChatHost;
+/** `/models` is public, so it proves nothing about the key. Only the model is
+ * checked here, and a bad key shows up on the first real call. */
+export declare function verifyOpenCode(variant: OpenCodeVariant, _apiKey: string, model?: string): Promise<VerifyResult>;

package/dist/src/ai/opencode.js

@@ -0,0 +1,76 @@
+/** OpenCode Zen and OpenCode Go, two gateways run by the OpenCode team.
+ *
+ * Both route each model to its own wire format (Responses, Messages, Chat
+ * Completions, Google), and the model list does not say which. Every model is
+ * called over Chat Completions instead of keeping a model to format table
+ * that goes stale with each new model. A model that refuses it fails with a
+ * hint that says so. */
+import { randomUUID } from "node:crypto";
+import { CliError, EXIT_USAGE } from "../cli/error.js";
+import { getEnv } from "../util/runtime.js";
+import { VERSION } from "../version.js";
+/** Go asks every client for one session id that stays the same for the run,
+ * so one per process. */
+const SESSION_ID = randomUUID();
+/** `CM_OPENCODE_URL` replaces the origin in tests. Zen and Go differ only in
+ * the path under it. */
+export function openCodeBase(variant) {
+    const origin = (getEnv("CM_OPENCODE_URL") ?? "https://opencode.ai").replace(/\/$/, "");
+    return `${origin}${variant === "opencode-go" ? "/zen/go/v1" : "/zen/v1"}`;
+}
+function displayName(variant) {
+    return variant === "opencode-go" ? "OpenCode Go" : "OpenCode Zen";
+}
+export function openCodeHost(variant) {
+    return {
+        provider: variant,
+        name: displayName(variant),
+        code: "opencode",
+        endpoint: `${openCodeBase(variant)}/chat/completions`,
+        // Go wants its own user agent and a stable session id from every client.
+        // Zen does not ask, and sending the same pair costs nothing.
+        headers: {
+            "User-Agent": `co-maintainer/${VERSION}`,
+            "x-opencode-session": SESSION_ID,
+        },
+        modelHint: "co-maintainer calls every OpenCode model over Chat Completions. Pick one that supports it from https://opencode.ai/docs/zen and set it with co-maintainer set --high-model=...",
+    };
+}
+/** `/models` is public, so it proves nothing about the key. Only the model is
+ * checked here, and a bad key shows up on the first real call. */
+export async function verifyOpenCode(variant, _apiKey, model) {
+    if (!model)
+        return { status: "ok" };
+    const name = displayName(variant);
+    let response;
+    try {
+        response = await fetch(`${openCodeBase(variant)}/models`);
+    }
+    catch (error) {
+        const code = error.cause?.code;
+        return { status: "unreachable", reason: code ?? "network error" };
+    }
+    if (!response.ok) {
+        return {
+            status: "unreachable",
+            reason: `${name} returned ${response.status}`,
+        };
+    }
+    let rows;
+    try {
+        rows = (await response.json()).data;
+    }
+    catch {
+        rows = undefined;
+    }
+    if (!Array.isArray(rows)) {
+        return { status: "unreachable", reason: `${name} returned no model list` };
+    }
+    if (!rows.some((row) => row?.id === model)) {
+        return {
+            status: "rejected",
+            error: new CliError("opencode_unknown_model", `${name} does not know the model ${model}.`, "Pick one from https://opencode.ai/docs/zen and set it with co-maintainer set --high-model=...", EXIT_USAGE),
+        };
+    }
+    return { status: "ok" };
+}

package/dist/src/ai/openrouter.d.ts

@@ -1,22 +1,38 @@
 import type { AiProvider, AiRequest, AiResponse } from "../types.ts";
 import { CliError } from "../cli/error.ts";
+/** A service that speaks OpenAI-compatible Chat Completions. OpenRouter is
+ * one, OpenCode Zen and OpenCode Go are the others, so they share this client
+ * and differ only in where they live and how they name themselves. */
+export type ChatHost = {
+    provider: AiResponse["provider"];
+    /** Shown in every message, e.g. `OpenCode Zen rejected the API key.` */
+    name: string;
+    /** Prefix of the error codes, e.g. `openrouter_unauthorized`. */
+    code: string;
+    endpoint: string;
+    headers: Record<string, string>;
+    /** The hint for a model the host refuses. */
+    modelHint: string;
+};
+/** `CM_OPENROUTER_URL` points the provider at a local fake in tests. It is
+ * only a default override: with the env unset the real endpoint is used, so
+ * nothing changes for users. */
+export declare function openRouterHost(): ChatHost;
 /** Provider failures as actionable text. A 401 and a 400 for
  * an unknown model are preconditions the user can fix, so they are usage
  * errors; anything else is a runtime failure. Only the provider's own
  * `error.message` is surfaced: the raw body can carry account metadata
  * (`user_id`) that has no business in a terminal. */
-export declare function openRouterError(model: string, status: number, body: string): CliError;
+export declare function openRouterError(model: string, status: number, body: string, host?: ChatHost): CliError;
 export declare class OpenRouterProvider implements AiProvider {
     readonly supportsTools = true;
-    /** `CM_OPENROUTER_URL` points the provider at a local fake in tests. It is
-     * only a default override: with the env unset the real endpoint is used, so
-     * nothing changes for users. */
-    private readonly endpoint;
+    private readonly host;
     private readonly apiKey;
     private readonly model;
-    constructor(apiKey: string, model: string);
+    constructor(apiKey: string, model: string, host?: ChatHost);
     /** One POST. Returns the raw response so `complete` can decide whether the
      * failure is worth a retry without the schema. */
     private post;
+    private fail;
     complete(request: AiRequest): Promise<AiResponse>;
 }

package/dist/src/ai/openrouter.js

@@ -1,12 +1,29 @@
 import { chatBody, parseChatResponse } from "./provider.js";
 import { getEnv } from "../util/runtime.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
+/** `CM_OPENROUTER_URL` points the provider at a local fake in tests. It is
+ * only a default override: with the env unset the real endpoint is used, so
+ * nothing changes for users. */
+export function openRouterHost() {
+    return {
+        provider: "openrouter",
+        name: "OpenRouter",
+        code: "openrouter",
+        endpoint: getEnv("CM_OPENROUTER_URL") ??
+            "https://openrouter.ai/api/v1/chat/completions",
+        headers: {
+            "HTTP-Referer": "https://github.com/GroophyLifefor/co-maintainer",
+            "X-Title": "co-maintainer",
+        },
+        modelHint: "Pick one at https://openrouter.ai/models and set it with co-maintainer set --high-model=...",
+    };
+}
 /** Provider failures as actionable text. A 401 and a 400 for
  * an unknown model are preconditions the user can fix, so they are usage
  * errors; anything else is a runtime failure. Only the provider's own
  * `error.message` is surfaced: the raw body can carry account metadata
  * (`user_id`) that has no business in a terminal. */
-export function openRouterError(model, status, body) {
+export function openRouterError(model, status, body, host = openRouterHost()) {
     let detail = "";
     try {
         const parsed = JSON.parse(body);
@@ -16,25 +33,22 @@ export function openRouterError(model, status, body) {
         detail = body.trim().slice(0, 200);
     }
     if (status === 401 || status === 403) {
-        return new CliError("openrouter_unauthorized", "OpenRouter rejected the API key.", "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
+        return new CliError(`${host.code}_unauthorized`, `${host.name} rejected the API key.`, "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
     }
     if (status === 400 && /model/i.test(detail)) {
-        return new CliError("openrouter_unknown_model", `OpenRouter does not know the model ${model}.`, `Pick one at https://openrouter.ai/models and set it with co-maintainer set --high-model=...`, EXIT_USAGE);
+        return new CliError(`${host.code}_unknown_model`, `${host.name} does not know the model ${model}.`, host.modelHint, EXIT_USAGE);
     }
-    return new CliError("openrouter_failed", `OpenRouter failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);
+    return new CliError(`${host.code}_failed`, `${host.name} failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);
 }
 export class OpenRouterProvider {
     supportsTools = true;
-    /** `CM_OPENROUTER_URL` points the provider at a local fake in tests. It is
-     * only a default override: with the env unset the real endpoint is used, so
-     * nothing changes for users. */
-    endpoint = getEnv("CM_OPENROUTER_URL") ??
-        "https://openrouter.ai/api/v1/chat/completions";
+    host;
     apiKey;
     model;
-    constructor(apiKey, model) {
+    constructor(apiKey, model, host = openRouterHost()) {
         if (!apiKey)
-            throw new Error("OpenRouter requires OPENROUTER_API_KEY");
+            throw new Error(`${host.name} requires an API key`);
+        this.host = host;
         this.apiKey = apiKey;
         this.model = model;
     }
@@ -42,22 +56,24 @@ export class OpenRouterProvider {
      * failure is worth a retry without the schema. */
     async post(body) {
         try {
-            return await fetch(this.endpoint, {
+            return await fetch(this.host.endpoint, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${this.apiKey}`,
                     "Content-Type": "application/json",
-                    "HTTP-Referer": "https://github.com/GroophyLifefor/co-maintainer",
-                    "X-Title": "co-maintainer",
+                    ...this.host.headers,
                 },
                 body: JSON.stringify(body),
             });
         }
         catch (error) {
             // `fetch failed` alone names neither the host nor the cause.
-            throw networkFailure(this.endpoint, error);
+            throw networkFailure(this.host.endpoint, error);
         }
     }
+    fail(status, body) {
+        return openRouterError(this.model, status, body, this.host);
+    }
     async complete(request) {
         let response = await this.post(chatBody(this.model, request));
         // A provider may refuse `response_format` next to `tools`. The schema is
@@ -69,15 +85,15 @@ export class OpenRouterProvider {
                 const { responseFormat: _dropped, ...withoutSchema } = request;
                 response = await this.post(chatBody(this.model, withoutSchema));
                 if (response.ok) {
-                    return parseChatResponse((await response.json()), "openrouter", this.model);
+                    return parseChatResponse((await response.json()), this.host.provider, this.model);
                 }
-                throw openRouterError(this.model, response.status, await response.text());
+                throw this.fail(response.status, await response.text());
             }
-            throw openRouterError(this.model, response.status, detail);
+            throw this.fail(response.status, detail);
         }
         if (!response.ok) {
-            throw openRouterError(this.model, response.status, await response.text());
+            throw this.fail(response.status, await response.text());
         }
-        return parseChatResponse((await response.json()), "openrouter", this.model);
+        return parseChatResponse((await response.json()), this.host.provider, this.model);
     }
 }

package/dist/src/ai/provider.d.ts

@@ -2,7 +2,10 @@ import type { AiProvider, AiRequest, AiResponse, Json, Options } from "../types.
 /** The one list of accepted `--ai` values, so a new or retired provider is
  * added or removed in a single place instead of the half dozen copies
  * Hetzner's removal had to chase down. */
-export declare const AI_PROVIDERS: readonly ["none", "openrouter", "openai", "anthropic"];
+export declare const AI_PROVIDERS: readonly ["none", "openrouter", "openai", "anthropic", "opencode-zen", "opencode-go"];
+/** The provider's own key variable. It is read only when that provider runs,
+ * so a key meant for one provider is never sent to another. */
+export declare function providerKeyEnv(ai: string, env: (name: string) => string | undefined): string | undefined;
 /** Hetzner was dropped in 0.5.1. Naming it beats a generic "must be one of". */
 export declare function rejectRetiredProvider(value: string | undefined): void;
 export declare function createAiProvider(options: Options, model: string): AiProvider | undefined;

package/dist/src/ai/provider.js

@@ -1,6 +1,7 @@
 import { OpenRouterProvider } from "./openrouter.js";
 import { OpenAiProvider } from "./openai.js";
 import { AnthropicProvider } from "./anthropic.js";
+import { openCodeHost } from "./opencode.js";
 import { die } from "../cli/error.js";
 /** The one list of accepted `--ai` values, so a new or retired provider is
  * added or removed in a single place instead of the half dozen copies
@@ -10,7 +11,19 @@ export const AI_PROVIDERS = [
     "openrouter",
     "openai",
     "anthropic",
+    "opencode-zen",
+    "opencode-go",
 ];
+/** The provider's own key variable. It is read only when that provider runs,
+ * so a key meant for one provider is never sent to another. */
+export function providerKeyEnv(ai, env) {
+    if (ai === "openrouter")
+        return env("OPENROUTER_API_KEY");
+    if (ai === "opencode-zen" || ai === "opencode-go") {
+        return env("OPENCODE_API_KEY");
+    }
+    return undefined;
+}
 /** Hetzner was dropped in 0.5.1. Naming it beats a generic "must be one of". */
 export function rejectRetiredProvider(value) {
     if (value === "hetzner") {
@@ -29,6 +42,9 @@ export function createAiProvider(options, model) {
     if (options.ai === "anthropic") {
         return new AnthropicProvider(options.aiToken ?? "", model);
     }
+    if (options.ai === "opencode-zen" || options.ai === "opencode-go") {
+        return new OpenRouterProvider(options.aiToken ?? "", model, openCodeHost(options.ai));
+    }
     die(`${options.ai} support is not finished yet. Use openrouter or none.`);
 }
 export function parseChatResponse(json, provider, model) {

package/dist/src/cli/args.js

@@ -2,7 +2,7 @@ import { prepareConfig } from "../config.js";
 import { getEnv } from "../util/runtime.js";
 import { askLine } from "./prompt.js";
 import { die } from "./error.js";
-import { AI_PROVIDERS, rejectRetiredProvider } from "../ai/provider.js";
+import { AI_PROVIDERS, providerKeyEnv, rejectRetiredProvider, } from "../ai/provider.js";
 import { detectRemoteRepo } from "../local/git_ops.js";
 import { reviewBlockingFrom } from "../review/blocking.js";
 import { renderCommandHelp, renderGlobalHelp, unknownCommandMessage, unknownOptionMessage, } from "./commands/registry.js";
@@ -190,10 +190,15 @@ export async function parseArgs(args) {
     rejectRetiredProvider(text("ai"));
     let ai = choice("ai", AI_PROVIDERS, configuredAi ?? "none");
     if (command === "review") {
-        if (explicitAi && choice("ai", AI_PROVIDERS, "none") !== "openrouter") {
-            die("review supports OpenRouter only");
+        // Review was pinned to OpenRouter only so Hetzner never wrote one. Hetzner
+        // is gone, so review follows the configured provider. With none set it
+        // stays on OpenRouter, which every review before this one used.
+        if (ai === "none") {
+            if (explicitAi) {
+                die(`review needs an AI provider. Pass --ai=${AI_PROVIDERS.filter((p) => p !== "none").join("|")}`);
+            }
+            ai = "openrouter";
         }
-        ai = "openrouter";
     }
     else if (!explicitAi && !configuredAi && command !== "probe") {
         const selected = await ask(`AI provider (${AI_PROVIDERS.join("|")})`, "openrouter");
@@ -205,20 +210,23 @@ export async function parseArgs(args) {
     }
     let aiToken = text("token") ??
         env("CO_MAINTAINER_TOKEN") ??
-        (ai === "openrouter" ? env("OPENROUTER_API_KEY") : undefined) ??
+        providerKeyEnv(ai, env) ??
         config.token;
+    // The OPENROUTER_ names would hand an OpenRouter model id to another
+    // provider, so they only count when OpenRouter is the one running.
+    const openRouterModelEnv = (name) => ai === "openrouter" ? env(name) : undefined;
     let lowModel = text("low-model") ??
-        env("OPENROUTER_LOW_MODEL") ??
+        openRouterModelEnv("OPENROUTER_LOW_MODEL") ??
         env("LOW_MODEL") ??
         repoConfig.lowModel ??
         config.lowModel;
     let highModel = text("high-model") ??
-        env("OPENROUTER_HIGH_MODEL") ??
+        openRouterModelEnv("OPENROUTER_HIGH_MODEL") ??
         env("HIGH_MODEL") ??
         repoConfig.highModel ??
         config.highModel;
     if (command === "review") {
-        aiToken ??= await ask("openrouter API key", undefined, true);
+        aiToken ??= await ask(`${ai} API key`, undefined, true);
         // Review summarizes large files with the low model, so it needs one just
         // as init and sync do. Without a default to fall back on, ask here too.
         lowModel ??= await ask("low model", undefined, true);

package/dist/src/cli/commands/config.js

@@ -39,7 +39,7 @@ export function maskSecret(value) {
 /** The env var that supplies each field, mirroring args.ts. Only the fields
  * that actually read env are listed. */
 export const ENV_BY_FIELD = {
-    token: ["CO_MAINTAINER_TOKEN", "OPENROUTER_API_KEY"],
+    token: ["CO_MAINTAINER_TOKEN", "OPENROUTER_API_KEY", "OPENCODE_API_KEY"],
     githubPat: ["GITHUB_TOKEN", "GH_TOKEN"],
     ai: ["CO_MAINTAINER_AI"],
     auth: ["CO_MAINTAINER_AUTH"],

package/dist/src/cli/commands/registry.d.ts

@@ -1,11 +1,3 @@
-/** The command registry.
- *
- * One place that knows every command, its aliases, its usage lines, its flags
- * and its examples. Everything the user reads as help is rendered from here,
- * so a flag cannot drift out of the help and a command cannot be documented
- * twice with different wording. It is also the source the command reference is
- * generated from, which is why it is data rather than template strings.
- */
 export type FlagSpec = {
     /** Without the leading dashes, e.g. `include-codebase`. */
     name: string;

package/dist/src/cli/commands/registry.js

@@ -6,6 +6,7 @@
  * twice with different wording. It is also the source the command reference is
  * generated from, which is why it is data rather than template strings.
  */
+import { AI_PROVIDERS } from "../../ai/provider.js";
 const OUTPUT_FLAGS = {
     title: "Output and diagnostics",
     flags: [
@@ -34,7 +35,7 @@ const AI_FLAGS = {
     flags: [
         {
             name: "ai",
-            value: "none|openrouter|openai|anthropic",
+            value: AI_PROVIDERS.join("|"),
             default: "none",
             description: "Which provider writes the review.",
         },
@@ -56,16 +57,6 @@ const AI_FLAGS = {
         },
     ],
 };
-/** `review` always calls OpenRouter regardless of what `--ai=` is passed,
- * so its own help must not advertise the other three names the
- * other AI commands accept. */
-const REVIEW_AI_FLAGS = {
-    ...AI_FLAGS,
-    flags: [
-        { ...AI_FLAGS.flags[0], value: "openrouter" },
-        ...AI_FLAGS.flags.slice(1),
-    ],
-};
 const GITHUB_FLAGS = {
     title: "GitHub access",
     flags: [
@@ -364,7 +355,7 @@ export const COMMANDS = [
                     },
                 ],
             },
-            REVIEW_AI_FLAGS,
+            AI_FLAGS,
             GITHUB_FLAGS,
             REVIEW_OUTPUT_FLAGS,
         ],
@@ -549,7 +540,7 @@ export const COMMANDS = [
                     },
                     {
                         name: "no-verify",
-                        description: "Do not check the key and model against OpenRouter.",
+                        description: "Do not check the key and model against the provider.",
                     },
                     {
                         name: "unset",

package/dist/src/cli/commands/set.js

@@ -2,6 +2,7 @@ import { readConfig, configPath, writeUserConfig } from "../../config.js";
 import { hashPassword, passwordProblem } from "../../util/password.js";
 import { readTextFile } from "../../util/runtime.js";
 import { verifyAnthropic, verifyOpenAi, verifyOpenRouter, } from "../../ai/verify.js";
+import { verifyOpenCode } from "../../ai/opencode.js";
 import { die } from "../error.js";
 import { parsePolicy } from "../../services/review_policy.js";
 import { AI_PROVIDERS, rejectRetiredProvider } from "../../ai/provider.js";
@@ -266,16 +267,15 @@ export async function runSet(args) {
     const effectiveAi = effective("ai");
     const effectiveToken = effective("token");
     const effectiveHighModel = effective("highModel");
-    if (verify &&
-        (effectiveAi === "openrouter" ||
-            effectiveAi === "openai" ||
-            effectiveAi === "anthropic") &&
-        effectiveToken) {
-        const verifyProvider = effectiveAi === "openrouter"
-            ? verifyOpenRouter
-            : effectiveAi === "openai"
-                ? verifyOpenAi
-                : verifyAnthropic;
+    const verifiers = {
+        openrouter: verifyOpenRouter,
+        openai: verifyOpenAi,
+        anthropic: verifyAnthropic,
+        "opencode-zen": (key, model) => verifyOpenCode("opencode-zen", key, model),
+        "opencode-go": (key, model) => verifyOpenCode("opencode-go", key, model),
+    };
+    const verifyProvider = typeof effectiveAi === "string" ? verifiers[effectiveAi] : undefined;
+    if (verify && verifyProvider && effectiveToken) {
         const result = await verifyProvider(String(effectiveToken), effectiveHighModel === undefined ? undefined : String(effectiveHighModel));
         if (result.status === "rejected")
             throw result.error;

package/dist/src/config.d.ts

@@ -5,7 +5,7 @@ import { type Platform } from "./util/runtime.ts";
  * flags and no interactive prompts, reusing what `init` was told. */
 export type RepoConfig = {
     auth?: "gh" | "pat";
-    ai?: "none" | "openrouter" | "openai" | "anthropic";
+    ai?: "none" | "openrouter" | "openai" | "anthropic" | "opencode-zen" | "opencode-go";
     lowModel?: string;
     highModel?: string;
     maxCommits?: number;
@@ -24,7 +24,7 @@ export type RepoConfig = {
 };
 export type UserConfig = {
     auth?: "gh" | "pat";
-    ai?: "none" | "openrouter" | "openai" | "anthropic";
+    ai?: "none" | "openrouter" | "openai" | "anthropic" | "opencode-zen" | "opencode-go";
     lowModel?: string;
     highModel?: string;
     /** Written only by `co-maintainer set --token=...`. Every other write

package/dist/src/pr/reviewer.js

@@ -1,4 +1,4 @@
-import { OpenRouterProvider } from "../ai/openrouter.js";
+import { createAiProvider } from "../ai/provider.js";
 import { CliError, EXIT_USAGE } from "../cli/error.js";
 import { completeWithMermaidTools, } from "../ai/mermaid_loop.js";
 import { loadGuides } from "../review/guides.js";
@@ -11,6 +11,15 @@ import { FINDINGS_JSON_INSTRUCTIONS, FINDINGS_JSON_SCHEMA, findingsMarkdownFromJ
 /** A model id is never guessed here. Models go stale, and a build already
  * installed cannot fetch a fresher one, so the id to run comes from config
  * or a flag, set at least once by whoever runs it (Murat, 2026-09-28). */
+/** The configured provider for one model. Built only when a call needs it:
+ * a provider's constructor requires a real key, which a fake-AI run never has. */
+function reviewProvider(options, model, label) {
+    const provider = createAiProvider(options, requiredModel(model, label));
+    if (!provider) {
+        throw new CliError("missing_provider", "Review needs an AI provider.", "Run co-maintainer set --ai=... --token=...", EXIT_USAGE);
+    }
+    return provider;
+}
 function requiredModel(model, label) {
     if (model)
         return model;
@@ -243,12 +252,10 @@ export async function reviewPullRequest(client, options, usage, snapshot, ai, pr
     if (scope) {
         report(`scope resolved · own=${ownFiles.length} files · upstream=${upstreamFiles.length} files`);
     }
-    // Built only if needed: OpenRouterProvider's constructor requires a real
-    // API key, which a fake-AI test run never has.
+    // Built only if needed, see reviewProvider.
     const filesNeedSummary = ownFiles.some(({ file }) => needsSummary(Number(file.changes ?? 0), String(file.patch ?? "")));
     const lowProvider = filesNeedSummary
-        ? (ai ??
-            new OpenRouterProvider(options.aiToken ?? "", requiredModel(options.lowModel, "low")))
+        ? (ai ?? reviewProvider(options, options.lowModel, "low"))
         : undefined;
     const patchByPath = new Map();
     const [ownSections, codegraphTools] = await Promise.all([
@@ -312,8 +319,7 @@ interaction if the pull request's own change above relies on or conflicts with
 one of these files, and never mark that finding blocking:
 ${upstreamListing}${unchangedListing}`;
     report(`diff prepared · ${ownPatch.length} chars${diffWasTruncated ? " · truncated for model context" : ""}`);
-    const provider = ai ??
-        new OpenRouterProvider(options.aiToken ?? "", requiredModel(options.highModel, "high"));
+    const provider = ai ?? reviewProvider(options, options.highModel, "high");
     const diagrams = provider.supportsTools !== false;
     const carryBlock = extras?.carryPrompt ? `${extras.carryPrompt}\n` : "";
     const prompt = `Review this pull request against the repository's review guide and
@@ -370,11 +376,11 @@ ${diff}`;
         reasoningEffort: "high",
         responseFormat: FINDINGS_JSON_SCHEMA,
     };
-    report(`AI request · model=${options.highModel ?? "openrouter default"} · ` +
+    report(`AI request · ${options.ai} · model=${options.highModel ?? "unset"} · ` +
         `prompt=${prompt.length} chars · maxTokens=${request.maxTokens}`);
     if (options.debug) {
         console.log(`[debug] review prompt · ${prompt.length} chars · diff=${diff.length} chars`);
-        console.log(`[debug] openrouter request · model=${options.highModel ?? "unset"} · maxTokens=${request.maxTokens}`);
+        console.log(`[debug] ${options.ai} request · model=${options.highModel ?? "unset"} · maxTokens=${request.maxTokens}`);
     }
     let response = await completeWithMermaidTools(provider, request, 1, extraTools, maxToolRounds);
     if (usage)
@@ -385,7 +391,7 @@ ${diff}`;
         console.log(`\n----- INITIAL REVIEW -----\n${response.text}\n`);
     }
     if (!response.text.trim()) {
-        throw new Error("OpenRouter returned an empty review. The reasoning budget may have been exhausted");
+        throw new Error(`${options.ai} returned an empty review. The reasoning budget may have been exhausted`);
     }
     // The model returns JSON; we render the Markdown. A reply
     // that is not usable JSON is retried once and then falls back to the legacy
@@ -417,7 +423,7 @@ ${reviewText}`,
         report(`AI improvement response · input=${response.tokensIn} tokens · ` +
             `output=${response.tokensOut} tokens`);
         if (!response.text.trim()) {
-            throw new Error(`OpenRouter returned an empty review improvement at pass ${pass - 1}`);
+            throw new Error(`${options.ai} returned an empty review improvement at pass ${pass - 1}`);
         }
         reviewText = await normalizeReviewResponse(provider, improvementRequest, response, extraTools, maxToolRounds, usage, report, options);
         if (options.debug) {
@@ -471,8 +477,7 @@ export async function reviewWorkspaceRevision(revision, options, headSha, usage,
         const changes = Number(file.changes ?? 0);
         const patch = String(file.patch ?? "");
         const lowProvider = needsSummary(changes, patch)
-            ? (ai ??
-                new OpenRouterProvider(options.aiToken ?? "", requiredModel(options.lowModel, "low")))
+            ? (ai ?? reviewProvider(options, options.lowModel, "low"))
             : undefined;
         if (!lowProvider)
             return `FILE: ${path}\n${filePatch(file)}`;
@@ -506,8 +511,7 @@ export async function reviewWorkspaceRevision(revision, options, headSha, usage,
             .join("\n")}`
         : "";
     const carryBlock = extras?.carryPrompt ? `${extras.carryPrompt}\n` : "";
-    const provider = ai ??
-        new OpenRouterProvider(options.aiToken ?? "", requiredModel(options.highModel, "high"));
+    const provider = ai ?? reviewProvider(options, options.highModel, "high");
     const diagrams = provider.supportsTools !== false;
     const prompt = `Review these local changes against the repository's review guide and
 codebase conventions. Find only actionable code-level violations supported by
@@ -541,7 +545,7 @@ ${ownDiff}${unchangedListing}`;
     if (usage)
         await usage(response);
     if (!response.text.trim()) {
-        throw new Error("OpenRouter returned an empty review");
+        throw new Error(`${options.ai} returned an empty review`);
     }
     let reviewText = await normalizeReviewResponse(provider, request, response, extraTools, maxToolRounds, usage, report, options);
     for (let pass = 2; pass <= matrix; pass++) {

package/dist/src/server/pages/settings.js

@@ -48,6 +48,8 @@ export function renderSettings(username, config, webhookUrl, baseUrl) {
             <option value="openrouter"${config.ai === "openrouter" ? " selected" : ""}>OpenRouter</option>
             <option value="openai"${config.ai === "openai" ? " selected" : ""}>OpenAI</option>
             <option value="anthropic"${config.ai === "anthropic" ? " selected" : ""}>Anthropic</option>
+            <option value="opencode-zen"${config.ai === "opencode-zen" ? " selected" : ""}>OpenCode Zen</option>
+            <option value="opencode-go"${config.ai === "opencode-go" ? " selected" : ""}>OpenCode Go</option>
           </select></div>
         <div class="field"><label>API key</label>
           <input id="token" type="password" placeholder="Leave blank to keep the current key">

package/dist/src/services/remote_review.js

@@ -38,9 +38,9 @@ class RemoteReviewError extends Error {
 function remoteQueueKey(repo, branch, tokenId) {
     return `remote:${repo}:${branch}:${tokenId}`;
 }
-/** True only for a provider *authentication* rejection: the three providers
- * raise `openrouter_unauthorized`, `openai_unauthorized` and
- * `anthropic_unauthorized`. The list is explicit so an unrelated error that
+/** True only for a provider *authentication* rejection: the providers raise
+ * `openrouter_unauthorized`, `openai_unauthorized`, `anthropic_unauthorized`
+ * and `opencode_unauthorized`. The list is explicit so an unrelated error that
  * happens to end in `_unauthorized` is not relabelled as a bad client key.
  */
 function isProviderAuthError(error) {
@@ -49,6 +49,7 @@ function isProviderAuthError(error) {
             "openrouter_unauthorized",
             "openai_unauthorized",
             "anthropic_unauthorized",
+            "opencode_unauthorized",
         ].includes(error.code));
 }
 function reviewOptionsForRepo(repo, useCodegraph, aiToken) {

package/dist/src/services/review.js

@@ -140,6 +140,8 @@ export function reviewOptions(repo, prNumber) {
         ghConcurrent: 1,
         aiConcurrent: 1,
         auth: "gh",
+        // With no provider saved the App review stays on OpenRouter, the same
+        // fallback the CLI review uses.
         ai: config.ai && config.ai !== "none" ? config.ai : "openrouter",
         aiToken: config.token,
         highModel: config.highModel,

package/dist/src/types.d.ts

@@ -24,7 +24,7 @@ export type Options = {
     envPath?: string;
     auth: "gh" | "pat";
     githubPat?: string;
-    ai: "none" | "openrouter" | "openai" | "anthropic";
+    ai: "none" | "openrouter" | "openai" | "anthropic" | "opencode-zen" | "opencode-go";
     aiToken?: string;
     lowModel?: string;
     highModel?: string;
@@ -102,7 +102,7 @@ export type AiResponse = {
         unknown: number;
     };
     model: string;
-    provider: "openrouter" | "openai" | "anthropic";
+    provider: "openrouter" | "openai" | "anthropic" | "opencode-zen" | "opencode-go";
 };
 export type AiProvider = {
     supportsTools?: boolean;

package/dist/src/util/redact.js

@@ -5,6 +5,7 @@ const PATTERNS = [
     /github_pat_[A-Za-z0-9_]{20,}/g, // fine-grained GitHub PATs
     /sk-or-[A-Za-z0-9-]{10,}/g, // OpenRouter keys
     /sk-ant-[A-Za-z0-9_-]{10,}/g, // Anthropic keys
+    /sk-[A-Za-z0-9_-]{20,}/g, // OpenAI keys, old `sk-` and new `sk-proj-` alike
     /cmr_[A-Za-z0-9_-]{20,}/g, // remote review bearer tokens
     /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
 ];

package/dist/src/util/run_summary.js

@@ -37,8 +37,22 @@ export function printRunSummary(summary) {
     else
         console.error(line);
 }
+/** A run that finished without one AI call, such as a `sync` served entirely
+ * from the cache, spent nothing. `settle` reads that as "ended before its cost
+ * was recorded", which is right for a review row and wrong for this line. */
+function madeNoAiCall(metrics) {
+    return metrics.knownCalls === 0 && metrics.unknownCalls === 0;
+}
 /** The metrics half of a summary, so call sites do not repeat the spread. */
 export function summaryFromMetrics(metrics, durationMs) {
+    if (madeNoAiCall(metrics)) {
+        return {
+            durationMs,
+            tokensIn: metrics.tokensIn,
+            tokensOut: metrics.tokensOut,
+            costUsd: 0,
+        };
+    }
     const outcome = settle(metrics);
     return {
         durationMs,
@@ -52,6 +66,8 @@ export function summaryFromMetrics(metrics, durationMs) {
 }
 /** `0.0016` for a known cost, `unknown` otherwise. For the timing log line. */
 export function costLabel(metrics) {
+    if (madeNoAiCall(metrics))
+        return "0.0000";
     const outcome = settle(metrics);
     return outcome.status === "known" ? outcome.usd.toFixed(4) : "unknown";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "co-maintainer",
-  "version": "0.5.1-beta.1",
+  "version": "0.5.1-beta.2",
   "description": "An imitator of yours, A PR review tool like co-maintainer.",
   "keywords": [
     "ai",