co-maintainer 0.5.1-beta.4 → 0.5.2

package/dist/package.json

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

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

@@ -19,8 +19,8 @@
  *
  * `cache_control` is set on the system prompt, which every review sends as the
  * same guide prefix. Anthropic caches the longest stable prefix, so the
- * guides are billed at the cached rate from the second review on and the
- * `cache_read_input_tokens` count shows up in the usage log.
+ * guides are billed at the cached rate from the second review on. The cached
+ * tokens are counted in `tokensIn` with the rest of the input.
  *
  * ponytail: this talks to Messages without streaming. The original design
  * called for the SDK's `stream()` + `finalMessage()` helper for large `max_tokens` (a single

package/dist/src/ai/anthropic.js

@@ -1,4 +1,5 @@
 import { getEnv } from "../util/runtime.js";
+import { outputLimitError } from "./provider.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
 /** Required on every Messages request and the only version the errors below
  * are written against. */
@@ -26,8 +27,7 @@ export function anthropicError(model, status, body) {
     if (status === 401 || status === 403) {
         return new CliError("anthropic_unauthorized", "Anthropic rejected the API key.", "Set a new one with co-maintainer set --token=...", EXIT_USAGE);
     }
-    if ((status === 400 || status === 404) &&
-        (type === "not_found_error" || /model/i.test(detail))) {
+    if ((status === 400 || status === 404) && type === "not_found_error") {
         return 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 new CliError("anthropic_failed", `Anthropic failed with ${status}${detail ? `: ${detail}` : "."}`, undefined, EXIT_RUNTIME);
@@ -198,10 +198,18 @@ export function parseMessagesBody(json, model) {
         }
     }
     const usage = json.usage;
+    const text = texts.join("");
+    if (json.stop_reason === "max_tokens" && !text.trim() && !toolCalls.length) {
+        throw outputLimitError("anthropic", model);
+    }
     return {
-        text: texts.join(""),
+        text,
         ...(toolCalls.length ? { toolCalls } : {}),
-        tokensIn: Number(usage?.input_tokens ?? 0),
+        // Tokens read from or written to the prompt cache are input too, and with
+        // the guides cached they are most of it.
+        tokensIn: Number(usage?.input_tokens ?? 0) +
+            Number(usage?.cache_read_input_tokens ?? 0) +
+            Number(usage?.cache_creation_input_tokens ?? 0),
         tokensOut: Number(usage?.output_tokens ?? 0),
         // Anthropic reports only token counts, never a dollar cost, so this is
         // always unknown (`costReasonText`'s "provider_did_not_report").

package/dist/src/ai/openai.js

@@ -1,4 +1,5 @@
 import { getEnv } from "../util/runtime.js";
+import { outputLimitError, withoutRefusedPart } from "./provider.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. */
@@ -22,7 +23,9 @@ export function openAiError(model, status, body) {
     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))) {
+    // Only the code says the model is unknown. Other 400s mention "model" too,
+    // a context that is too long or a setting this model does not take.
+    if ((status === 400 || status === 404) && code === "model_not_found") {
         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);
@@ -143,8 +146,12 @@ function parseResponsesBody(json, model) {
         }
     }
     const usage = json.usage;
+    const text = texts.join("");
+    if (json.status === "incomplete" && !text.trim() && !toolCalls.length) {
+        throw outputLimitError("openai", model);
+    }
     return {
-        text: texts.join(""),
+        text,
         ...(toolCalls.length ? { toolCalls } : {}),
         tokensIn: Number(usage?.input_tokens ?? 0),
         tokensOut: Number(usage?.output_tokens ?? 0),
@@ -182,25 +189,19 @@ export class OpenAiProvider {
         }
     }
     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());
