co-maintainer 0.5.0 → 0.5.1-beta.1

package/dist/src/ai/openai.js

@@ -0,0 +1,206 @@
+import { getEnv } from "../util/runtime.js";
+import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
+/** `CM_OPENAI_URL` points at a local fake in tests. Unset means the real
+ * endpoint, so production behavior is unchanged. */
+export function openAiBase() {
+    const endpoint = getEnv("CM_OPENAI_URL") ?? "https://api.openai.com/v1/responses";
+    return endpoint.replace(/\/responses\/?$/, "");
+}
+/** A failed response as actionable text. Only `error.message` is
+ * shown: the raw body can carry request ids that mean nothing in a terminal. */
+export function openAiError(model, status, body) {
+    let detail = "";
+    let code = "";
+    try {
+        const parsed = JSON.parse(body);
+        detail = String(parsed.error?.message ?? "");
+        code = String(parsed.error?.code ?? "");
+    }
+    catch {
+        detail = body.trim().slice(0, 200);
+    }
+    if (status === 401) {
+        return new CliError("openai_unauthorized", "OpenAI rejected the API key.", "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
+    }
+    if (status === 400 && (code === "model_not_found" || /model/i.test(detail))) {
+        return new CliError("openai_unknown_model", `OpenAI does not know the model ${model}.`, "Pick one at https://platform.openai.com/docs/models and set it with co-maintainer set --high-model=...", EXIT_USAGE);
+    }
+    return new CliError("openai_failed", `OpenAI failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);
+}
+/** The Chat-Completions-shaped message list every caller already builds
+ * (`chatBody` does the same fallback for OpenRouter). */
+function effectiveMessages(request) {
+    return (request.messages ?? [
+        ...(request.system
+            ? [{ role: "system", content: request.system }]
+            : []),
+        { role: "user", content: request.prompt },
+    ]);
+}
+/** `{type:"function",function:{name,parameters}}` (what `mermaid.ts` and the
+ * codegraph tools build) to Responses' flat shape. */
+function toResponsesTool(tool) {
+    const fn = (tool.function ?? {});
+    return {
+        type: "function",
+        name: String(fn.name ?? ""),
+        description: fn.description ? String(fn.description) : undefined,
+        parameters: fn.parameters,
+    };
+}
+/** A tool call and its result do not live inside a message the way Chat
+ * Completions nests them; each is its own item in `input`. */
+function toResponsesInput(messages) {
+    const input = [];
+    let instructions;
+    for (const message of messages) {
+        if (message.role === "system") {
+            instructions = instructions
+                ? `${instructions}\n\n${message.content ?? ""}`
+                : String(message.content ?? "");
+            continue;
+        }
+        if (message.role === "tool") {
+            input.push({
+                type: "function_call_output",
+                call_id: message.tool_call_id,
+                output: message.content ?? "",
+            });
+            continue;
+        }
+        if (message.tool_calls?.length) {
+            if (message.content) {
+                input.push({ role: "assistant", content: message.content });
+            }
+            for (const call of message.tool_calls) {
+                input.push({
+                    type: "function_call",
+                    call_id: call.id,
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                });
+            }
+            continue;
+        }
+        input.push({ role: message.role, content: message.content ?? "" });
+    }
+    return { instructions, input };
+}
+function responsesBody(model, request) {
+    const { instructions, input } = toResponsesInput(effectiveMessages(request));
+    const schema = request.responseFormat?.json_schema;
+    return {
+        model,
+        ...(instructions ? { instructions } : {}),
+        input,
+        max_output_tokens: request.maxTokens,
+        ...(request.reasoningEffort
+            ? { reasoning: { effort: request.reasoningEffort } }
+            : {}),
+        ...(request.tools?.length
+            ? {
+                tools: request.tools.map(toResponsesTool),
+                tool_choice: "auto",
+            }
+            : {}),
+        ...(schema
+            ? {
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: schema.name,
+                        schema: schema.schema,
+                        strict: schema.strict ?? false,
+                    },
+                },
+            }
+            : {}),
+    };
+}
+function parseResponsesBody(json, model) {
+    const output = Array.isArray(json.output)
+        ? json.output
+        : [];
+    const texts = [];
+    const toolCalls = [];
+    for (const item of output) {
+        if (item.type === "function_call" && item.call_id && item.name) {
+            toolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments ?? "{}" },
+            });
+            continue;
+        }
+        if (item.type !== "message")
+            continue;
+        for (const part of item.content ?? []) {
+            if (part.type === "refusal") {
+                throw new CliError("openai_refusal", `OpenAI refused to answer: ${part.refusal ?? "no reason given"}`, undefined, EXIT_RUNTIME);
+            }
+            if (part.type === "output_text" && part.text)
+                texts.push(part.text);
+        }
+    }
+    const usage = json.usage;
+    return {
+        text: texts.join(""),
+        ...(toolCalls.length ? { toolCalls } : {}),
+        tokensIn: Number(usage?.input_tokens ?? 0),
+        tokensOut: Number(usage?.output_tokens ?? 0),
+        // OpenAI's Responses API reports no dollar cost, so this is always
+        // unknown (`costReasonText`'s "provider_did_not_report").
+        cost: undefined,
+        model,
+        provider: "openai",
+    };
+}
+export class OpenAiProvider {
+    supportsTools = true;
+    endpoint = `${openAiBase()}/responses`;
+    apiKey;
+    model;
+    constructor(apiKey, model) {
+        if (!apiKey)
+            throw new Error("OpenAI requires an API key");
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async post(body) {
+        try {
+            return await fetch(this.endpoint, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            throw networkFailure(this.endpoint, error);
+        }
+    }
+    async complete(request) {
+        let response = await this.post(responsesBody(this.model, request));
+        // A model may reject `text.format` next to tools. The schema is only a
+        // hint (the prompt also asks for a fenced JSON block), so one retry
+        // without it beats failing the review outright.
+        if (response.status === 400 && request.responseFormat) {
+            const detail = await response.text();
+            if (/text\.format|json_schema|structured/i.test(detail)) {
+                const { responseFormat: _dropped, ...withoutSchema } = request;
+                response = await this.post(responsesBody(this.model, withoutSchema));
+                if (response.ok) {
+                    return parseResponsesBody((await response.json()), this.model);
+                }
+                throw openAiError(this.model, response.status, await response.text());
+            }
+            throw openAiError(this.model, response.status, detail);
+        }
+        if (!response.ok) {
+            throw openAiError(this.model, response.status, await response.text());
+        }
+        return parseResponsesBody((await response.json()), this.model);
+    }
+}

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

@@ -1,6 +1,6 @@
 import type { AiProvider, AiRequest, AiResponse } from "../types.ts";
 import { CliError } from "../cli/error.ts";
-/** Provider failures as actionable text (CORE-12, F24/F28). A 401 and a 400 for
+/** 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

package/dist/src/ai/openrouter.js

@@ -1,7 +1,7 @@
 import { chatBody, parseChatResponse } from "./provider.js";
 import { getEnv } from "../util/runtime.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
-/** Provider failures as actionable text (CORE-12, F24/F28). A 401 and a 400 for
+/** 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
@@ -54,7 +54,7 @@ export class OpenRouterProvider {
             });
         }
         catch (error) {
-            // `fetch failed` alone names neither the host nor the cause (CORE-12).
+            // `fetch failed` alone names neither the host nor the cause.
             throw networkFailure(this.endpoint, error);
         }
     }
@@ -62,7 +62,7 @@ export class OpenRouterProvider {
         let response = await this.post(chatBody(this.model, request));
         // A provider may refuse `response_format` next to `tools`. The schema is
         // only a hint — the prompt also asks for a fenced JSON block — so one
-        // retry without it is better than failing the review (CORE-40).
+        // retry without it is better than failing the review.
         if (response.status === 400 && request.responseFormat) {
             const detail = await response.text();
             if (/response_format|json_schema|structured/i.test(detail)) {

package/dist/src/ai/pricing.js

@@ -1,4 +1,4 @@
-/** OpenRouter model prices for the probe estimate (CORE-24).
+/** OpenRouter model prices for the probe estimate.
  *
  * `/api/v1/models` is public: no key needed. The list is large and changes
  * slowly, so it is cached for 24 hours in cache.db. A network failure is not

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

@@ -1,4 +1,10 @@
 import type { AiProvider, AiRequest, AiResponse, Json, Options } from "../types.ts";
+/** 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"];
+/** 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;
 export declare function parseChatResponse(json: Json, provider: AiResponse["provider"], model: string): AiResponse;
 export declare function chatBody(model: string, request: AiRequest): Json;

package/dist/src/ai/provider.js

@@ -1,12 +1,35 @@
-import { HetznerProvider } from "./hetzner.js";
 import { OpenRouterProvider } from "./openrouter.js";
+import { OpenAiProvider } from "./openai.js";
+import { AnthropicProvider } from "./anthropic.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
+ * Hetzner's removal had to chase down. */
+export const AI_PROVIDERS = [
+    "none",
+    "openrouter",
+    "openai",
+    "anthropic",
+];
+/** Hetzner was dropped in 0.5.1. Naming it beats a generic "must be one of". */
+export function rejectRetiredProvider(value) {
+    if (value === "hetzner") {
+        die("Hetzner is no longer supported. Use openrouter or none.");
+    }
+}
 export function createAiProvider(options, model) {
     if (options.ai === "none")
         return undefined;
     if (options.ai === "openrouter") {
         return new OpenRouterProvider(options.aiToken ?? "", model);
     }
-    return new HetznerProvider(options.aiToken ?? "", model);
+    if (options.ai === "openai") {
+        return new OpenAiProvider(options.aiToken ?? "", model);
+    }
+    if (options.ai === "anthropic") {
+        return new AnthropicProvider(options.aiToken ?? "", model);
+    }
+    die(`${options.ai} support is not finished yet. Use openrouter or none.`);
 }
 export function parseChatResponse(json, provider, model) {
     const choice = Array.isArray(json.choices)
@@ -59,7 +82,7 @@ export function chatBody(model, request) {
         ...(request.tools?.length
             ? { tools: request.tools, tool_choice: "auto" }
             : {}),
-        // A review asks for structured output (CORE-40). The schema is sent even
+        // A review asks for structured output. The schema is sent even
         // when tools are present, because most providers accept the pair; one that
         // rejects it gets a single retry without the schema (see
         // `OpenRouterProvider.complete`), and the prompt also asks for a fenced

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

@@ -1,4 +1,4 @@
-/** Pre-flight checks for `config set` (CORE-22, F35).
+/** Pre-flight checks for `config set`.
  *
  * A wrong API key or an unknown model used to be accepted by `set` and only
  * surfaced during a review, after the pull request had been fetched and
@@ -23,3 +23,11 @@ export type VerifyResult = {
  * lists it. The first failure decides: a bad key is reported before a model
  * question, since the model check would fail on the key too. */
 export declare function verifyOpenRouter(apiKey: string, model?: string): Promise<VerifyResult>;
+/** Same shape as {@link verifyOpenRouter}: `/models` both authenticates the
+ * key and, when `model` is given, confirms OpenAI actually has it. */
+export declare function verifyOpenAi(apiKey: string, model?: string): Promise<VerifyResult>;
+/** Anthropic authenticates the key and lists models at `/models`, but with its
+ * own headers (`x-api-key` + `anthropic-version`) instead of a Bearer token.
+ * Without a model the call only proves the key; with one it also confirms
+ * Anthropic serves it. */
+export declare function verifyAnthropic(apiKey: string, model?: string): Promise<VerifyResult>;

package/dist/src/ai/verify.js

@@ -1,4 +1,4 @@
-/** Pre-flight checks for `config set` (CORE-22, F35).
+/** Pre-flight checks for `config set`.
  *
  * A wrong API key or an unknown model used to be accepted by `set` and only
  * surfaced during a review, after the pull request had been fetched and
@@ -7,6 +7,8 @@
  * user's mistake, so it warns and saves instead of refusing. */
 import { CliError, EXIT_USAGE } from "../cli/error.js";
 import { getEnv } from "../util/runtime.js";
+import { openAiBase } from "./openai.js";
+import { anthropicBase, ANTHROPIC_VERSION } from "./anthropic.js";
 /** The chat endpoint the provider uses, with `/chat/completions` removed.
  * `CM_OPENROUTER_URL` points at a local fake in tests, so the base follows it
  * and the verification hits the same server the review would. */
@@ -15,11 +17,11 @@ export function openRouterBase() {
         "https://openrouter.ai/api/v1/chat/completions";
     return endpoint.replace(/\/chat\/completions\/?$/, "");
 }
-async function getJson(url, apiKey) {
+async function getJson(url, apiKey, headers) {
     let response;
     try {
         response = await fetch(url, {
-            headers: { Authorization: `Bearer ${apiKey}` },
+            headers: headers ?? { Authorization: `Bearer ${apiKey}` },
         });
     }
     catch (error) {
@@ -76,3 +78,79 @@ export async function verifyOpenRouter(apiKey, model) {
     }
     return { status: "ok" };
 }
+/** Same shape as {@link verifyOpenRouter}: `/models` both authenticates the
+ * key and, when `model` is given, confirms OpenAI actually has it. */
+export async function verifyOpenAi(apiKey, model) {
+    const base = openAiBase();
+    const models = await getJson(`${base}/models`, apiKey);
+    if ("unreachable" in models) {
+        return { status: "unreachable", reason: models.unreachable };
+    }
+    if (models.status === 401) {
+        return {
+            status: "rejected",
+            error: new CliError("openai_unauthorized", "OpenAI rejected the API key.", "Check the key at https://platform.openai.com/api-keys and pass it again.", EXIT_USAGE),
+        };
+    }
+    if (models.status >= 400) {
+        return {
+            status: "unreachable",
+            reason: `OpenAI returned ${models.status}`,
+        };
+    }
+    if (!model)
+        return { status: "ok" };
+    const rows = models.body?.data;
+    if (!Array.isArray(rows)) {
+        return { status: "unreachable", reason: "OpenAI returned no model list" };
+    }
+    if (!rows.some((row) => row?.id === model)) {
+        return {
+            status: "rejected",
+            error: new CliError("openai_unknown_model", `OpenAI does not know the model ${model}.`, "Pick one at https://platform.openai.com/docs/models and set it with co-maintainer set --high-model=...", EXIT_USAGE),
+        };
+    }
+    return { status: "ok" };
+}
+/** Anthropic authenticates the key and lists models at `/models`, but with its
+ * own headers (`x-api-key` + `anthropic-version`) instead of a Bearer token.
+ * Without a model the call only proves the key; with one it also confirms
+ * Anthropic serves it. */
+export async function verifyAnthropic(apiKey, model) {
+    const base = anthropicBase();
+    const models = await getJson(`${base}/models`, apiKey, {
+        "x-api-key": apiKey,
+        "anthropic-version": ANTHROPIC_VERSION,
+    });
+    if ("unreachable" in models) {
+        return { status: "unreachable", reason: models.unreachable };
+    }
+    if (models.status === 401 || models.status === 403) {
+        return {
+            status: "rejected",
+            error: new CliError("anthropic_unauthorized", "Anthropic rejected the API key.", "Check the key at https://console.anthropic.com/settings/keys and pass it again.", EXIT_USAGE),
+        };
+    }
+    if (models.status >= 400) {
+        return {
+            status: "unreachable",
+            reason: `Anthropic returned ${models.status}`,
+        };
+    }
+    if (!model)
+        return { status: "ok" };
+    const rows = models.body?.data;
+    if (!Array.isArray(rows)) {
+        return {
+            status: "unreachable",
+            reason: "Anthropic returned no model list",
+        };
+    }
+    if (!rows.some((row) => row?.id === model)) {
+        return {
+            status: "rejected",
+            error: new CliError("anthropic_unknown_model", `Anthropic does not know the model ${model}.`, "Pick one at https://docs.anthropic.com/en/docs/about-claude/models and set it with co-maintainer set --high-model=...", EXIT_USAGE),
+        };
+    }
+    return { status: "ok" };
+}

package/dist/src/cli/args.d.ts

@@ -1,5 +1,4 @@
 import type { Options } from "../types.ts";
-export declare const defaultLowModel = "openai/gpt-oss-120b";
-/** Plan §8.7 — `--json` must not prompt. */
+/** `--json` must not prompt. */
 export declare function setCliInteractive(value: boolean): void;
 export declare function parseArgs(args: string[]): Promise<Options>;

package/dist/src/cli/args.js

@@ -2,6 +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 { detectRemoteRepo } from "../local/git_ops.js";
 import { reviewBlockingFrom } from "../review/blocking.js";
 import { renderCommandHelp, renderGlobalHelp, unknownCommandMessage, unknownOptionMessage, } from "./commands/registry.js";
@@ -13,10 +14,8 @@ function numberOption(value, name) {
     return number;
 }
 const commands = ["probe", "init", "sync", "remake", "review"];
-export const defaultLowModel = "openai/gpt-oss-120b";
-const defaultHighModel = "openai/gpt-5.6-luna";
 let cliInteractive = true;
-/** Plan §8.7 — `--json` must not prompt. */
+/** `--json` must not prompt. */
 export function setCliInteractive(value) {
     cliInteractive = value;
 }
@@ -24,10 +23,10 @@ async function ask(label, fallback, required = false) {
     if (!cliInteractive) {
         if (fallback !== undefined && fallback !== "")
             return fallback;
-        die(`Missing ${label}; pass it as a CLI option when running without an interactive terminal`);
+        die(`Missing ${label}. Pass it as a CLI option when running without an interactive terminal`);
     }
     if (process.stdin.isTTY !== true) {
-        die(`Missing ${label}; pass it as a CLI option when running without an interactive terminal`);
+        die(`Missing ${label}. Pass it as a CLI option when running without an interactive terminal`);
     }
     const value = await askLine(label, fallback);
     if (required && !value)
@@ -57,7 +56,7 @@ export async function parseArgs(args) {
         process.exit(0);
     }
     // `probe` (and only probe, for now) may omit the repo and let the current
-    // directory's git remote name it (CORE-24).
+    // directory's git remote name it.
     let repoName = repo;
     if ((!repoName || repoName.startsWith("-")) && command === "probe") {
         repoName = await detectRemoteRepo(process.cwd());
@@ -168,9 +167,10 @@ export async function parseArgs(args) {
     }
     const explicitAi = rest.some((arg) => arg.startsWith("--ai="));
     const configuredAiRaw = env("CO_MAINTAINER_AI") ?? repoConfig.ai ?? config.ai;
+    rejectRetiredProvider(configuredAiRaw);
     if (configuredAiRaw &&
-        !["none", "openrouter", "hetzner"].includes(configuredAiRaw)) {
-        die("CO_MAINTAINER_AI/config.ai must be none, openrouter, or hetzner");
+        !AI_PROVIDERS.includes(configuredAiRaw)) {
+        die(`CO_MAINTAINER_AI/config.ai must be one of: ${AI_PROVIDERS.join(", ")}`);
     }
     const configuredAi = configuredAiRaw;
     const configuredAuthRaw = env("CO_MAINTAINER_AUTH") ?? repoConfig.auth ?? config.auth;
@@ -187,46 +187,50 @@ export async function parseArgs(args) {
         die("--auth=pat requires a GitHub token. Pass --github-pat=..., set GITHUB_TOKEN/GH_TOKEN, " +
             "or run: co-maintainer set --github-pat=...");
     }
-    let ai = choice("ai", ["none", "openrouter", "hetzner"], configuredAi ?? "none");
+    rejectRetiredProvider(text("ai"));
+    let ai = choice("ai", AI_PROVIDERS, configuredAi ?? "none");
     if (command === "review") {
-        if (explicitAi &&
-            choice("ai", ["none", "openrouter", "hetzner"], "none") !== "openrouter") {
+        if (explicitAi && choice("ai", AI_PROVIDERS, "none") !== "openrouter") {
             die("review supports OpenRouter only");
         }
         ai = "openrouter";
     }
     else if (!explicitAi && !configuredAi && command !== "probe") {
-        const selected = await ask("AI provider (openrouter|hetzner)", "openrouter");
-        if (!["openrouter", "hetzner"].includes(selected)) {
-            die("AI provider must be openrouter or hetzner");
+        const selected = await ask(`AI provider (${AI_PROVIDERS.join("|")})`, "openrouter");
+        rejectRetiredProvider(selected);
+        if (!AI_PROVIDERS.includes(selected)) {
+            die(`AI provider must be one of: ${AI_PROVIDERS.join(", ")}`);
         }
         ai = selected;
     }
     let aiToken = text("token") ??
         env("CO_MAINTAINER_TOKEN") ??
         (ai === "openrouter" ? env("OPENROUTER_API_KEY") : undefined) ??
-        (ai === "hetzner" ? env("HETZNER_API_KEY") : undefined) ??
         config.token;
     let lowModel = text("low-model") ??
         env("OPENROUTER_LOW_MODEL") ??
-        env("HETZNER_LOW_MODEL") ??
         env("LOW_MODEL") ??
         repoConfig.lowModel ??
         config.lowModel;
     let highModel = text("high-model") ??
         env("OPENROUTER_HIGH_MODEL") ??
-        env("HETZNER_HIGH_MODEL") ??
         env("HIGH_MODEL") ??
         repoConfig.highModel ??
         config.highModel;
     if (command === "review") {
         aiToken ??= await ask("openrouter API key", undefined, true);
-        highModel ??= await ask("high model", defaultHighModel, 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);
+        highModel ??= await ask("high model", undefined, true);
     }
     else if (ai !== "none" && command !== "probe") {
+        // No house pick for any provider: models go stale and a shipped build
+        // cannot fetch a fresher one, so the model to use is the user's call,
+        // set once in config or passed every time (Murat, 2026-09-28).
         aiToken ??= await ask(`${ai} API key`, undefined, true);
-        lowModel ??= await ask("low model", defaultLowModel, true);
-        highModel ??= await ask("high model", defaultHighModel, true);
+        lowModel ??= await ask("low model", undefined, true);
+        highModel ??= await ask("high model", undefined, true);
     }
     if (command !== "review" &&
         ai !== "none" &&

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

@@ -37,7 +37,7 @@ export declare function resolveField(name: string): string;
  * `defaults` are nested maps, not settings, so they are not listed.
  * `satisfies` makes this the type's own vocabulary: a name that is not a
  * `UserConfig` key is a compile error rather than a silently undefined read. */
-export declare const KNOWN_FIELDS: readonly ["auth", "ai", "lowModel", "highModel", "token", "githubPat", "githubAppId", "githubAppPrivateKey", "githubAppPrivateKeyPath", "githubWebhookSecret", "webhookUrl", "githubOAuthClientId", "githubOAuthClientSecret", "githubOAuthAllowedUser", "passwordAuthDisabled", "githubAuthEnabled", "dashboardPasswordHash", "maxConcurrentJobs", "reviewBlocking", "remoteHost", "remoteToken", "remoteNoticeShownFor", "remoteSyncTimeoutSeconds", "maxConcurrentRemoteReviewsPerToken", "remoteToolOutputMaxChars"];
+export declare const KNOWN_FIELDS: readonly ["auth", "ai", "lowModel", "highModel", "token", "githubPat", "githubAppId", "githubAppPrivateKey", "githubAppPrivateKeyPath", "githubWebhookSecret", "webhookUrl", "githubOAuthClientId", "githubOAuthClientSecret", "githubOAuthAllowedUser", "passwordAuthDisabled", "githubAuthEnabled", "dashboardPasswordHash", "maxConcurrentJobs", "reviewBlocking", "remoteHost", "remoteToken", "remoteNoticeShownFor", "remoteSyncTimeoutSeconds", "maxConcurrentRemoteReviewsPerToken", "remoteToolOutputMaxChars", "remoteByok", "remoteByokDefault", "reviewPolicy"];
 /** `co-maintainer config <sub> ...`. `set` is handled by runSet, which this
  * command delegates to so there is one implementation of the write rules. */
 export declare function runConfig(args: string[]): Promise<void>;

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

@@ -1,5 +1,5 @@
 /** The `config` command: read and edit the user config without opening the
- * file (CORE-22, F12). `set` is `config set` under its own name, so both share
+ * file. `set` is `config set` under its own name, so both share
  * the mapping and masking here.
  *
  * The key list is derived from `UserConfig` at runtime where possible: a
@@ -18,6 +18,7 @@ export const SECRET_FIELDS = new Set([
     "githubOAuthClientSecret",
     "remoteToken",
     "dashboardPasswordHash",
+    "remoteByok",
 ]);
 /** `lowModel` -> `low-model`. The inverse of {@link configKey}. */
 export function flagName(field) {
@@ -38,13 +39,15 @@ 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", "HETZNER_API_KEY"],
+    token: ["CO_MAINTAINER_TOKEN", "OPENROUTER_API_KEY"],
     githubPat: ["GITHUB_TOKEN", "GH_TOKEN"],
     ai: ["CO_MAINTAINER_AI"],
     auth: ["CO_MAINTAINER_AUTH"],
-    lowModel: ["OPENROUTER_LOW_MODEL", "HETZNER_LOW_MODEL", "LOW_MODEL"],
-    highModel: ["OPENROUTER_HIGH_MODEL", "HETZNER_HIGH_MODEL", "HIGH_MODEL"],
+    lowModel: ["OPENROUTER_LOW_MODEL", "LOW_MODEL"],
+    highModel: ["OPENROUTER_HIGH_MODEL", "HIGH_MODEL"],
     webhookUrl: ["CM_WEBHOOK_URL"],
+    remoteHost: ["CM_REMOTE_HOST"],
+    remoteToken: ["CM_REMOTE_TOKEN"],
     reviewBlocking: ["CO_MAINTAINER_REVIEW_BLOCKING"],
 };
 /** Renders one field for people. A secret is masked; the password hash, which
@@ -151,6 +154,9 @@ export const KNOWN_FIELDS = [
     "remoteSyncTimeoutSeconds",
     "maxConcurrentRemoteReviewsPerToken",
     "remoteToolOutputMaxChars",
+    "remoteByok",
+    "remoteByokDefault",
+    "reviewPolicy",
 ];
 /** `co-maintainer config <sub> ...`. `set` is handled by runSet, which this
  * command delegates to so there is one implementation of the write rules. */

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

@@ -1,7 +1,7 @@
 import { clientFor, runInitOrRemake } from "../../services/setup.js";
 import { probePlan } from "../../services/probe.js";
 import { log, startHeartbeat } from "../../util/log.js";
-import { estimateInit, readJobHistory } from "../../ai/estimate.js";
+import { estimateCostLine, estimateInit, readJobHistory, } from "../../ai/estimate.js";
 import { loadPrices } from "../../ai/pricing.js";
 import { cacheSet } from "../../store/cache_db.js";
 export async function runProbe(options) {
@@ -25,7 +25,7 @@ export async function runProbe(options) {
     for (const reason of analysis.reasons)
         console.log(`  - ${reason}`);
     // The estimate is separate from the recommendation: the flags say what to
-    // read, this says what that costs in time and dollars (CORE-24). Prices are
+    // read, this says what that costs in time and dollars. Prices are
     // only fetched when an OpenRouter model would actually be billed, so a
     // plain `--ai=none` probe makes no network call.
     const needsPrices = options.ai === "openrouter" &&
@@ -50,15 +50,7 @@ export async function runProbe(options) {
     console.log(`  AI jobs: ${estimate.extract} extract + ${estimate.synth} synth`);
     console.log(`  tokens: ${range(estimate.tokensIn)} in · ${range(estimate.tokensOut)} out`);
     console.log(`  time: ${secondsRange(estimate.seconds)}s`);
-    if (estimate.usd) {
-        console.log(`  cost: $${estimate.usd[0].toFixed(4)}-$${estimate.usd[1].toFixed(4)}`);
-    }
-    else if (needsPrices && prices.source === "unavailable") {
-        console.log("  cost: unknown (could not read OpenRouter prices)");
-    }
-    else {
-        console.log("  cost: set --ai=openrouter with both models to estimate dollars");
-    }
+    console.log(`  cost: ${estimateCostLine(estimate, options.ai, needsPrices && prices.source === "unavailable")}`);
     console.log(`  basis: ${estimate.basis === "history"
         ? "this repository's recorded jobs"
         : "the cm-dx-lab calibration"}; an estimate, not a bill`);