@quickchatai/pi-quickreview 0.0.0-stage → 1.2.0

package/dist/src/reviewconfig.js

@@ -0,0 +1,805 @@
+// The review config: the config.toml sections the review core reads, their
+// defaults and their parsers. The schema of every other surface (ops,
+// ingress, Slack, TUI, companion, memory, archive, …) and the install's homes
+// stay in src/config.ts, which re-exports everything here and parses the
+// whole file through these same section parsers.
+//
+// `parseCoreConfig` reads just these sections: what a one-shot review needs,
+// with no install home, no secrets lookup and no app section. Where a caller
+// wants the located secrets dir or a deprecation said, it does that itself.
+import { parse } from "smol-toml";
+import { globProblem } from "./glob.js";
+import { INTENT_MIN_SUBSTANCE_WORDS, PLACEMENT_MIN_NEW_FILE_LINES, PLACEMENT_MIN_PROD_FILES, QUALITY_MIN_ADDED_LINES, SWEEP_MAX_FILES_PER_GROUP, SWEEP_MAX_LINES_PER_GROUP, SWEEP_WIDE_FILES_PER_GROUP, } from "./heuristics.js";
+import { ALL_PASSES, SCAN_DEEP_FLOOR_LENSES, SCAN_DEEP_LENSES } from "./passes.js";
+import { PASS_TIER_ORDER } from "./types.js";
+export const GITHUB_AUTH_MODES = ["app", "user"];
+export const GUARDS_DEFAULTS = {
+    downgrade_on_human_approval: true,
+    skip_unchanged_head: true,
+    recheck_pr_state_before_post: true,
+    block_approve_on_red_ci: true,
+    no_checks_is_red: false,
+    refuse_on_head_drift: true,
+};
+export const REVIEW_DIRECTIVES_DEFAULTS = {
+    extra_vendored_segments: [],
+    extra_basenames: [],
+    extra_dir_segments: [],
+    extra_root_dirs: [],
+    extra_files: [],
+};
+/** The lean lever plan — `default` and `low` share it. Its thresholds are the
+ * selection's own defaults (packages/pi-plugin/src/heuristics.ts), named once there. */
+const LEAN_LEVERS = {
+    sublenses: true,
+    sweep: true,
+    sweep_max_groups: 6,
+    // 8 files, so the 500-line budget binds first on most groups: a 5-file cap
+    // cut nearly half the sweep rows at a median of 78 changed lines, and 8
+    // plans ~17% fewer rows with none unswept.
+    sweep_group_files: SWEEP_MAX_FILES_PER_GROUP,
+    sweep_group_lines: SWEEP_MAX_LINES_PER_GROUP,
+    sweep_wide_files: SWEEP_WIDE_FILES_PER_GROUP,
+    behaviour_delta: true,
+    behaviour_delta_max_groups: 3,
+    loosened_test_hint: true,
+    intent_min_words: INTENT_MIN_SUBSTANCE_WORDS,
+    placement_min_code_files: PLACEMENT_MIN_PROD_FILES,
+    placement_min_new_file_lines: PLACEMENT_MIN_NEW_FILE_LINES,
+    dependency_sources: true,
+    tests_lens: true,
+    quality_lenses: true,
+    quality_min_added_lines: QUALITY_MIN_ADDED_LINES,
+    style_lens: true,
+    lint_conformance: true,
+};
+export const REVIEW_PRESETS = {
+    default: { effort: "", levers: LEAN_LEVERS },
+    low: { effort: "low", levers: LEAN_LEVERS },
+    max: {
+        effort: "high",
+        levers: {
+            ...LEAN_LEVERS,
+            sweep_max_groups: 8,
+            sweep_group_files: 3,
+            sweep_group_lines: 400,
+            behaviour_delta_max_groups: 4,
+            intent_min_words: 20,
+            placement_min_code_files: 4,
+            placement_min_new_file_lines: 0,
+        },
+    },
+};
+export function parsePreset(raw) {
+    const v = String(raw ?? "default")
+        .trim()
+        .toLowerCase();
+    if (v === "low" || v === "default" || v === "max")
+        return v;
+    throw new Error(`config.toml [review] preset must be "low", "default" or "max" (got "${v}")`);
+}
+export const REVIEW_DEFAULTS = {
+    escalation_mention_default: "",
+    profile: "",
+    directives: REVIEW_DIRECTIVES_DEFAULTS,
+    preset: "default",
+    ...LEAN_LEVERS,
+    nits: "strict",
+    validate_demote: true,
+    skip_lenses: [],
+    validate_consequence_rule: false,
+    wide_lens_fanout: true,
+    task_files: true,
+    render_outputs: true,
+    validator_shards: 1,
+    dedup_merge: true,
+    coverage_check: true,
+    follow_up: "delta",
+    follow_up_max_delta_ratio: 0.6,
+    follow_up_sweep: true,
+    follow_up_post_approval_sweep_lines: 500,
+    follow_up_small_delta_lines: 150,
+    baseline_split_lines: 2000,
+    context_pack: "pack-first",
+    context_pack_max_tokens: 40000,
+    sweep_light_tier: "",
+    validate_compact: true,
+    follow_up_extent: "session",
+};
+export const ESCALATION_RULE_DEFAULTS = {
+    name: "",
+    to: "",
+    why: "",
+    paths: [],
+    labels: [],
+    min_severity: "",
+    failing_checks: [],
+};
+export const ESCALATION_DEFAULTS = {
+    enabled: false,
+    shape: "comment",
+    targets: [],
+    session_judgement: false,
+    max_per_pr: 2,
+    rules: [],
+};
+export const ESCALATION_SEVERITY_FLOORS = ["P0", "P1", "P2", "P3"];
+/** A GitHub login: letters, digits and single inner dashes, at most 39. */
+export const ESCALATION_LOGIN_RE = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}$/;
+/**
+ * Parse and VALIDATE `[escalation]`.
+ *
+ * A half-configured live state is made unrepresentable here
+ * rather than only in the wizard: a config with the feature on and no target,
+ * or with a rule pointing at a login that is not a target, or with a rule that
+ * declares no condition, fails to LOAD. A hand-edited config gets the same
+ * refusal the interview does.
+ *
+ * With `enabled = false` NOTHING below the early return is checked, so a
+ * half-filled table that is switched off really is a draft — it cannot wedge
+ * daemon startup. The whole validation set fires the moment the operator
+ * flips the switch.
+ */
+export function parseEscalation(raw) {
+    const rawRules = Array.isArray(raw.rules) ? raw.rules : [];
+    const cfg = {
+        ...ESCALATION_DEFAULTS,
+        ...raw,
+        targets: (Array.isArray(raw.targets) ? raw.targets : [])
+            .map((t) => String(t).trim().replace(/^@/, ""))
+            .filter(Boolean),
+        rules: rawRules.map((r) => ({
+            ...ESCALATION_RULE_DEFAULTS,
+            ...r,
+            to: String(r.to ?? "")
+                .trim()
+                .replace(/^@/, ""),
+            name: String(r.name ?? "").trim(),
+            why: String(r.why ?? "").trim(),
+            paths: (Array.isArray(r.paths) ? r.paths : [])
+                .map((p) => String(p).trim())
+                .filter(Boolean),
+            labels: (Array.isArray(r.labels) ? r.labels : [])
+                .map((l) => String(l).trim())
+                .filter(Boolean),
+            failing_checks: (Array.isArray(r.failing_checks) ? r.failing_checks : [])
+                .map((c) => String(c).trim())
+                .filter(Boolean),
+            min_severity: String(r.min_severity ?? "")
+                .trim()
+                .toUpperCase(),
+        })),
+    };
+    // Switched off is a draft — checked FIRST, before any shape rule, because
+    // "draft" has to mean it. Nothing below
+    // this line is read while the feature is off, so a half-written rule an
+    // operator is still thinking about must not wedge daemon startup. Every one
+    // of these checks fires the moment they flip `enabled = true`, and the
+    // onboarding step runs the real parser over the text it is about to write,
+    // so a draft is never a way to smuggle a broken live config past validation.
+    if (!cfg.enabled)
+        return cfg;
+    if (cfg.shape !== "comment" && cfg.shape !== "review_request") {
+        throw new Error(`config.toml [escalation]: shape must be "comment" or "review_request" (got ${JSON.stringify(cfg.shape)})`);
+    }
+    if (!Number.isInteger(cfg.max_per_pr) || cfg.max_per_pr < 1) {
+        throw new Error(`config.toml [escalation]: max_per_pr must be a positive integer (got ${JSON.stringify(cfg.max_per_pr)})`);
+    }
+    for (const t of cfg.targets) {
+        if (!ESCALATION_LOGIN_RE.test(t)) {
+            throw new Error(`config.toml [escalation]: targets entry ${JSON.stringify(t)} is not a GitHub login`);
+        }
+    }
+    const seenNames = new Set();
+    for (const r of cfg.rules) {
+        if (!r.name)
+            throw new Error("config.toml [[escalation.rules]]: every rule needs a `name`");
+        if (seenNames.has(r.name))
+            throw new Error(`config.toml [[escalation.rules]]: duplicate rule name ${JSON.stringify(r.name)}`);
+        seenNames.add(r.name);
+        if (r.min_severity && !ESCALATION_SEVERITY_FLOORS.includes(r.min_severity)) {
+            throw new Error(`config.toml [[escalation.rules]] ${r.name}: min_severity must be P0, P1, P2 or P3 (got ${JSON.stringify(r.min_severity)})`);
+        }
+        if (r.paths.length + r.labels.length + r.failing_checks.length === 0 && !r.min_severity) {
+            throw new Error(`config.toml [[escalation.rules]] ${r.name}: declares no condition — it could never fire`);
+        }
+        if (!r.why)
+            throw new Error(`config.toml [[escalation.rules]] ${r.name}: needs a \`why\` saying why this person`);
+    }
+    if (cfg.targets.length === 0) {
+        throw new Error("config.toml [escalation]: enabled = true with no `targets` — escalation on with nobody to escalate to is not a configuration");
+    }
+    if (cfg.rules.length === 0 && !cfg.session_judgement) {
+        throw new Error("config.toml [escalation]: enabled = true with no rules and session_judgement = false — nothing could ever escalate");
+    }
+    for (const r of cfg.rules) {
+        if (!cfg.targets.includes(r.to)) {
+            throw new Error(`config.toml [[escalation.rules]] ${r.name}: to = ${JSON.stringify(r.to)} is not in [escalation] targets — every escalation target is declared once, in one place`);
+        }
+    }
+    return cfg;
+}
+export const OWNER_DEFAULTS = {
+    name: "",
+    slack_id: "",
+    github_login: "",
+};
+/** pi's thinking levels, ascending (pi 0.87.1, unchanged at 0.99.1 and 1.0.0 — VERIFY-ON-PIN). */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** "provider/model:thinking" → its model and its pi thinking level, or a
+ * null level when the spec carries no suffix. */
+export function splitModelSpec(spec) {
+    const m = new RegExp(`^(.+):(${THINKING_LEVELS.join("|")})$`).exec(spec);
+    return m ? { model: m[1], thinking: m[2] } : { model: spec, thinking: null };
+}
+/** Replace (or add) the `:thinking` suffix of one model spec. */
+export function withThinking(spec, level) {
+    return `${splitModelSpec(spec).model}:${level}`;
+}
+/** The thinking level an effort setting names: `high` is the model's
+ * ceiling (`[models] effort_max`) — the one reading of `[models] effort`, a
+ * lens's profile `effort` and `[scan] effort` alike. */
+export function effortLevel(effort, effortMax) {
+    return effort === "high" ? effortMax : effort;
+}
+/** Apply `[models] effort` to every spec the review runs on. Pure. */
+export function applyReviewEffort(models) {
+    if (models.effort === "")
+        return models;
+    const level = effortLevel(models.effort, models.effort_max);
+    const tiers = Object.fromEntries(Object.entries(models.tiers).map(([t, spec]) => [t, withThinking(spec, level)]));
+    return {
+        ...models,
+        default: withThinking(models.default, level),
+        conversation: withThinking(models.conversation, level),
+        tiers,
+    };
+}
+export function parseEffort(raw) {
+    const v = String(raw ?? "")
+        .trim()
+        .toLowerCase();
+    if (v === "")
+        return "";
+    const effort = normalizeEffort(v);
+    if (effort !== null)
+        return effort;
+    throw new Error(`config.toml [models] effort must be "", "low", "medium" or "high" (got "${v}")`);
+}
+/** The nonempty effort vocabulary every effort knob shares — `low`,
+ * `medium` (alias `med`) and `high`, case- and space-insensitive — or null for
+ * anything else. What an empty value means is each knob's own call. */
+export function normalizeEffort(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const v = raw.trim().toLowerCase();
+    if (v === "low" || v === "medium" || v === "high")
+        return v;
+    return v === "med" ? "medium" : null;
+}
+function parseEffortMax(raw) {
+    const v = String(raw ?? "max")
+        .trim()
+        .toLowerCase();
+    if (THINKING_LEVELS.includes(v) && v !== "off")
+        return v;
+    throw new Error(`config.toml [models] effort_max must be a pi thinking level (got "${v}")`);
+}
+/**
+ * The shipped per-lens tier pins (measured: high effort on these lenses found
+ * more defects with no high-severity loss, for ~18% more cost per PR). The
+ * three lenses that read the whole diff line by line run at
+ * the `sol-high` tier — gpt-6.1-sol at high effort — on every PR; every other
+ * lens keeps its planned tier. A config's own `[models.pass_tiers]` entry for
+ * one of them replaces its pin (e.g. `"pass-baseline" = "sol-med"`), and a
+ * profile lowers its thinking with `[lenses.<pass>] effort = "medium"`.
+ */
+export const DEFAULT_PASS_TIERS = Object.freeze({
+    "pass-baseline": "sol-high",
+    "pass-sweep": "sol-high",
+    "pass-behaviour-delta": "sol-high",
+});
+/** `[engine] lens_pass_deadline_min` when the file does not set it: a
+ * healthy pass takes 20-100 s and the slowest about 4 min, so 8 min only
+ * ever cuts a stalled one. */
+export const DEFAULT_LENS_PASS_DEADLINE_MIN = 8;
+/** `[engine] lens_cache_stagger_ms`'s default — every reader's fallback too
+ * (`packages/pi-plugin/src/engine/lens/env.ts` keeps the env reader's copy, pinned equal by a
+ * test). */
+export const DEFAULT_LENS_CACHE_STAGGER_MS = 2500;
+/** `[engine] lens_max_concurrency` when the file does not set it: the
+ * companion's desktop number. */
+export const DEFAULT_LENS_MAX_CONCURRENCY = 4;
+/** `[engine] lens_cache_group` when the file does not set it. */
+export const DEFAULT_LENS_CACHE_GROUP = 5;
+export const ENGINE_RUNTIME_KINDS = ["sdk"];
+export const LENS_RUNTIME_KINDS = ["engine"];
+export const ENGINE_DEFAULTS = {
+    runtime: "sdk",
+    lens_max_concurrency: DEFAULT_LENS_MAX_CONCURRENCY,
+    lens_cache_group: DEFAULT_LENS_CACHE_GROUP,
+    lens_cache_stagger_ms: DEFAULT_LENS_CACHE_STAGGER_MS,
+    lens_pass_deadline_min: DEFAULT_LENS_PASS_DEADLINE_MIN,
+};
+/** The `[pi]` lens default: the engine's planned wave is on. */
+function piLensDefaults() {
+    return { lens_runtime: "engine", engine_wave: true };
+}
+/** The `[pi]` keys that moved to `[engine]` and are refused where they stand. */
+const RETIRED_PI_KEYS = {
+    subagent_max_concurrency: "lens_max_concurrency",
+    subagent_cache_group: "lens_cache_group",
+    subagent_cache_stagger_ms: "lens_cache_stagger_ms",
+    subagent_pass_deadline_min: "lens_pass_deadline_min",
+};
+/** Refuse a value outside a closed set. A typo must not silently become the
+ * default runtime. */
+function oneOf(where, v, allowed) {
+    if (typeof v !== "string" || !allowed.includes(v))
+        throw new Error(`config.toml ${where} must be one of ${allowed.join(" | ")} (got ${JSON.stringify(v)})`);
+    return v;
+}
+export function parseEngine(raw) {
+    const e = { ...ENGINE_DEFAULTS, ...raw };
+    if (e.runtime === "proc")
+        throw new Error('config.toml [engine] runtime = "proc" is retired: pi runs in-process on the SDK (the one adapter); delete the key or set it to "sdk"');
+    const runtime = oneOf("[engine] runtime", e.runtime, ENGINE_RUNTIME_KINDS);
+    const whole = (key, min, max) => {
+        const v = e[key];
+        if (typeof v !== "number" || !Number.isInteger(v) || v < min || v > max)
+            throw new Error(`config.toml [engine] ${key} must be a whole number ${min}-${max} (got ${JSON.stringify(v)})`);
+        return v;
+    };
+    return {
+        runtime,
+        lens_max_concurrency: whole("lens_max_concurrency", 1, 64),
+        lens_cache_group: whole("lens_cache_group", 0, 1000),
+        lens_cache_stagger_ms: whole("lens_cache_stagger_ms", 0, 600_000),
+        lens_pass_deadline_min: whole("lens_pass_deadline_min", 0, 240),
+    };
+}
+/** Refuse the `[pi]` keys the lens settings left behind, naming where they went. */
+function refuseRetiredPiKeys(pi) {
+    for (const [key, to] of Object.entries(RETIRED_PI_KEYS))
+        if (key in pi)
+            throw new Error(`config.toml [pi] ${key} is retired with pi's native subagent glue: delete it, and set [engine] ${to} if the default does not suit`);
+}
+function parsePiLensRuntime(pi) {
+    if (pi.lens_runtime === "native")
+        throw new Error('config.toml [pi] lens_runtime = "native" is retired: pi\'s own subagent glue is gone and the engine\'s lens tool is the only one; delete the key or set it to "engine"');
+    oneOf("[pi] lens_runtime", pi.lens_runtime, LENS_RUNTIME_KINDS);
+    if (typeof pi.engine_wave !== "boolean")
+        throw new Error(`config.toml [pi] engine_wave must be true or false (got ${JSON.stringify(pi.engine_wave)})`);
+    // A wave only the engine route can launch: a typo must not run the main
+    // session's own launch while the config says the engine's.
+    if (pi.engine_wave && pi.lens_runtime !== "engine")
+        throw new Error('config.toml [pi] engine_wave = true needs lens_runtime = "engine"');
+    return pi;
+}
+/** Defaults for the tiered [models] knobs — older configs keep parsing. */
+export const MODELS_TIER_DEFAULTS = {
+    pass_tiers: { ...DEFAULT_PASS_TIERS },
+    pass_models: {},
+    effort: "",
+    effort_max: "max",
+    tiers: {
+        "terra-med": "openai-codex/gpt-6.1-sol:medium",
+        "sol-med": "openai-codex/gpt-6.1-sol:medium",
+        "sol-high": "openai-codex/gpt-6.1-sol:high",
+    },
+    risk_passes: ["pass-security", "pass-prod-risk", "pass-data-safety"],
+    validate_tier: "sol-high",
+    small_diff_lines: 150,
+    pricing: {},
+};
+/** The values `[memory] delivery` takes. */
+export const MEMORY_DELIVERY_MODES = ["off", "shadow", "on"];
+/** How hard a scan looks — `[scan] depth`. */
+export const SCAN_DEPTHS = ["standard", "deep"];
+export const SCAN_DEFAULTS = {
+    effort: "low",
+    tier: "sol-med",
+    validator: true,
+    exclude: [],
+    calibration_units: 3,
+    calibration_max_usd: 3,
+    concurrency: 8,
+    case_max_files: 30,
+    case_max_lines: 3000,
+    unmeasured_rate_factor: 4,
+    depth: "standard",
+    deep_lenses: [...SCAN_DEEP_FLOOR_LENSES],
+};
+/** The `[scan]` keys a repo profile may override — what is about THIS repo
+ * (how hard to look, whether to validate, what is not worth reading), never
+ * the install's operating limits. */
+export const SCAN_PROFILE_KEYS = [
+    "effort",
+    "tier",
+    "validator",
+    "exclude",
+    "depth",
+    "deep_lenses",
+];
+/**
+ * Validate one `[scan]` table — config.toml's (every key) or a profile's
+ * (`SCAN_PROFILE_KEYS` only). Returns just the keys it set; an unknown key or
+ * a bad value throws naming `where`.
+ */
+export function parseScanTable(where, raw, allowed = Object.keys(SCAN_DEFAULTS)) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error(`${where} [scan] must be a table`);
+    }
+    const out = {};
+    const fail = (key, what, v) => {
+        throw new Error(`${where} [scan] ${key} ${what} (got ${JSON.stringify(v)})`);
+    };
+    for (const [key, v] of Object.entries(raw)) {
+        if (!allowed.includes(key)) {
+            throw new Error(`${where} [scan] unknown key "${key}" — allowed here: ${allowed.join(", ")}`);
+        }
+        switch (key) {
+            case "effort": {
+                const e = normalizeEffort(v);
+                if (e)
+                    out.effort = e;
+                else
+                    fail(key, 'must be "low", "medium" or "high"', v);
+                break;
+            }
+            case "tier":
+                if (typeof v === "string" && PASS_TIER_ORDER.includes(v))
+                    out.tier = v;
+                else
+                    fail(key, `must be one of ${PASS_TIER_ORDER.join(", ")}`, v);
+                break;
+            case "validator":
+                if (typeof v === "boolean")
+                    out.validator = v;
+                else
+                    fail(key, "must be true or false", v);
+                break;
+            case "exclude": {
+                if (!Array.isArray(v))
+                    fail(key, "must be an array of globs", v);
+                for (const g of v) {
+                    const problem = globProblem(g);
+                    if (problem !== null)
+                        fail(key, `entry ${JSON.stringify(g)} ${problem}`, v);
+                }
+                out.exclude = [...v];
+                break;
+            }
+            case "calibration_max_usd":
+                if (typeof v === "number" && Number.isFinite(v) && v > 0)
+                    out.calibration_max_usd = v;
+                else
+                    fail(key, "must be a positive number of dollars", v);
+                break;
+            case "unmeasured_rate_factor":
+                if (typeof v === "number" && Number.isFinite(v) && v >= 1)
+                    out.unmeasured_rate_factor = v;
+                else
+                    fail(key, "must be a number of at least 1", v);
+                break;
+            case "depth":
+                if (typeof v === "string" && SCAN_DEPTHS.includes(v))
+                    out.depth = v;
+                else
+                    fail(key, `must be ${SCAN_DEPTHS.map((d) => `"${d}"`).join(" or ")}`, v);
+                break;
+            case "deep_lenses": {
+                if (!Array.isArray(v) || v.length === 0)
+                    fail(key, "must be a non-empty array of lens names", v);
+                for (const l of v) {
+                    if (typeof l !== "string" || !SCAN_DEEP_LENSES.includes(l))
+                        fail(key, `entry ${JSON.stringify(l)} is not a lens a scan can run (one of: ${SCAN_DEEP_LENSES.join(", ")})`, v);
+                }
+                out.deep_lenses = [...new Set(v)];
+                break;
+            }
+            default: {
+                // The integer knobs.
+                if (typeof v === "number" && Number.isInteger(v) && v >= 1) {
+                    out[key] = v;
+                }
+                else
+                    fail(key, "must be a positive integer", v);
+            }
+        }
+    }
+    return out;
+}
+/** The `[scan]` keys that say where a run is driven, not how it scans. */
+export const SCAN_SANDBOX_KEYS = ["sandbox", "pihome_volume", "image"];
+/** `[scan]` from config.toml: the defaults, overlaid by what it sets. The
+ * sandbox keys are parsed apart (`parseScanSandbox`). */
+export function parseScan(raw) {
+    const table = typeof raw === "object" && raw !== null && !Array.isArray(raw)
+        ? Object.fromEntries(Object.entries(raw).filter(([k]) => !SCAN_SANDBOX_KEYS.includes(k)))
+        : (raw ?? {});
+    return { ...SCAN_DEFAULTS, ...parseScanTable("config.toml", table) };
+}
+/** A key the table must have: its value, or a throw naming it. */
+export function req(obj, key) {
+    const v = obj[key];
+    if (v === undefined)
+        throw new Error(`config.toml: missing key '${key}'`);
+    return v;
+}
+/** The overseer session is gone: its two knobs are still ACCEPTED so a
+ * live config does not break, read by nothing, and named here once at parse. */
+export function configDeprecations(raw) {
+    const out = [];
+    if (raw.models?.overseer !== undefined)
+        out.push("config.toml [models] overseer is deprecated and ignored: the overseer session was deleted. Remove the key.");
+    if (raw.daemon?.overseer_rotation_days !== undefined)
+        out.push("config.toml [daemon] overseer_rotation_days is deprecated and ignored: the overseer session was deleted. Remove the key.");
+    return out;
+}
+export function parseModels(raw, presetEffort = "") {
+    return applyReviewEffort({
+        // `[models] effort` set explicitly wins over the preset's level.
+        effort: raw.effort !== undefined ? parseEffort(raw.effort) : presetEffort,
+        effort_max: parseEffortMax(raw.effort_max),
+        default: String(req(raw, "default")),
+        conversation: String(req(raw, "conversation")),
+        tiers: {
+            ...MODELS_TIER_DEFAULTS.tiers,
+            ...(raw.tiers ?? {}),
+        },
+        risk_passes: (raw.risk_passes ?? MODELS_TIER_DEFAULTS.risk_passes),
+        validate_tier: (raw.validate_tier ?? MODELS_TIER_DEFAULTS.validate_tier),
+        small_diff_lines: Number(raw.small_diff_lines ?? MODELS_TIER_DEFAULTS.small_diff_lines),
+        pricing: (raw.pricing ?? {}),
+        pass_tiers: { ...DEFAULT_PASS_TIERS, ...(raw.pass_tiers ?? {}) },
+        pass_models: { ...(raw.pass_models ?? {}) },
+    });
+}
+/**
+ * Validate the per-lens knobs — `[review] skip_lenses`,
+ * `[review] validate_consequence_rule`, `[models.pass_tiers]` and
+ * `[models.pass_models]`. Called by
+ * `parseConfig` and again by the bench's `--config` overrides (which write
+ * past the parser), so both routes refuse the same things.
+ */
+export function validateLensKnobs(cfg) {
+    const known = new Set(ALL_PASSES);
+    const skip = cfg.review.skip_lenses ?? [];
+    if (!Array.isArray(skip) || skip.some((s) => typeof s !== "string"))
+        throw new Error(`config.toml [review] skip_lenses must be an array of pass names (got ${JSON.stringify(skip)})`);
+    for (const s of skip) {
+        if (s === "pass-validate")
+            throw new Error("config.toml [review] skip_lenses may not name pass-validate — switch the validator off in the profile ([lenses.pass-validate] enabled = false)");
+        if (!known.has(s))
+            throw new Error(`config.toml [review] skip_lenses: unknown pass "${s}"`);
+    }
+    if (cfg.review.validate_consequence_rule !== undefined &&
+        typeof cfg.review.validate_consequence_rule !== "boolean")
+        throw new Error(`config.toml [review] validate_consequence_rule must be true or false (got ${JSON.stringify(cfg.review.validate_consequence_rule)})`);
+    if (!PASS_TIER_ORDER.includes(cfg.models.validate_tier))
+        throw new Error(`config.toml [models] validate_tier: unknown tier ${JSON.stringify(cfg.models.validate_tier)} (one of ${PASS_TIER_ORDER.join(", ")})`);
+    const pins = cfg.models.pass_tiers ?? {};
+    if (typeof pins !== "object" || pins === null || Array.isArray(pins))
+        throw new Error("config.toml [models.pass_tiers] must be a table of pass = tier");
+    const risk = new Set(cfg.models.risk_passes ?? []);
+    if (risk.has("pass-validate"))
+        throw new Error("config.toml [models] risk_passes may not name pass-validate — use validate_tier");
+    for (const [pass, tier] of Object.entries(pins)) {
+        if (!known.has(pass))
+            throw new Error(`config.toml [models.pass_tiers]: unknown pass "${pass}"`);
+        if (pass === "pass-validate")
+            throw new Error("config.toml [models.pass_tiers] may not pin pass-validate — use [models] validate_tier");
+        if (risk.has(pass))
+            throw new Error(`config.toml [models.pass_tiers]: ${pass} is a risk pass (always sol-high) — remove it from [models] risk_passes first`);
+        if (!PASS_TIER_ORDER.includes(tier))
+            throw new Error(`config.toml [models.pass_tiers] ${pass}: unknown tier ${JSON.stringify(tier)} (one of ${PASS_TIER_ORDER.join(", ")})`);
+    }
+    const moved = cfg.models.pass_models ?? {};
+    if (typeof moved !== "object" || moved === null || Array.isArray(moved))
+        throw new Error("config.toml [models.pass_models] must be a table of pass = model spec");
+    for (const [pass, model] of Object.entries(moved)) {
+        if (!known.has(pass))
+            throw new Error(`config.toml [models.pass_models]: unknown pass "${pass}"`);
+        if (pass === "pass-validate")
+            throw new Error("config.toml [models.pass_models] may not move pass-validate — the validator's model is its tier's");
+        if (risk.has(pass))
+            throw new Error(`config.toml [models.pass_models]: ${pass} is a risk pass — it always runs on the sol-high tier's model`);
+        if (typeof model !== "string" || !/^[\w.-]+\/[\w.:-]+$/.test(model))
+            throw new Error(`config.toml [models.pass_models] ${pass}: ${JSON.stringify(model)} is not a "provider/model[:thinking]" spec`);
+    }
+}
+/** Full model spec ("provider/model:thinking") for a pass tier. */
+export function tierModel(cfg, tier) {
+    return cfg.models.tiers[tier];
+}
+/** `[github]`: base_branch/clone_dir default so older configs keep parsing.
+ * `secrets_dir` is as written; the reader that needs the secrets locates
+ * them (src/homes.ts `locateSecrets`). */
+export function parseGithubSection(raw) {
+    const given = req(raw, "github");
+    const auth = given.auth ?? "app";
+    if (!GITHUB_AUTH_MODES.includes(auth))
+        throw new Error(`config.toml [github]: auth must be "app" or "user" (got ${JSON.stringify(auth)})`);
+    return {
+        base_branch: "main",
+        clone_dir: "",
+        // No App under the person's own credential: its slug may be left out.
+        ...(auth === "user" ? { app_slug: "" } : {}),
+        ...given,
+        auth,
+    };
+}
+/** The `[github]` keys every config names. */
+const REQUIRED_GITHUB_KEYS = [
+    "repo",
+    "app_slug",
+    "bot_login",
+    "review_team",
+    "trigger_label",
+    "in_progress_label",
+    "reviewed_label",
+    "improvement_label",
+    "issue_label",
+];
+/** Refuse a `[github]` table that leaves out a key every config names. */
+export function requireGithubKeys(github) {
+    for (const k of REQUIRED_GITHUB_KEYS)
+        req(github, k);
+}
+/** `[review] preset`. It shapes both [models] (reasoning level) and [review]
+ * (the levers), so it is read before either is parsed. */
+export function presetOf(raw) {
+    return parsePreset(raw.review?.preset);
+}
+/** `[pi]`, with the lens runtime defaulted and checked and the retired keys refused. */
+export function parsePiSection(raw) {
+    const pi = req(raw, "pi");
+    refuseRetiredPiKeys(pi);
+    return parsePiLensRuntime({
+        ...piLensDefaults(),
+        ...pi,
+    });
+}
+/** `[guards]` over its defaults. */
+export function parseGuardsSection(raw) {
+    return { ...GUARDS_DEFAULTS, ...(raw.guards ?? {}) };
+}
+/** `[owner]` over its defaults (the legacy Slack alias folds in later,
+ * `foldLegacyOwnerSlackId`). */
+export function parseOwnerSection(raw) {
+    return { ...OWNER_DEFAULTS, ...(raw.owner ?? {}) };
+}
+/** `[review]`. [review.directives] merges under its own spread so a partial
+ * table extends the defaults instead of clobbering the sibling keys. The
+ * preset fills every lever the file does not set itself; an explicit key
+ * always wins, so `preset = "max"` + `sweep = false` means exactly that. */
+export function parseReviewSection(raw, preset) {
+    return {
+        ...REVIEW_DEFAULTS,
+        ...REVIEW_PRESETS[preset].levers,
+        ...(raw.review ?? {}),
+        preset,
+        directives: {
+            ...REVIEW_DIRECTIVES_DEFAULTS,
+            ...(raw.review?.directives ??
+                {}),
+        },
+    };
+}
+/** The checks on a parsed `[review]` (and the per-lens knobs), run once the
+ * whole config is built. */
+export function validateReviewSection(cfg) {
+    validateLensKnobs(cfg);
+    const shards = cfg.review.validator_shards;
+    if (!Number.isInteger(shards) || shards < 1 || shards > 4) {
+        throw new Error(`config.toml [review]: validator_shards must be an integer 1-4 (got ${JSON.stringify(shards)})`);
+    }
+    if (typeof cfg.review.loosened_test_hint !== "boolean") {
+        throw new Error(`config.toml [review]: loosened_test_hint must be true or false (got ${JSON.stringify(cfg.review.loosened_test_hint)})`);
+    }
+    if (typeof cfg.review.coverage_check !== "boolean") {
+        throw new Error(`config.toml [review]: coverage_check must be true or false (got ${JSON.stringify(cfg.review.coverage_check)})`);
+    }
+    if (typeof cfg.review.dedup_merge !== "boolean") {
+        throw new Error(`config.toml [review]: dedup_merge must be true or false (got ${JSON.stringify(cfg.review.dedup_merge)})`);
+    }
+    if (cfg.review.follow_up !== "delta" && cfg.review.follow_up !== "full") {
+        throw new Error(`config.toml [review]: follow_up must be "delta" or "full" (got ${JSON.stringify(cfg.review.follow_up)})`);
+    }
+    {
+        const ratio = cfg.review.follow_up_max_delta_ratio;
+        if (!(typeof ratio === "number" && Number.isFinite(ratio) && ratio > 0 && ratio <= 1)) {
+            throw new Error(`config.toml [review]: follow_up_max_delta_ratio must be a number in (0, 1] (got ${JSON.stringify(ratio)})`);
+        }
+    }
+    if (typeof cfg.review.follow_up_sweep !== "boolean") {
+        throw new Error(`config.toml [review]: follow_up_sweep must be true or false (got ${JSON.stringify(cfg.review.follow_up_sweep)})`);
+    }
+    {
+        const n = cfg.review.follow_up_post_approval_sweep_lines;
+        if (!(typeof n === "number" && Number.isInteger(n) && n >= 0)) {
+            throw new Error(`config.toml [review]: follow_up_post_approval_sweep_lines must be a whole number >= 0 (got ${JSON.stringify(n)})`);
+        }
+    }
+    {
+        const n = cfg.review.baseline_split_lines;
+        if (!(typeof n === "number" && Number.isInteger(n) && n >= 0)) {
+            throw new Error(`config.toml [review]: baseline_split_lines must be a whole number >= 0 (got ${JSON.stringify(n)})`);
+        }
+    }
+    if (cfg.review.sweep_light_tier !== "" &&
+        !PASS_TIER_ORDER.includes(cfg.review.sweep_light_tier)) {
+        throw new Error(`config.toml [review]: sweep_light_tier must be "" or a tier (${PASS_TIER_ORDER.join(", ")}) (got ${JSON.stringify(cfg.review.sweep_light_tier)})`);
+    }
+    if (cfg.review.follow_up_extent !== "session" && cfg.review.follow_up_extent !== "rules") {
+        throw new Error(`config.toml [review]: follow_up_extent must be "session" or "rules" (got ${JSON.stringify(cfg.review.follow_up_extent)})`);
+    }
+    if (typeof cfg.review.validate_compact !== "boolean") {
+        throw new Error(`config.toml [review]: validate_compact must be true or false (got ${JSON.stringify(cfg.review.validate_compact)})`);
+    }
+    if (cfg.review.context_pack !== "off" && cfg.review.context_pack !== "pack-first") {
+        throw new Error(`config.toml [review]: context_pack must be "off" or "pack-first" (got ${JSON.stringify(cfg.review.context_pack)})`);
+    }
+    for (const [key, n, min] of [
+        ["[review] context_pack_max_tokens", cfg.review.context_pack_max_tokens, 1000],
+    ]) {
+        if (!(typeof n === "number" && Number.isInteger(n) && n >= min))
+            throw new Error(`config.toml ${key} must be a whole number >= ${min} (got ${JSON.stringify(n)})`);
+    }
+    {
+        const n = cfg.review.follow_up_small_delta_lines;
+        if (!(typeof n === "number" && Number.isInteger(n) && n >= 0)) {
+            throw new Error(`config.toml [review]: follow_up_small_delta_lines must be a whole number >= 0 (got ${JSON.stringify(n)})`);
+        }
+    }
+    if (cfg.review.nits !== "strict" && cfg.review.nits !== "open") {
+        throw new Error(`config.toml [review]: nits must be "strict" or "open" (got ${JSON.stringify(cfg.review.nits)})`);
+    }
+}
+/** Legacy alias: a set `[slack] legacy_owner_slack_id` feeds [owner] slack_id when
+ * that is empty; a conflicting pair is an error that names the NEW key. After
+ * this fold nothing reads the legacy key. */
+export function foldLegacyOwnerSlackId(raw, owner) {
+    const legacyOwnerSlackId = String(raw.slack?.legacy_owner_slack_id ?? "").trim();
+    if (legacyOwnerSlackId) {
+        if (!owner.slack_id.trim()) {
+            owner.slack_id = legacyOwnerSlackId;
+        }
+        else if (owner.slack_id.trim() !== legacyOwnerSlackId) {
+            throw new Error("config.toml: legacy [slack] legacy_owner_slack_id and [owner] slack_id are both set and differ — set `[owner] slack_id` only");
+        }
+    }
+}
+/**
+ * The review sections of a config.toml, parsed and checked exactly as the
+ * whole-file parser (`parseConfig`, src/config.ts) parses them. The other
+ * sections are not read, so a file that only names the review's sections is
+ * a whole review config. `[github] secrets_dir` stays as written. `warn`
+ * hears each deprecated key once.
+ */
+export function parseCoreConfig(toml, opts = {}) {
+    const raw = parse(toml);
+    for (const line of configDeprecations(raw))
+        opts.warn?.(`[quickreviewd] ${line}`);
+    const github = parseGithubSection(raw);
+    const preset = presetOf(raw);
+    const engine = parseEngine((raw.engine ?? {}));
+    const cfg = {
+        dry_run: Boolean(req(raw, "dry_run")),
+        github,
+        models: parseModels(req(raw, "models"), REVIEW_PRESETS[preset].effort),
+        engine,
+        pi: parsePiSection(raw),
+        guards: parseGuardsSection(raw),
+        review: parseReviewSection(raw, preset),
+        escalation: parseEscalation((raw.escalation ?? {})),
+        owner: parseOwnerSection(raw),
+        scan: parseScan(raw.scan),
+    };
+    validateReviewSection(cfg);
+    foldLegacyOwnerSlackId(raw, cfg.owner);
+    requireGithubKeys(cfg.github);
+    return cfg;
+}
+//# sourceMappingURL=reviewconfig.js.map