+        let current = request;
+        for (;;) {
+            const response = await this.post(responsesBody(this.model, current));
+            if (response.ok) {
+                return parseResponsesBody((await response.json()), this.model);
             }
-            throw openAiError(this.model, response.status, detail);
-        }
-        if (!response.ok) {
-            throw openAiError(this.model, response.status, await response.text());
+            const detail = await response.text();
+            const lighter = response.status === 400
+                ? withoutRefusedPart(current, detail, /text\.format|json_schema|structured/i)
+                : undefined;
+            if (!lighter)
+                throw openAiError(this.model, response.status, detail);
+            current = lighter;
         }
-        return parseResponsesBody((await response.json()), this.model);
     }
 }

package/dist/src/ai/openrouter.js

@@ -1,4 +1,4 @@
-import { chatBody, parseChatResponse } from "./provider.js";
+import { chatBody, parseChatResponse, withoutRefusedPart } 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
@@ -75,25 +75,19 @@ export class OpenRouterProvider {
         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
-        // only a hint — the prompt also asks for a fenced JSON block — so one
-        // 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)) {
-                const { responseFormat: _dropped, ...withoutSchema } = request;
-                response = await this.post(chatBody(this.model, withoutSchema));
-                if (response.ok) {
-                    return parseChatResponse((await response.json()), this.host.provider, this.model);
-                }
-                throw this.fail(response.status, await response.text());
+        let current = request;
+        for (;;) {
+            const response = await this.post(chatBody(this.model, current));
+            if (response.ok) {
+                return parseChatResponse((await response.json()), this.host.provider, this.model);
             }
-            throw this.fail(response.status, detail);
-        }
-        if (!response.ok) {
-            throw this.fail(response.status, await response.text());
+            const detail = await response.text();
+            const lighter = response.status === 400
+                ? withoutRefusedPart(current, detail, /response_format|json_schema|structured/i)
+                : undefined;
+            if (!lighter)
+                throw this.fail(response.status, detail);
+            current = lighter;
         }
-        return parseChatResponse((await response.json()), this.host.provider, this.model);
     }
 }

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

@@ -7,5 +7,14 @@ export { providerKeyEnv } from "../config.ts";
 /** 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;
+/** A 400 that names one optional part of the request earns one retry without
+ * it: the JSON schema, which the prompt asks for anyway, or "thinking off",
+ * which a model that always thinks refuses. Undefined when nothing is left to
+ * drop, so the caller reports the error. */
+export declare function withoutRefusedPart(request: AiRequest, detail: string, schemaPattern: RegExp): AiRequest | undefined;
+/** The model stopped at its output limit before writing a word. Thinking counts
+ * toward that limit, so a thinking model can spend all of it there. Without
+ * this the empty answer read as a normal one and failed later as "not JSON". */
+export declare function outputLimitError(provider: string, model: string): Error;
 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

@@ -38,6 +38,28 @@ export function createAiProvider(options, model) {
     }
     die(`${options.ai} support is not finished yet. Use openrouter or none.`);
 }
+/** A 400 that names one optional part of the request earns one retry without
+ * it: the JSON schema, which the prompt asks for anyway, or "thinking off",
+ * which a model that always thinks refuses. Undefined when nothing is left to
+ * drop, so the caller reports the error. */
+export function withoutRefusedPart(request, detail, schemaPattern) {
+    if (request.responseFormat && schemaPattern.test(detail)) {
+        const { responseFormat: _dropped, ...rest } = request;
+        return rest;
+    }
+    if (request.reasoningEffort === "none" &&
+        /reasoning|effort|thinking/i.test(detail)) {
+        const { reasoningEffort: _dropped, ...rest } = request;
+        return rest;
+    }
+    return undefined;
+}
+/** The model stopped at its output limit before writing a word. Thinking counts
+ * toward that limit, so a thinking model can spend all of it there. Without
+ * this the empty answer read as a normal one and failed later as "not JSON". */
+export function outputLimitError(provider, model) {
+    return new Error(`${provider} model ${model} reached its output limit before writing an answer. Thinking counts toward that limit.`);
+}
 export function parseChatResponse(json, provider, model) {
     const choice = Array.isArray(json.choices)
         ? json.choices[0]
@@ -61,8 +83,14 @@ export function parseChatResponse(json, provider, model) {
         })
             .filter((call) => call.id && call.function.name)
         : undefined;
