lastlight-shared 0.1.7 → 0.3.0

package/dist/config-types.d.ts

@@ -3,6 +3,13 @@
  * `config/config.ts` so `shared` never depends back on core (locked decision
  * 11). Core re-exports these from `lastlight-shared` so its own
  * `config/config.js` import surface is unchanged.
+ *
+ * The `fix:` / `dependencies:` / `review:` policy blocks below live here for the
+ * same reason plus one more: they are **repo-settable** (issues #251/#252), so
+ * `repo-config-schema.ts` — which bounds a repo's `.lastlight/` and is compiled
+ * into the CLI as well as core — has to name their shape and their shipped
+ * defaults. Core's normaliser and the repo-layer sanitizer therefore agree by
+ * construction rather than by two hand-maintained copies.
  */
 export interface DisabledConfig {
     workflows: string[];
@@ -15,3 +22,132 @@ export interface RouteConfig {
     github: Record<string, string>;
     slack: Record<string, string>;
 }
+/**
+ * The five classes a `diagnose` phase may return (09 → S1,
+ * `apps/server/skills/fixing/SKILL.md`), which is also the vocabulary
+ * {@link FixConfig.retryableClasses} names members of.
+ *
+ * It lives here rather than beside the marker parser in core because BOTH
+ * validators of that leaf need it: core's boot normaliser, and the repo-layer
+ * clamp in `./repo-config-schema.ts` — which is compiled into the CLI and may
+ * never reach core. `apps/server/src/engine/fix-markers.ts` re-exports it, so
+ * every reader of the marker grammar still finds it where it expects to.
+ */
+export declare const DIAGNOSIS_CLASSES: readonly ["reproducible", "env-mismatch", "flaky", "infra-dependent", "upstream-broken"];
+export type DiagnosisClass = (typeof DIAGNOSIS_CLASSES)[number];
+/** True when `value` is one of {@link DIAGNOSIS_CLASSES}. */
+export declare function isDiagnosisClass(value: unknown): value is DiagnosisClass;
+/**
+ * Retry/escalation policy for every PR_FIX_SHAPED workflow (`pr-fix`,
+ * `dependabot-ci-fix`).
+ *
+ * Repo-settable subset (bounded in `repo-config-schema.ts`): `maxAttempts`,
+ * `localIterations`, `maxCostUsd`, `maxFlakyDeferrals` and `retryableClasses`,
+ * each clamped so a repo can only ever be MORE conservative than the operator.
+ * `escalateModelAfterAttempt` (spend control) and `gateTimeoutSeconds` (resource
+ * control) are operator-only.
+ */
+export interface FixConfig {
+    /** Cross-run attempts per (repo, PR) before the PR is escalated to a human. */
+    maxAttempts: number;
+    /**
+     * Within-run gate-loop iterations inside ONE attempt.
+     *
+     * Read by the fix phase's `generic_loop.max_iterations:
+     * { from: fix.localIterations, default: 2 }` in `pr-fix.yaml` /
+     * `dependabot-ci-fix.yaml` — the effective block is seeded on the run's
+     * template context, so the repo-clamped value is the operative bound.
+     */
+    localIterations: number;
+    /**
+     * `until_bash` budget, in seconds, for the repo's build/test gate. Read by
+     * the same phase's `timeout_seconds: { from: fix.gateTimeoutSeconds, … }`.
+     */
+    gateTimeoutSeconds: number;
+    /** Attempts ABOVE this number use `models["pr-fix-retry"]` when one is set. */
+    escalateModelAfterAttempt: number;
+    /** Cumulative cost ceiling across attempts for one PR. `null` = unbounded. */
+    maxCostUsd: number | null;
+    /** How many times a `flaky` diagnosis may defer before it is treated as reproducible. */
+    maxFlakyDeferrals: number;
+    /**
+     * Diagnosis classes another attempt may help with; every other class escalates
+     * immediately. Members must be {@link DIAGNOSIS_CLASSES}.
+     *
+     * Typed `string[]` rather than `DiagnosisClass[]` because it is parsed from
+     * untrusted YAML and a bad member must NARROW the retry set with a warning
+     * rather than fail the boot — but it is validated against the enum on both
+     * paths now. It was not: a typo (`reproducable`) silently made every
+     * diagnosis escalate `not-retryable` on the second dispatch, with nothing
+     * said anywhere (#256).
+     */
+    retryableClasses: string[];
+}
+/** The shipped `fix:` block. Mirrors `fix:` in `apps/server/config/default.yaml`. */
+export declare function defaultFixConfig(): FixConfig;
+/** How much blast radius a major dependency bump carries, ascending. */
+export declare const DEPENDENCY_IMPACT_LEVELS: readonly ["none", "low", "medium", "high"];
+export type DependencyImpact = (typeof DEPENDENCY_IMPACT_LEVELS)[number];
+/** True when `value` is one of {@link DEPENDENCY_IMPACT_LEVELS}. */
+export declare function isDependencyImpact(value: unknown): value is DependencyImpact;
+/** Position of an impact tier on the `none < low < medium < high` scale. */
+export declare function dependencyImpactRank(impact: DependencyImpact): number;
+/**
+ * Policy for merging dependency PRs — specifically, how far up the impact scale
+ * a MAJOR bump may be auto-merged instead of escalated to a human.
+ *
+ * Repo-settable subset: `autoMergeMaxImpact` (clamped to the lower tier), and
+ * `requireSettledChecks` + `auditComment` (both add-only `true`).
+ * `minSettledChecks` is **operator-only**: the §6.2 `max(repo, operator)` clamp
+ * would weld the escape hatch shut for a repo with no CI at all (09 locked
+ * decision 18).
+ */
+export interface DependenciesConfig {
+    /** Ceiling for auto-merging a MAJOR bump. `none` = never auto-merge a major. */
+    autoMergeMaxImpact: DependencyImpact;
+    /** Enforce settled-"passing" checks on ALL routes (webhook, cron, comment). */
+    requireSettledChecks: boolean;
+    /** An auto-merge decision needs >= N settled checks; `0` = today's behaviour. */
+    minSettledChecks: number;
+    /** Post the evidence comment when auto-merging a major. */
+    auditComment: boolean;
+}
+/** The shipped `dependencies:` block. Mirrors `dependencies:` in `config/default.yaml`. */
+export declare function defaultDependenciesConfig(): DependenciesConfig;
+/**
+ * When a `pr-review` run is triggered.
+ *
+ * - `eager` — dispatch on `pr.opened` / `synchronize` / `reopened`, in parallel
+ *   with CI (the historical behaviour).
+ * - `after-checks` — dispatch once the head SHA's checks SETTLE, either colour.
+ * - `on-request` — never automatically; only when explicitly asked for.
+ *
+ * (`review.afterChecks` — the settled/passing sub-mode — was deleted by 09
+ * locked decision 14: a PR whose CI never goes green would never be reviewed.)
+ */
+export declare const REVIEW_TRIGGERS: readonly ["eager", "after-checks", "on-request"];
+export type ReviewTrigger = (typeof REVIEW_TRIGGERS)[number];
+/** True when `value` is one of {@link REVIEW_TRIGGERS}. */
+export declare function isReviewTrigger(value: unknown): value is ReviewTrigger;
+/** Position of a trigger mode on the automation scale. */
+export declare function reviewTriggerRank(trigger: ReviewTrigger): number;
+/**
+ * The `review:` block. Every key is repo-settable, and every one is CLAMPED
+ * towards less automation: `postsCheck` and `skipDraft` are add-only `true` (a
+ * repo may ask for the check and may skip drafts; it may not suppress an
+ * operator's check or force reviews onto drafts), `trigger` takes the lower
+ * {@link reviewTriggerRank} of repo and operator, and `requestLabel` is free —
+ * naming a label only ever adds an explicit, human-initiated route.
+ */
+export interface ReviewConfig {
+    /** Post the `last-light/review` Check Run. */
+    postsCheck: boolean;
+    /** Which trigger mode this deployment/repo uses. */
+    trigger: ReviewTrigger;
+    /** Label that requests a review in `on-request` mode. `null` = no label route. */
+    requestLabel: string | null;
+    /** Skip draft PRs (matching what the review cron has always done). */
+    skipDraft: boolean;
+}
+/** The shipped `review:` block. Mirrors `review:` in `config/default.yaml`. */
+export declare function defaultReviewConfig(): ReviewConfig;

package/dist/config-types.js

@@ -3,6 +3,123 @@
  * `config/config.ts` so `shared` never depends back on core (locked decision
  * 11). Core re-exports these from `lastlight-shared` so its own
  * `config/config.js` import surface is unchanged.
+ *
+ * The `fix:` / `dependencies:` / `review:` policy blocks below live here for the
+ * same reason plus one more: they are **repo-settable** (issues #251/#252), so
+ * `repo-config-schema.ts` — which bounds a repo's `.lastlight/` and is compiled
+ * into the CLI as well as core — has to name their shape and their shipped
+ * defaults. Core's normaliser and the repo-layer sanitizer therefore agree by
+ * construction rather than by two hand-maintained copies.
  */
-export {};
+// ---------------------------------------------------------------------------
+// fix: — the PR_FIX_SHAPED retry policy (issue #251)
+// ---------------------------------------------------------------------------
+/**
+ * The five classes a `diagnose` phase may return (09 → S1,
+ * `apps/server/skills/fixing/SKILL.md`), which is also the vocabulary
+ * {@link FixConfig.retryableClasses} names members of.
+ *
+ * It lives here rather than beside the marker parser in core because BOTH
+ * validators of that leaf need it: core's boot normaliser, and the repo-layer
+ * clamp in `./repo-config-schema.ts` — which is compiled into the CLI and may
+ * never reach core. `apps/server/src/engine/fix-markers.ts` re-exports it, so
+ * every reader of the marker grammar still finds it where it expects to.
+ */
+export const DIAGNOSIS_CLASSES = [
+    "reproducible",
+    "env-mismatch",
+    "flaky",
+    "infra-dependent",
+    "upstream-broken",
+];
+/** True when `value` is one of {@link DIAGNOSIS_CLASSES}. */
+export function isDiagnosisClass(value) {
+    return typeof value === "string" && DIAGNOSIS_CLASSES.includes(value);
+}
+/** The shipped `fix:` block. Mirrors `fix:` in `apps/server/config/default.yaml`. */
+export function defaultFixConfig() {
+    return {
+        maxAttempts: 3,
+        localIterations: 2,
+        gateTimeoutSeconds: 900,
+        escalateModelAfterAttempt: 1,
+        maxCostUsd: 5.0,
+        maxFlakyDeferrals: 2,
+        retryableClasses: ["reproducible", "env-mismatch"],
+    };
+}
+// ---------------------------------------------------------------------------
+// dependencies: — major-bump auto-merge policy (issue #252)
+// ---------------------------------------------------------------------------
+/** How much blast radius a major dependency bump carries, ascending. */
+export const DEPENDENCY_IMPACT_LEVELS = ["none", "low", "medium", "high"];
+/** True when `value` is one of {@link DEPENDENCY_IMPACT_LEVELS}. */
+export function isDependencyImpact(value) {
+    return typeof value === "string" && DEPENDENCY_IMPACT_LEVELS.includes(value);
+}
+/** Position of an impact tier on the `none < low < medium < high` scale. */
+export function dependencyImpactRank(impact) {
+    return DEPENDENCY_IMPACT_LEVELS.indexOf(impact);
+}
+/** The shipped `dependencies:` block. Mirrors `dependencies:` in `config/default.yaml`. */
+export function defaultDependenciesConfig() {
+    return {
+        autoMergeMaxImpact: "medium",
+        requireSettledChecks: true,
+        minSettledChecks: 1,
+        auditComment: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// review: — when `pr-review` runs
+// ---------------------------------------------------------------------------
+/**
+ * When a `pr-review` run is triggered.
+ *
+ * - `eager` — dispatch on `pr.opened` / `synchronize` / `reopened`, in parallel
+ *   with CI (the historical behaviour).
+ * - `after-checks` — dispatch once the head SHA's checks SETTLE, either colour.
+ * - `on-request` — never automatically; only when explicitly asked for.
+ *
+ * (`review.afterChecks` — the settled/passing sub-mode — was deleted by 09
+ * locked decision 14: a PR whose CI never goes green would never be reviewed.)
+ */
+export const REVIEW_TRIGGERS = ["eager", "after-checks", "on-request"];
+/** True when `value` is one of {@link REVIEW_TRIGGERS}. */
+export function isReviewTrigger(value) {
+    return typeof value === "string" && REVIEW_TRIGGERS.includes(value);
+}
+/**
+ * How much automation a trigger mode buys, ascending — the scale the repo-layer
+ * clamp takes the minimum on.
+ *
+ * Not derived from {@link REVIEW_TRIGGERS}' index, which runs the other way: the
+ * list is ordered most-automatic first for readability, and silently inverting
+ * it is exactly the kind of coupling that breaks when someone reorders the
+ * literal. Stated explicitly instead.
+ *
+ * `eager` runs a full agent review on every push; `after-checks` runs one per
+ * settled head; `on-request` runs none unless asked. So a repo that commits
+ * `eager` against an `on-request` deployment is buying itself an agent run per
+ * push at the operator's expense (#256) — the same direction `fix.maxAttempts`
+ * is clamped in, and the same clamp applies.
+ */
+const REVIEW_TRIGGER_AUTOMATION = {
+    "on-request": 0,
+    "after-checks": 1,
+    eager: 2,
+};
+/** Position of a trigger mode on the automation scale. */
+export function reviewTriggerRank(trigger) {
+    return REVIEW_TRIGGER_AUTOMATION[trigger];
+}
+/** The shipped `review:` block. Mirrors `review:` in `config/default.yaml`. */
+export function defaultReviewConfig() {
+    return {
+        postsCheck: false,
+        trigger: "after-checks",
+        requestLabel: null,
+        skipDraft: true,
+    };
+}
 //# sourceMappingURL=config-types.js.map

package/dist/config-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../src/config-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}
+{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../src/config-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAeH,8EAA8E;AAC9E,qDAAqD;AACrD,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,cAAc;IACd,cAAc;IACd,OAAO;IACP,iBAAiB;IACjB,iBAAiB;CACT,CAAC;AAIX,6DAA6D;AAC7D,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,iBAAuC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC/F,CAAC;AAiDD,qFAAqF;AACrF,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,WAAW,EAAE,CAAC;QACd,eAAe,EAAE,CAAC;QAClB,kBAAkB,EAAE,GAAG;QACvB,yBAAyB,EAAE,CAAC;QAC5B,UAAU,EAAE,GAAG;QACf,iBAAiB,EAAE,CAAC;QACpB,gBAAgB,EAAE,CAAC,cAAc,EAAE,cAAc,CAAC;KACnD,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,4DAA4D;AAC5D,8EAA8E;AAE9E,wEAAwE;AACxE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAU,CAAC;AAInF,oEAAoE;AACpE,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,wBAA8C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACtG,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAAC,MAAwB;IAC3D,OAAO,wBAAwB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAClD,CAAC;AAuBD,2FAA2F;AAC3F,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL,kBAAkB,EAAE,QAAQ;QAC5B,oBAAoB,EAAE,IAAI;QAC1B,gBAAgB,EAAE,CAAC;QACnB,YAAY,EAAE,IAAI;KACnB,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,kCAAkC;AAClC,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,YAAY,CAAU,CAAC;AAIhF,2DAA2D;AAC3D,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,yBAAyB,GAAkC;IAC/D,YAAY,EAAE,CAAC;IACf,cAAc,EAAE,CAAC;IACjB,KAAK,EAAE,CAAC;CACT,CAAC;AAEF,0DAA0D;AAC1D,MAAM,UAAU,iBAAiB,CAAC,OAAsB;IACtD,OAAO,yBAAyB,CAAC,OAAO,CAAC,CAAC;AAC5C,CAAC;AAqBD,+EAA+E;AAC/E,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,UAAU,EAAE,KAAK;QACjB,OAAO,EAAE,cAAc;QACvB,YAAY,EAAE,IAAI;QAClB,SAAS,EAAE,IAAI;KAChB,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -19,3 +19,4 @@ export * from "./overlay-assets.js";
 export * from "./core-pin.js";
 export * from "./workflow-loader.js";
 export * from "./config-types.js";
+export * from "./repo-config-schema.js";

package/dist/index.js

@@ -19,4 +19,5 @@ export * from "./overlay-assets.js";
 export * from "./core-pin.js";
 export * from "./workflow-loader.js";
 export * from "./config-types.js";
+export * from "./repo-config-schema.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}

package/dist/repo-config-schema.d.ts

@@ -0,0 +1,328 @@
+/**
+ * The PURE half of the per-repository config layer (issue #180) — the schema,
+ * the operator bounds, and the validators/merger that enforce them.
+ *
+ * A managed repo may commit a `.lastlight/` directory that overrides a BOUNDED
+ * subset of Last Light's config for runs against that repo. The directory
+ * mirrors a deployment overlay's on-disk shape exactly:
+ *
+ *   .lastlight/
+ *     lastlight.yml                  # the config override
+ *     workflows/prompts/*.md         # prompt overrides
+ *     skills/<name>/SKILL.md         # skill overrides
+ *     agent-context/*.md             # persona/rules additions
+ *
+ * ── Why this lives in `lastlight-shared` ──────────────────────────────────
+ * Two consumers need exactly the same answers about a `.lastlight/` tree:
+ *   - `lastlight-core` at runtime, after fetching the layer from GitHub
+ *     (`apps/server/src/config/repo-config.ts`, which owns the impure half —
+ *     the fetch, the TTL cache, the on-disk unpack — and re-exports everything
+ *     here so its import surface is unchanged); and
+ *   - the `lastlight` CLI, offline, inside a user's own code repo
+ *     (`lastlight repo config validate`).
+ * The CLI must never gain a dependency edge to core, so the bounds logic sits
+ * here — the one package both already depend on. Nothing in this file touches
+ * the filesystem, the network, or runtime config: it is a function of its
+ * arguments, which is also what makes it directly unit-testable.
+ *
+ * ── The trust rule ────────────────────────────────────────────────────────
+ * The layer is ALWAYS read from the repo's **default branch**. Never a PR head.
+ * Never the sandbox checkout. That rule is enforced by the fetcher in core;
+ * this module only describes what may appear in the layer once it arrives.
+ *
+ * ── The failure rule ──────────────────────────────────────────────────────
+ * Warn, drop the bad bits, run anyway. A repo's config file must never fail a
+ * run. Invalid YAML drops the whole file; an unknown or out-of-bounds key drops
+ * just that key. Every rejection becomes a structured {@link RepoConfigWarning}
+ * so the dashboard/CLI can report it back to the repo's owners.
+ */
+import { type DependenciesConfig, type DisabledConfig, type FixConfig, type ReviewConfig } from "./config-types.js";
+/** Hard cap on the unpacked `.lastlight/` layer, in bytes. */
+export declare const REPO_CONFIG_MAX_BYTES: number;
+/** Hard cap on the number of files in the unpacked layer. */
+export declare const REPO_CONFIG_MAX_FILES = 200;
+/** The config file inside `.lastlight/`. Exactly this name — no `.yaml` variant. */
+export declare const REPO_CONFIG_FILE = "lastlight.yml";
+/**
+ * The operator's bounds on the per-repo config layer (issue #180). A repo may
+ * narrow its own behaviour within these bounds; it can never widen them, and
+ * violating them drops the offending key with a warning rather than failing
+ * the run.
+ *
+ * Trust note: the layer this policy bounds is always fetched from the repo's
+ * DEFAULT BRANCH. A PR head can't reach it, so a PR can't reconfigure the agent
+ * that reviews it. That rule lives in `apps/server/src/config/repo-config.ts`;
+ * this type only describes the bounds.
+ */
+export interface RepoConfigPolicy {
+    /** Master switch. `false` ignores every repo's `.lastlight/` entirely (no fetch). */
+    enabled: boolean;
+    /**
+     * Config keys a repo may set, as dotted paths (`models`, `disabled.workflows`,
+     * …). A repo leaf is kept when some entry is that leaf's path or a prefix of
+     * it — so `models` admits `models.architect`, while `disabled.workflows` does
+     * NOT admit `disabled.prompts`. Everything else is dropped with a warning.
+     */
+    allowKeys: string[];
+    /**
+     * Model specs a repo may select. `null` (the default) means "any model whose
+     * `provider/` prefix is a provider Last Light knows how to wire" — the repo
+     * still can't invent a provider. A list restricts to exactly those specs.
+     */
+    allowedModels: string[] | null;
+    /**
+     * Whether the repo's asset overrides (`workflows/prompts/*.md`,
+     * `skills/<name>/SKILL.md`, `agent-context/*.md`) are unpacked and used.
+     * `false` keeps `lastlight.yml` only.
+     */
+    allowAssets: boolean;
+}
+/**
+ * The allow-list a deployment gets when it says nothing. Kept as a constant so
+ * the normaliser, the docs, `config/default.yaml` and the CLI's offline
+ * validator can't drift apart.
+ *
+ * It MUST stay identical to `repoConfig.allowKeys` in
+ * `apps/server/config/default.yaml`: this list is what a deployment falls back
+ * to when config isn't in reach (`repoConfigPolicy()`'s no-config path, and the
+ * CLI's offline `lastlight repo config validate`), so a divergence tells repo
+ * owners their file is out of bounds when it isn't. Pinned by the
+ * `default allow-list` block in `apps/server/tests/config/repo-config-shared.test.ts`
+ * — the two drifted apart once already, silently.
+ */
+export declare const DEFAULT_REPO_CONFIG_ALLOW_KEYS: readonly string[];
+/**
+ * The bounds to assume when no deployment config is in reach — the shipped
+ * defaults. The offline CLI validator (`lastlight repo config validate`) uses
+ * this: it can't know the operator's narrowing, so it validates against the
+ * widest shipped policy and says so.
+ */
+export declare function defaultRepoConfigPolicy(): RepoConfigPolicy;
+/** Which config layer supplied a resolved leaf. Mirrors core's `ConfigSource`. */
+export type ConfigSource = "default" | "overlay" | "env" | "repo";
+/** Why a piece of a repo's `.lastlight/` was dropped. */
+export type RepoConfigWarningCode = 
+/** `lastlight.yml` did not parse as YAML — the whole file is ignored. */
+"invalid-yaml"
+/** `lastlight.yml` parsed to something that isn't a mapping. */
+ | "not-a-mapping"
+/** The key isn't in the operator's `repoConfig.allowKeys`. */
+ | "key-not-allowed"
+/** The key is allowed but the value has the wrong type/shape. */
+ | "invalid-value"
+/** A model spec outside `repoConfig.allowedModels`. */
+ | "model-not-allowed"
+/** A model spec whose `provider/` prefix isn't a provider we can wire. */
+ | "unknown-provider"
+/** An `approval` entry that would clear a gate — the layer is add-only. */
+ | "approval-downgrade"
+/**
+ * A `fix` / `dependencies` / `review` entry that would make the repo LESS
+ * conservative than the operator (issues #251/#252). Clamped to the operator's
+ * value — the repo keeps running, it just doesn't get the looser setting.
+ */
+ | "policy-downgrade"
+/** A file path that escapes the layer root. */
+ | "path-escape"
+/** A symlink (or other non-regular blob) in the layer. */
+ | "symlink"
+/** The layer exceeded {@link REPO_CONFIG_MAX_BYTES}. */
+ | "size-cap"
+/** The layer exceeded {@link REPO_CONFIG_MAX_FILES}. */
+ | "file-count-cap"
+/** A workflow YAML under `workflows/` — repos may contribute prompts, not workflows. */
+ | "workflow-not-allowed"
+/** Asset files present but `repoConfig.allowAssets` is false. */
+ | "assets-not-allowed"
+/** Files in a layer directory that don't match its expected shape. */
+ | "unrecognised-asset"
+/** The GitHub fetch failed; the previous cached layer (if any) still stands. */
+ | "fetch-failed";
+/**
+ * One structured, reportable rejection. Deliberately a plain data object (not
+ * an Error): these are collected, persisted in the cache sidecar and rendered
+ * by the dashboard/CLI, never thrown.
+ */
+export interface RepoConfigWarning {
+    code: RepoConfigWarningCode;
+    /** `owner/repo` this warning belongs to, when known. */
+    repo?: string;
+    /** The config path (`models.architect`) or file path (`workflows/x.yaml`) at fault. */
+    path: string;
+    /** One-line human-readable explanation, safe to post back to the repo. */
+    message: string;
+}
+/**
+ * One blob of a `.lastlight/` tree, as handed to {@link sanitizeRepoFiles}.
+ * Structurally the same shape core's GitHub client produces (`RepoConfigFile`
+ * in `apps/server/src/engine/github/github.ts`) and the CLI reads off disk —
+ * declared here so the bounds logic needs no GitHub types.
+ */
+export interface RepoLayerFile {
+    /** Path relative to `.lastlight/`. */
+    path: string;
+    /** Git filemode (`100644`, `100755`, `120000`, …). */
+    mode: string;
+    size: number;
+    content: Buffer;
+}
+/** A repo's fetched-and-unpacked `.lastlight/` layer. */
+export interface RepoLayer {
+    /** `owner/repo`. */
+    repo: string;
+    /** The ref this layer was read from — always the repo's default branch. */
+    defaultBranch: string;
+    /** Git tree SHA of `.lastlight/` — the content identity used for conditional refetch. */
+    treeSha: string;
+    /** ETag of the default branch's root tree, for the cheap 304 path. */
+    etag?: string;
+    /** ISO timestamp of the last successful download (not of the last check). */
+    fetchedAt: string;
+    /**
+     * Absolute path of the unpacked tree. Mirrors an overlay root
+     * (`workflows/`, `skills/`, `agent-context/`), so it can be handed to the
+     * layer-aware asset loader directly.
+     */
+    root: string;
+    /** Parsed `lastlight.yml` — raw and UNVALIDATED; bounds are applied at resolve time. */
+    config?: Record<string, unknown>;
+    /** Accepted asset paths relative to {@link root}. Empty when `allowAssets` is false. */
+    assets: string[];
+    /** Everything dropped while fetching/unpacking this layer. */
+    warnings: RepoConfigWarning[];
+}
+/**
+ * The boot-resolved config the repo layer is applied on top of: the merged
+ * (default→overlay→env) values plus the matching provenance tree from
+ * `resolveConfigLayers`. Core builds one with `repoConfigBaseFromRuntime`.
+ */
+export interface RepoConfigBase {
+    value: Record<string, unknown>;
+    sources: Record<string, unknown>;
+}
+/** The effective, repo-specific values for the keys a repo is allowed to touch. */
+export interface RepoMergedConfig {
+    models: Record<string, string>;
+    variants: Record<string, string>;
+    /**
+     * Full disabled shape. Only `workflows` and `crons` are repo-settable by
+     * default; the rest always come from the operator's layers.
+     */
+    disabled: DisabledConfig;
+    approval: Record<string, boolean>;
+    /**
+     * Retry policy for the PR_FIX_SHAPED workflows (issue #251) and major-bump
+     * auto-merge policy (issue #252), each already clamped so the repo is never
+     * looser than the operator. Always present: a base that carries no `fix:` /
+     * `dependencies:` / `review:` node (an older boot config, or the CLI's offline
+     * validator) falls back leaf-by-leaf to the shipped defaults, so consumers
+     * never have to reason about a partially-populated block.
+     */
+    fix: FixConfig;
+    dependencies: DependenciesConfig;
+    review: ReviewConfig;
+}
+/** Provenance mirror of {@link RepoMergedConfig} — each leaf tagged with its winning layer. */
+export interface RepoConfigSources {
+    models: Record<string, ConfigSource>;
+    variants: Record<string, ConfigSource>;
+    disabled: Record<keyof DisabledConfig, ConfigSource>;
+    approval: Record<string, ConfigSource>;
+    fix: Record<string, ConfigSource>;
+    dependencies: Record<string, ConfigSource>;
+    review: Record<string, ConfigSource>;
+}
+/** Result of {@link resolveRepoConfig}. */
+export interface ResolvedRepoConfig {
+    merged: RepoMergedConfig;
+    sources: RepoConfigSources;
+    /** Fetch/unpack warnings from the layer PLUS everything this resolve dropped. */
+    warnings: RepoConfigWarning[];
+}
+/** What role a path inside `.lastlight/` plays in the repo layer. */
+export type RepoLayerPathKind = "config" | "prompt" | "skill" | "agent-context";
+/**
+ * Classify a path relative to `.lastlight/`, or `null` when it is not part of
+ * the layer at all.
+ *
+ * `null` is a routine answer, not an error: `.lastlight/` is shared real
+ * estate. With `buildAssets.location: repo` the build workflow commits its
+ * handoff docs to `.lastlight/<issueKey>/*.md`, and repos are free to keep
+ * other things there. Those are simply outside the layer — the warning path is
+ * reserved for files that LOOK like layer assets but have the wrong shape
+ * (see {@link sanitizeRepoFiles}).
+ */
+export declare function repoLayerPathKind(path: string): RepoLayerPathKind | null;
+/** True when a path is a workflow DEFINITION — the one thing a repo may never contribute. */
+export declare function isRepoWorkflowPath(path: string): boolean;
+/**
+ * Apply every file-level bound to a `.lastlight/` subtree.
+ *
+ * Pure — takes the blobs, returns the ones that may be written to disk plus a
+ * warning per rejection. The caps are enforced here as well as at fetch time
+ * (the client stops downloading at its own limits) because this function is the
+ * last gate before anything touches the filesystem, and defence in depth is
+ * cheap.
+ *
+ * Generic in the file type so a caller carrying a richer blob shape (core's
+ * `RepoConfigFile`) gets its own type back rather than a widened one.
+ */
+export declare function sanitizeRepoFiles<T extends RepoLayerFile>(files: readonly T[], policy: RepoConfigPolicy, repo?: string): {
+    accepted: T[];
+    warnings: RepoConfigWarning[];
+};
+/**
+ * Parse a repo's `lastlight.yml`. Malformed YAML, or YAML that isn't a mapping,
+ * drops the WHOLE file — a half-understood config file is more dangerous than
+ * none, and the repo gets a warning either way.
+ */
+export declare function parseRepoConfigYaml(raw: string, repo?: string): {
+    config?: Record<string, unknown>;
+    warnings: RepoConfigWarning[];
+};
+/**
+ * Reduce a repo's raw `lastlight.yml` to the sub-tree it is actually allowed to
+ * contribute. Pure. Everything dropped produces a warning.
+ *
+ * `base` supplies the operator's current values, which the `approval` add-only
+ * rule needs: a repo may raise a gate, never lower one.
+ */
+export declare function sanitizeRepoConfigLayer(raw: Record<string, unknown> | undefined, policy: RepoConfigPolicy, base: RepoConfigBase, repo?: string): {
+    layer: Record<string, unknown>;
+    warnings: RepoConfigWarning[];
+};
+/**
+ * Apply a repo's layer on top of the boot config and report what happened.
+ *
+ * PURE — no fs, no network, no runtime-config reads. Plain objects deep-merge
+ * key-by-key while arrays and scalars replace wholesale — byte-for-byte the
+ * semantics of the boot layers (see {@link mergeLayer}), so the repo layer can
+ * never acquire semantics the operator's layers don't have.
+ *
+ * Note on `disabled.*`: those are arrays, so a repo's list REPLACES the
+ * operator's rather than adding to it (locked precedence). Operators who don't
+ * want that remove `disabled.workflows` / `disabled.crons` from
+ * `repoConfig.allowKeys`.
+ *
+ * Passing `undefined` for `repoLayer` (no `.lastlight/`, fetch failed, feature
+ * disabled) returns the base unchanged with no warnings — the inert path.
+ */
+export declare function resolveRepoConfig(base: RepoConfigBase, policy: RepoConfigPolicy, repoLayer?: RepoLayer): ResolvedRepoConfig;
+/**
+ * Merge one layer INTO `value`/`sources` in place, tagging every leaf it
+ * supplies with `source`.
+ *
+ * THE single definition of Last Light's config-merge semantics: plain objects
+ * deep-merge key-by-key so each leaf resolves (and is attributed) on its own;
+ * arrays and scalars replace wholesale. Core's boot-layer resolver
+ * (`apps/server/src/config/config-resolve.ts`) re-exports this rather than
+ * carrying its own — the repo layer must merge exactly the way default/overlay/
+ * env do, or a repo could acquire precedence the operator's own layers don't
+ * have, and two implementations is exactly how that drift starts.
+ *
+ * It lives HERE, in the leaf package, because the direction of the dependency
+ * edge only permits it here: `lastlight-shared` may never depend on core.
+ */
+export declare function mergeLayer(value: Record<string, unknown>, sources: Record<string, unknown>, layer: Record<string, unknown>, source: ConfigSource): void;
+/** Narrow an unknown provenance leaf to a {@link ConfigSource}. */
+export declare function isConfigSource(value: unknown): value is ConfigSource;