+    const text = String(message?.content ?? "");
+    if (choice?.finish_reason === "length" &&
+        !text.trim() &&
+        !toolCalls?.length) {
+        throw outputLimitError(provider, model);
+    }
     return {
-        text: String(message?.content ?? ""),
+        text,
         ...(toolCalls?.length ? { toolCalls } : {}),
         tokensIn: Number(usage?.prompt_tokens ?? 0),
         tokensOut: Number(usage?.completion_tokens ?? 0),

package/dist/src/cli/args.js

@@ -1,4 +1,4 @@
-import { prepareConfig } from "../config.js";
+import { prepareConfig, savedTokenFor } from "../config.js";
 import { getEnv } from "../util/runtime.js";
 import { askLine } from "./prompt.js";
 import { die } from "./error.js";
@@ -211,7 +211,7 @@ export async function parseArgs(args) {
     let aiToken = text("token") ??
         env("CO_MAINTAINER_TOKEN") ??
         providerKeyEnv(ai, env) ??
-        config.token;
+        savedTokenFor(config, ai);
     // 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;

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", "remoteByok", "remoteByokDefault", "reviewPolicy"];
+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", "remoteByokPolicy", "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

@@ -49,6 +49,7 @@ export const ENV_BY_FIELD = {
     remoteHost: ["CM_REMOTE_HOST"],
     remoteToken: ["CM_REMOTE_TOKEN"],
     reviewBlocking: ["CO_MAINTAINER_REVIEW_BLOCKING"],
+    remoteByokPolicy: ["CM_REMOTE_BYOK_POLICY"],
 };
 /** Renders one field for people. A secret is masked; the password hash, which
  * nobody can use, only reports whether it is set. */
@@ -156,6 +157,7 @@ export const KNOWN_FIELDS = [
     "remoteToolOutputMaxChars",
     "remoteByok",
     "remoteByokDefault",
+    "remoteByokPolicy",
     "reviewPolicy",
 ];
 /** `co-maintainer config <sub> ...`. `set` is handled by runSet, which this

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

@@ -1,4 +1,4 @@
-import { readConfig, configPath, writeUserConfig } from "../../config.js";
+import { readConfig, configPath, savedKeyProvider, 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";
@@ -266,7 +266,16 @@ export async function runSet(args) {
     const effective = (field) => field in patch ? patch[field] : before[field];
     const effectiveAi = effective("ai");
     const effectiveToken = effective("token");
-    const effectiveHighModel = effective("highModel");
+    // The saved key and model belong to the saved provider. A switch without a
+    // new key would hand the old provider's key to the new one.
+    const previousAi = savedKeyProvider(before);
+    const switching = typeof patch.ai === "string" &&
+        patch.ai !== "none" &&
+        patch.ai !== previousAi;
+    if (switching && !("token" in patch) && before.token) {
+        die(`The saved key is for ${previousAi}. Pass --token= with the ${String(patch.ai)} key to switch providers.`);
+    }
+    const effectiveHighModel = switching && !("highModel" in patch) ? undefined : effective("highModel");
     const verifiers = {
         openrouter: verifyOpenRouter,
         openai: verifyOpenAi,

package/dist/src/cli/review_github.js

@@ -121,8 +121,9 @@ export function emitGithubOutput(input) {
  * printed on stderr, and the runner reads workflow commands from stderr too.
  * A line that would start one is given a prefix so it stays plain text. */
 export function neutralizeCommands(text) {
+    // The runner also ends a line at a bare carriage return.
     return text
-        .split("\n")
+        .split(/\r\n|\r|\n/)
         .map((line) => (line.trimStart().startsWith("::") ? `[log] ${line}` : line))
         .join("\n");
 }

package/dist/src/config.d.ts

@@ -93,10 +93,6 @@ export type UserConfig = {
     repos?: Record<string, RepoConfig>;
 };
 export type ByokPolicy = "off" | "allow" | "require";
-/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
- * overrides the saved config, so a hosted server cannot be talked out of its
- * policy by a config edit. An unset or unreadable value falls back to the
- * config, then to `off`. */
 /** 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;
@@ -105,8 +101,19 @@ export declare function providerKeyEnv(ai: string, env?: (name: string) => strin
  * then the saved key. Without this a server started with the key in its
  * environment reported AI as not configured and failed every job. */
 export declare function resolvedAiToken(config: Pick<UserConfig, "ai" | "token">, ai?: string | undefined): string | undefined;
+/** The provider the saved key belongs to. A config from before providers
+ * were saved holds an OpenRouter key, and so does one where AI was switched
+ * off, which the dashboard writes for such a config. */
+export declare function savedKeyProvider(config: Pick<UserConfig, "ai">): string;
+/** The saved key belongs to the saved provider, so a run on any other
+ * provider never receives it. */
+export declare function savedTokenFor(config: Pick<UserConfig, "ai" | "token">, ai: string): string | undefined;
 /** True when a provider is chosen and a key reaches it from anywhere. */
 export declare function aiConfigured(config: Pick<UserConfig, "ai" | "token">): boolean;
+/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
+ * overrides the saved config, so a hosted server cannot be talked out of its
+ * policy by a config edit. An unset or unreadable value falls back to the
+ * config, then to `off`. */
 export declare function remoteByokPolicy(config?: Pick<UserConfig, "remoteByokPolicy">): ByokPolicy;
 /** Platform/env injection keeps the OS branches testable: the
  * migration's `"windows"` vs `"win32"` trap is invisible otherwise. */

package/dist/src/config.js

@@ -1,8 +1,4 @@
 import { chmod, currentPlatform, getEnv, isNotFound, mkdir, readTextFileSync, setEnv, writeTextFile, } from "./util/runtime.js";
-/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
- * overrides the saved config, so a hosted server cannot be talked out of its
- * policy by a config edit. An unset or unreadable value falls back to the
- * config, then to `off`. */
 /** 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 = getEnv) {
@@ -20,12 +16,27 @@ export function providerKeyEnv(ai, env = getEnv) {
 export function resolvedAiToken(config, ai = config.ai) {
     return (getEnv("CO_MAINTAINER_TOKEN") ??
         (ai ? providerKeyEnv(ai) : undefined) ??
-        config.token);
+        savedTokenFor(config, ai ?? "openrouter"));
+}
+/** The provider the saved key belongs to. A config from before providers
+ * were saved holds an OpenRouter key, and so does one where AI was switched
+ * off, which the dashboard writes for such a config. */
+export function savedKeyProvider(config) {
+    return config.ai && config.ai !== "none" ? config.ai : "openrouter";
+}
+/** The saved key belongs to the saved provider, so a run on any other
+ * provider never receives it. */
+export function savedTokenFor(config, ai) {
+    return savedKeyProvider(config) === ai ? config.token : undefined;
 }
 /** True when a provider is chosen and a key reaches it from anywhere. */
 export function aiConfigured(config) {
     return Boolean(config.ai && config.ai !== "none" && resolvedAiToken(config));
 }
+/** Who pays for a remote review's AI calls. `CM_REMOTE_BYOK_POLICY`
+ * overrides the saved config, so a hosted server cannot be talked out of its
+ * policy by a config edit. An unset or unreadable value falls back to the
+ * config, then to `off`. */
 export function remoteByokPolicy(config = readConfig()) {
     // An env value that is not one of the three known policies is treated as
     // unreadable and falls back to the config, so a typo cannot silently turn a

package/dist/src/knowledge/synthesis.js

@@ -157,6 +157,9 @@ function extractRequest(prompt, maxTokens) {
         job: "extract_unit",
         prompt,
         maxTokens,
+        // Pulling facts out of a text needs no thinking, and on a thinking model
+        // the thinking used the whole limit and left the answer empty.
+        reasoningEffort: "none",
         system: "Extract only repository-specific facts. Never invent files, commands, or process.",
     };
 }

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

@@ -1,6 +1,6 @@
 import { errorResponse } from "../errors.js";
 import { readConfig, resolveAppPrivateKey, writeUserConfig, } from "../../config.js";
-import { aiConfigured } from "../../config.js";
+import { aiConfigured, savedKeyProvider, } from "../../config.js";
 import { testAppAccess, testGithubAccess } from "../../services/credentials.js";
 import { checkPassword, readSessionToken, revokeOtherSessions, } from "../auth.js";
 import { passwordProblem } from "../../util/password.js";
@@ -99,6 +99,21 @@ export async function handleSettingsRoute(request, url, webhookUrl, passwords, i
         text("githubOAuthClientId");
         text("githubOAuthClientSecret");
         text("githubOAuthAllowedUser");
+        const previousAi = savedKeyProvider(current);
+        if (patch.ai &&
+            patch.ai !== "none" &&
+            patch.ai !== previousAi &&
+            !patch.token &&
+            current.token) {
+            return errorResponse(422, "key_for_other_provider", `The saved key is for ${previousAi}. Enter the ${patch.ai} key to switch providers.`);
+        }
+        if ("remoteByokPolicy" in body) {
+            const policy = body.remoteByokPolicy;
+            if (policy !== "off" && policy !== "allow" && policy !== "require") {
+                return errorResponse(422, "invalid_setting", "remoteByokPolicy must be off, allow or require");
+            }
+            patch.remoteByokPolicy = policy;
+        }
         if (typeof body.passwordAuthDisabled === "boolean") {
             patch.passwordAuthDisabled = body.passwordAuthDisabled;
         }

package/dist/src/services/review.js

@@ -21,6 +21,7 @@ import { getReviewByJobId, insertReview, latestPostedReview, setReviewScope, set
 import { insertFinding, listCarryableFindingsForReview, listFindingsForPr, listFindingsForReview, setFindingPosted, } from "../store/findings.js";
 import { getOrCreatePrSubject, getSubjectRevision, parseRevisionFiles, parseVisiblePaths, saveSubjectRevision, } from "../store/subjects.js";
 import { enqueue, registerHandler } from "./jobs.js";
+import { requestedReviewBlocked } from "./webhook.js";
 import { getEnv } from "../util/runtime.js";
 const ACCESS_DENIED_BODY = "The App does not have access to review this pull request.";
 export function humanCopy(text) {
@@ -460,6 +461,14 @@ async function runReviewJobCore(job, log, client, ai) {
     }
     const options = reviewOptions(job.repo, job.pr_number);
     const args = JSON.parse(job.args || "{}");
+    const pr = await github.request(`repos/${job.repo}/pulls/${job.pr_number}`);
+    if (args.trigger === "request-comment" && !existing) {
+        const blocked = requestedReviewBlocked(job.repo, pr);
+        if (blocked) {
+            log("info", `the review request was not run: ${blocked}`);
+            return;
+        }
+    }
     // A maintainer asked for this review by label or comment: acknowledge it.
     // Best effort, a missing reaction must never fail the review itself.
     if (args.requestReaction && !existing) {
@@ -470,7 +479,6 @@ async function runReviewJobCore(job, log, client, ai) {
             log("info", `could not react to the review request: ${String(error)}`);
         }
     }
-    const pr = await github.request(`repos/${job.repo}/pulls/${job.pr_number}`);
     const headSha = String(pr.head?.sha ?? "");
     const mergeBase = String(pr.base?.sha ?? "");
     let scope = args.scope === "incremental" ? "incremental" : "whole-pr";

package/dist/src/services/webhook.d.ts

@@ -18,6 +18,12 @@ export type WebhookResult = {
     prNumber?: number;
     jobId?: string;
 };
+/** A comment request is decided from the issue payload, which says nothing
+ * about the fork, the target branch or the size. The review job asks again
+ * with the pull request it fetched, so a comment can never get past the size
+ * cap or a rule that a label request would hit. Returns why the review must
+ * not run, or undefined. */
+export declare function requestedReviewBlocked(repo: string, pr: Record<string, unknown>): string | undefined;
 export declare function maybeEnqueueReview(input: {
     repo: string;
     prNumber: number;

package/dist/src/services/webhook.js

@@ -99,6 +99,30 @@ function pullRequestFacts(pr, repo) {
         targetBranch: asString(asRecord(pr?.base)?.ref),
     };
 }
+/** A comment request is decided from the issue payload, which says nothing
+ * about the fork, the target branch or the size. The review job asks again
+ * with the pull request it fetched, so a comment can never get past the size
+ * cap or a rule that a label request would hit. Returns why the review must
+ * not run, or undefined. */
+export function requestedReviewBlocked(repo, pr) {
+    const row = getRepo(repo);
+    if (!row || row.active !== 1)
+        return "repo-not-active";
+    const config = readConfig();
+    const maxDiffLines = config.repos?.[repo]?.maxPullRequestChangeLines ??
+        config.defaults?.maxPullRequestChangeLines;
+    const changedLines = (asNumber(pr.additions) ?? 0) + (asNumber(pr.deletions) ?? 0);
+    if (maxDiffLines !== undefined && changedLines > maxDiffLines) {
+        return "diff-too-large";
+    }
+    const decision = evaluatePolicy(policyForRepo(row), {
+        ...pullRequestFacts(pr, repo),
+        draft: asBool(pr.draft),
+        bot: isBot(asRecord(pr.user)),
+        changedLines,
+    });
+    return decision.action === "skip" ? decision.reason : undefined;
+}
 export function maybeEnqueueReview(input) {
     const row = getRepo(input.repo);
     if (!row || row.active !== 1) {

package/dist/src/store/backup.js

@@ -7,7 +7,13 @@
  * version only. Data written after the upgrade is lost by design. */
 import { Database } from "./sqlite.js";
 import { CliError, EXIT_USAGE } from "../cli/error.js";
-import { isNotFound, mkdir, readFile, readTextFile, remove, rename, stat, writeFile, writeTextFile, } from "../util/runtime.js";
+import { chmod, isNotFound, mkdir, readFile, readTextFile, remove, rename, stat, writeFile, writeTextFile, } from "../util/runtime.js";
+// config.json holds the AI key, the PAT and the App key, so a copy of it is as
+// private as the original. Windows has no POSIX modes.
+async function writePrivate(path, data) {
+    await writeFile(path, data);
+    await chmod(path, 0o600).catch(() => { });
+}
 const slot = (paths) => `${paths.root}/previous`;
 export const rolledBackDir = (paths) => `${paths.root}/rolled-back`;
 async function exists(path) {
@@ -37,6 +43,7 @@ export async function takeBackup(paths, versions) {
     const temp = `${slot(paths)}.tmp`;
     await remove(temp, { recursive: true }).catch(() => { });
     await mkdir(temp, { recursive: true });
+    await chmod(temp, 0o700).catch(() => { });
     const files = ["app.db"];
     copyDatabase(paths.appDb, `${temp}/app.db`);
     if (await exists(paths.cacheDb)) {
@@ -44,7 +51,7 @@ export async function takeBackup(paths, versions) {
         files.push("cache.db");
     }
     if (await exists(paths.config)) {
-        await writeFile(`${temp}/config.json`, await readFile(paths.config));
+        await writePrivate(`${temp}/config.json`, await readFile(paths.config));
         files.push("config.json");
     }
     const manifest = {
@@ -144,7 +151,7 @@ export async function restoreBackup(paths) {
         "config.json": paths.config,
     };
     for (const file of manifest.files) {
-        await writeFile(destinations[file], await readFile(`${slot(paths)}/${file}`));
+        await writePrivate(destinations[file], await readFile(`${slot(paths)}/${file}`));
     }
     // The version marker must match the data again, or the next upgrade would
     // record the wrong version to go back to.

package/package.json

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