@oss-autopilot/core 3.4.0 → 3.5.0

package/dist/core/follow-up-history.d.ts

@@ -0,0 +1,41 @@
+/**
+ * PR follow-up history helpers (#1277).
+ *
+ * Centralizes the read/write logic for `state.prFollowUpHistory`.
+ * Used by `workflows/dormant-pr-follow-up.md` to enforce the
+ * one-follow-up-per-timeframe rule documented in
+ * `skills/pr-etiquette/SKILL.md`.
+ *
+ * Pure functions — callers manage state I/O.
+ */
+import type { AgentState } from './state-schema.js';
+import type { FollowUpEntry } from './state-schema.js';
+export type FollowUpTier = 'light_check_in' | 'direct_check_in' | 'final_check_in';
+/**
+ * Tier window in days. The "no second ping in the same window" rule
+ * uses this to decide whether a recent follow-up still locks out the
+ * next draft. Sourced from `skills/pr-etiquette/SKILL.md`.
+ */
+export declare const TIER_WINDOW_DAYS: Record<FollowUpTier, number>;
+/**
+ * Read the existing follow-up entries for a PR. Returns an empty
+ * array when no entries exist or when the state field is unset.
+ */
+export declare function getFollowUpHistory(state: AgentState, prUrl: string): FollowUpEntry[];
+/**
+ * Find the most recent entry, or null when there are none. Used by
+ * the workflow's pre-draft gate.
+ */
+export declare function lastFollowUp(state: AgentState, prUrl: string): FollowUpEntry | null;
+/**
+ * Whether a follow-up of the given tier was drafted within the
+ * tier's own window. The workflow uses this to surface a warning
+ * before the user drafts a second ping in the same window. Different
+ * tiers are always allowed (escalating light → direct → final).
+ */
+export declare function isWithinTierWindow(state: AgentState, prUrl: string, tier: FollowUpTier, now?: Date): boolean;
+/**
+ * Record a new follow-up entry. Returns the next state; callers
+ * decide when to persist.
+ */
+export declare function recordFollowUp(state: AgentState, prUrl: string, entry: FollowUpEntry): AgentState;

package/dist/core/follow-up-history.js

@@ -0,0 +1,71 @@
+/**
+ * PR follow-up history helpers (#1277).
+ *
+ * Centralizes the read/write logic for `state.prFollowUpHistory`.
+ * Used by `workflows/dormant-pr-follow-up.md` to enforce the
+ * one-follow-up-per-timeframe rule documented in
+ * `skills/pr-etiquette/SKILL.md`.
+ *
+ * Pure functions — callers manage state I/O.
+ */
+/**
+ * Tier window in days. The "no second ping in the same window" rule
+ * uses this to decide whether a recent follow-up still locks out the
+ * next draft. Sourced from `skills/pr-etiquette/SKILL.md`.
+ */
+export const TIER_WINDOW_DAYS = {
+    light_check_in: 7,
+    direct_check_in: 14,
+    final_check_in: 30,
+};
+/**
+ * Read the existing follow-up entries for a PR. Returns an empty
+ * array when no entries exist or when the state field is unset.
+ */
+export function getFollowUpHistory(state, prUrl) {
+    return state.prFollowUpHistory?.[prUrl] ?? [];
+}
+/**
+ * Find the most recent entry, or null when there are none. Used by
+ * the workflow's pre-draft gate.
+ */
+export function lastFollowUp(state, prUrl) {
+    const entries = getFollowUpHistory(state, prUrl);
+    if (entries.length === 0)
+        return null;
+    // Newest by timestamp wins. Defensive sort because the persistence
+    // path doesn't guarantee insertion order across machines.
+    return [...entries].sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp))[0];
+}
+/**
+ * Whether a follow-up of the given tier was drafted within the
+ * tier's own window. The workflow uses this to surface a warning
+ * before the user drafts a second ping in the same window. Different
+ * tiers are always allowed (escalating light → direct → final).
+ */
+export function isWithinTierWindow(state, prUrl, tier, now = new Date()) {
+    const last = lastFollowUp(state, prUrl);
+    if (!last)
+        return false;
+    if (last.tier !== tier)
+        return false;
+    const ageMs = now.getTime() - Date.parse(last.timestamp);
+    if (Number.isNaN(ageMs))
+        return false;
+    const windowMs = TIER_WINDOW_DAYS[tier] * 86400000;
+    return ageMs < windowMs;
+}
+/**
+ * Record a new follow-up entry. Returns the next state; callers
+ * decide when to persist.
+ */
+export function recordFollowUp(state, prUrl, entry) {
+    const next = {
+        ...state,
+        prFollowUpHistory: { ...(state.prFollowUpHistory ?? {}) },
+    };
+    const list = next.prFollowUpHistory[prUrl] ? [...next.prFollowUpHistory[prUrl]] : [];
+    list.push(entry);
+    next.prFollowUpHistory[prUrl] = list;
+    return next;
+}

package/dist/core/gist-state-store.d.ts

@@ -14,7 +14,7 @@
  *  6. Cache all Gist file contents in memory for session-scoped reads
  *  7. Write state to a local cache file for fallback
  *
- * Concurrency model (#1115):
+ * Concurrency model (#1115, #1235):
  *
  *  Each fetch captures the response's `ETag` and stores it as
  *  `lastFetchedEtag`. The next `push()` sends that ETag back as
@@ -24,12 +24,25 @@
  *  On 412, the store attempts a single merge: it re-fetches the Gist
  *  (refreshing the ETag), re-applies the in-memory dirty content on top of
  *  the now-current remote state, and pushes once more. If that second push
- *  also returns 412, `push()` throws {@link GistConcurrencyError} — local
- *  mutations stay in memory so the caller can decide whether to refresh and
- *  retry. The merge step is intentionally cheap (state is a single JSON
- *  blob) and treats local dirty changes as authoritative for conflict
- *  cells, which matches the "last-write-wins by intent" model the rest of
- *  oss-autopilot already assumes for state.json.
+ *  also returns 412, `push()` throws {@link GistConcurrencyError}.
+ *
+ *  Per-file conflict policy on the merge re-apply step:
+ *
+ *   - `state.json` is fail-loud. The `StateManager` contract advertises
+ *     optimistic compare-and-swap (state.ts:285-296), so silently clobbering
+ *     a concurrent remote write would violate it. To detect concurrent
+ *     writes without per-file ETags (the Gist API only exposes one ETag for
+ *     the whole gist), we snapshot each file's content at fetch time. If
+ *     the post-refresh `state.json` differs from the snapshot we held
+ *     before the refresh, another machine wrote it: `push()` throws
+ *     `GistConcurrencyError` instead of overwriting.
+ *   - Freeform documents (e.g. per-repo guidelines) keep last-write-wins.
+ *     The `setDocument` / `setGuidelines` callers' intent on a manual write
+ *     is "overwrite". Local dirty content is reapplied on top of the
+ *     refreshed remote.
+ *
+ *  In both cases, when the second push also 412s, local mutations stay in
+ *  memory so the caller can decide whether to refresh and retry.
  */
 import { AgentState } from './types.js';
 /** Well-known Gist description used for search-based discovery. */
@@ -126,6 +139,16 @@ export declare class GistStateStore {
     private gistId;
     readonly cachedFiles: Map<string, string>;
     readonly dirtyFiles: Set<string>;
+    /**
+     * Per-file content snapshot captured at fetch time (#1235). The Gist API
+     * exposes a single ETag for the whole gist, so we cannot use `If-Match`
+     * to detect a per-file conflict on the 412 merge re-apply. Holding the
+     * baseline content lets us compare it against the freshly-fetched remote
+     * and decide whether `state.json` changed under us. Updated only by
+     * `fetchAndCache` and successful `push()`; not mutated by `setState` /
+     * `setDocument` so the baseline reflects the remote, not local edits.
+     */
+    private baselineFiles;
     /**
      * ETag captured from the most recent successful Gist fetch (#1115).
      * Sent back as `If-Match` on `update` so concurrent writes from another

package/dist/core/gist-state-store.js

@@ -14,7 +14,7 @@
  *  6. Cache all Gist file contents in memory for session-scoped reads
  *  7. Write state to a local cache file for fallback
  *
- * Concurrency model (#1115):
+ * Concurrency model (#1115, #1235):
  *
  *  Each fetch captures the response's `ETag` and stores it as
  *  `lastFetchedEtag`. The next `push()` sends that ETag back as
@@ -24,12 +24,25 @@
  *  On 412, the store attempts a single merge: it re-fetches the Gist
  *  (refreshing the ETag), re-applies the in-memory dirty content on top of
  *  the now-current remote state, and pushes once more. If that second push
- *  also returns 412, `push()` throws {@link GistConcurrencyError} — local
- *  mutations stay in memory so the caller can decide whether to refresh and
- *  retry. The merge step is intentionally cheap (state is a single JSON
- *  blob) and treats local dirty changes as authoritative for conflict
- *  cells, which matches the "last-write-wins by intent" model the rest of
- *  oss-autopilot already assumes for state.json.
+ *  also returns 412, `push()` throws {@link GistConcurrencyError}.
+ *
+ *  Per-file conflict policy on the merge re-apply step:
+ *
+ *   - `state.json` is fail-loud. The `StateManager` contract advertises
+ *     optimistic compare-and-swap (state.ts:285-296), so silently clobbering
+ *     a concurrent remote write would violate it. To detect concurrent
+ *     writes without per-file ETags (the Gist API only exposes one ETag for
+ *     the whole gist), we snapshot each file's content at fetch time. If
+ *     the post-refresh `state.json` differs from the snapshot we held
+ *     before the refresh, another machine wrote it: `push()` throws
+ *     `GistConcurrencyError` instead of overwriting.
+ *   - Freeform documents (e.g. per-repo guidelines) keep last-write-wins.
+ *     The `setDocument` / `setGuidelines` callers' intent on a manual write
+ *     is "overwrite". Local dirty content is reapplied on top of the
+ *     refreshed remote.
+ *
+ *  In both cases, when the second push also 412s, local mutations stay in
+ *  memory so the caller can decide whether to refresh and retry.
  */
 import * as fs from 'node:fs';
 import { AgentStateSchema } from './state-schema.js';
@@ -77,6 +90,16 @@ export class GistStateStore {
     gistId = null;
     cachedFiles = new Map();
     dirtyFiles = new Set();
+    /**
+     * Per-file content snapshot captured at fetch time (#1235). The Gist API
+     * exposes a single ETag for the whole gist, so we cannot use `If-Match`
+     * to detect a per-file conflict on the 412 merge re-apply. Holding the
+     * baseline content lets us compare it against the freshly-fetched remote
+     * and decide whether `state.json` changed under us. Updated only by
+     * `fetchAndCache` and successful `push()`; not mutated by `setState` /
+     * `setDocument` so the baseline reflects the remote, not local edits.
+     */
+    baselineFiles = new Map();
     /**
      * ETag captured from the most recent successful Gist fetch (#1115).
      * Sent back as `If-Match` on `update` so concurrent writes from another
@@ -379,17 +402,61 @@ export class GistStateStore {
                 if (content !== undefined)
                     stagedContents[filename] = content;
             }
+            // Snapshot the full cache and baseline before refresh so a partial
+            // failure inside fetchAndCache (e.g. parse throws after the cache
+            // was already cleared and repopulated) can be rolled back without
+            // leaving the store with a stale ETag pointing at corrupt or
+            // half-populated state (#1235).
+            const preRefreshCache = new Map(this.cachedFiles);
+            const preRefreshBaseline = new Map(this.baselineFiles);
+            const preRefreshEtag = this.lastFetchedEtag;
+            const reapplyStaged = () => {
+                for (const [filename, content] of Object.entries(stagedContents)) {
+                    this.cachedFiles.set(filename, content);
+                }
+            };
             try {
                 await this.fetchAndCache(this.gistId);
             }
             catch (refreshErr) {
                 warn(MODULE, `Merge refresh after 412 failed: ${refreshErr}`);
+                // Roll back any partial mutation from fetchAndCache so the
+                // caller's retry path sees the prior state (with local
+                // mutations re-applied on top).
+                this.cachedFiles.clear();
+                for (const [filename, content] of preRefreshCache) {
+                    this.cachedFiles.set(filename, content);
+                }
+                this.baselineFiles = preRefreshBaseline;
+                this.lastFetchedEtag = preRefreshEtag;
+                reapplyStaged();
+                // Preserve the GistCorruptError type so callers don't retry
+                // against a corrupt remote (which a CONCURRENCY_ERROR would
+                // invite). Other failure types continue to surface as a
+                // concurrency error — the gist content is still likely fine.
+                if (refreshErr instanceof GistCorruptError)
+                    throw refreshErr;
                 throw new GistConcurrencyError(expectedEtag, null);
             }
-            // Re-apply our staged dirty contents on top of the refreshed remote.
-            for (const [filename, content] of Object.entries(stagedContents)) {
-                this.cachedFiles.set(filename, content);
+            // Per-file conflict policy (#1235):
+            //  - state.json must fail loud when its remote copy moved under us;
+            //    silently overwriting would violate the StateManager
+            //    optimistic-concurrency contract (state.ts:285-296).
+            //  - Freeform documents (guidelines, etc.) keep last-write-wins —
+            //    `setDocument` callers' intent on a manual write is "overwrite".
+            if (stagedContents[STATE_FILE_NAME] !== undefined) {
+                const baselineBeforeRefresh = preRefreshBaseline.get(STATE_FILE_NAME);
+                const remoteAfterRefresh = this.cachedFiles.get(STATE_FILE_NAME);
+                if (baselineBeforeRefresh !== remoteAfterRefresh) {
+                    warn(MODULE, 'state.json changed remotely while a push was in flight; surfacing GistConcurrencyError instead of clobbering (#1235)');
+                    // Preserve local state.json (and other staged dirty files) in
+                    // memory so the caller can refresh and reapply if appropriate.
+                    reapplyStaged();
+                    throw new GistConcurrencyError(expectedEtag, this.lastFetchedEtag);
+                }
             }
+            // Re-apply our staged dirty contents on top of the refreshed remote.
+            reapplyStaged();
             result = await attempt(this.lastFetchedEtag);
             if (!result.ok && result.status === 412) {
                 warn(MODULE, 'Second push after merge also returned 412; surfacing GistConcurrencyError');
@@ -405,8 +472,11 @@ export class GistStateStore {
                 return false;
             }
         }
-        // Success: flush dirty set and write local cache
+        // Success: flush dirty set and write local cache. Refresh the
+        // per-file baseline to reflect what we just wrote — the next 412
+        // merge re-apply check compares against this.
         this.dirtyFiles.clear();
+        this.baselineFiles = new Map(this.cachedFiles);
         const raw = this.cachedFiles.get(STATE_FILE_NAME);
         if (raw) {
             try {
@@ -489,6 +559,10 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        // Snapshot the just-fetched contents as the per-file baseline (#1235).
+        // The 412 merge path uses this to detect whether a concurrent write
+        // changed `state.json` between this fetch and the next push attempt.
+        this.baselineFiles = new Map(this.cachedFiles);
         // Parse state.json
         const state = this.parseStateFromCache();
         // Write-through to local cache for degraded-mode fallback
@@ -578,6 +652,7 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        this.baselineFiles = new Map(this.cachedFiles);
         // Write-through to local cache
         this.writeLocalStateCache(freshState);
         return { id: data.id, state: freshState };
@@ -602,6 +677,7 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        this.baselineFiles = new Map(this.cachedFiles);
         // Write-through to local cache
         this.writeLocalStateCache(seedState);
         return { id: data.id, state: seedState };

package/dist/core/issue-conversation.js

@@ -205,6 +205,7 @@ export class IssueConversationMonitor {
             title: item.title,
             url: item.html_url,
             userLastCommentedAt: userLastComment.createdAt,
+            userLastCommentBody: userLastComment.body.slice(0, 200) + (userLastComment.body.length > 200 ? '...' : ''),
             labels,
             daysSinceUserComment: daysBetween(userLastCommentTime, new Date()),
         };

package/dist/core/issue-effort.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Action-menu issue effort classification (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt truth table so
+ * the rules are typed, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as the typed-core extractions in
+ * #1245 (compliance-score), #1242 (repo-vet), #1243 (strategy), and
+ * #1252 (pr-quality-rubric).
+ */
+/** Issue types the action menu surfaces. Match the strings the CLI emits in
+ * `data.daily.actionableIssues[*].type`. */
+export type ActionableIssueType = 'needs_response' | 'needs_changes' | 'incomplete_checklist' | 'ci_failing' | 'merge_conflict';
+export type IssueEffort = 'small' | 'medium' | 'large';
+/**
+ * Decide the effort label for an actionable issue based on its type and
+ * how many maintainer hints accompany it. Default falls through to
+ * `medium` for any unrecognized combination — the action-menu workflow
+ * still renders something useful when the CLI surfaces a new issue
+ * type before this function is updated.
+ *
+ * Truth table sourced verbatim from `workflows/action-menu.md`:
+ *
+ * | Effort | Condition |
+ * |--------|-----------|
+ * | small  | needs_response with 0-1 hints, incomplete_checklist |
+ * | medium | needs_response with 2+ hints, needs_changes with 0-2 hints, ci_failing |
+ * | large  | merge_conflict, needs_changes with 3+ hints |
+ */
+export declare function computeIssueEffort(type: ActionableIssueType, hintCount: number): IssueEffort;

package/dist/core/issue-effort.js

@@ -0,0 +1,41 @@
+/**
+ * Action-menu issue effort classification (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt truth table so
+ * the rules are typed, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as the typed-core extractions in
+ * #1245 (compliance-score), #1242 (repo-vet), #1243 (strategy), and
+ * #1252 (pr-quality-rubric).
+ */
+/**
+ * Decide the effort label for an actionable issue based on its type and
+ * how many maintainer hints accompany it. Default falls through to
+ * `medium` for any unrecognized combination — the action-menu workflow
+ * still renders something useful when the CLI surfaces a new issue
+ * type before this function is updated.
+ *
+ * Truth table sourced verbatim from `workflows/action-menu.md`:
+ *
+ * | Effort | Condition |
+ * |--------|-----------|
+ * | small  | needs_response with 0-1 hints, incomplete_checklist |
+ * | medium | needs_response with 2+ hints, needs_changes with 0-2 hints, ci_failing |
+ * | large  | merge_conflict, needs_changes with 3+ hints |
+ */
+export function computeIssueEffort(type, hintCount) {
+    const hints = Math.max(0, hintCount);
+    switch (type) {
+        case 'needs_response':
+            return hints <= 1 ? 'small' : 'medium';
+        case 'incomplete_checklist':
+            return 'small';
+        case 'needs_changes':
+            return hints >= 3 ? 'large' : 'medium';
+        case 'ci_failing':
+            return 'medium';
+        case 'merge_conflict':
+            return 'large';
+        default:
+            return 'medium';
+    }
+}

package/dist/core/maintainer-hints.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Maintainer-hint label constants (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt mapping so the
+ * label strings live in typed code instead of markdown. Adding a new
+ * hint type becomes a single-file change in core; the workflow gets
+ * the new label for free instead of requiring a parallel markdown
+ * edit. Same pattern as #1252.
+ */
+export type MaintainerHint = 'demo_requested' | 'tests_requested' | 'changes_requested' | 'docs_requested' | 'rebase_requested';
+/**
+ * Display labels the action-menu workflow renders for each hint type.
+ * Source of truth — both `data.daily.actionableIssues[*].maintainerHintsLabel`
+ * (computed by the CLI) and the workflow's prose docs reference this map.
+ */
+export declare const MAINTAINER_HINT_LABELS: Record<MaintainerHint, string>;
+/**
+ * Format an array of hints as a comma-joined human label, in the same
+ * order the caller passed them. Unknown hint values are dropped silently —
+ * a future CLI version might emit a hint type the workflow doesn't yet
+ * know about; rendering "undefined" would be worse than omitting it.
+ */
+export declare function formatMaintainerHints(hints: readonly MaintainerHint[] | readonly string[]): string;

package/dist/core/maintainer-hints.js

@@ -0,0 +1,36 @@
+/**
+ * Maintainer-hint label constants (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt mapping so the
+ * label strings live in typed code instead of markdown. Adding a new
+ * hint type becomes a single-file change in core; the workflow gets
+ * the new label for free instead of requiring a parallel markdown
+ * edit. Same pattern as #1252.
+ */
+/**
+ * Display labels the action-menu workflow renders for each hint type.
+ * Source of truth — both `data.daily.actionableIssues[*].maintainerHintsLabel`
+ * (computed by the CLI) and the workflow's prose docs reference this map.
+ */
+export const MAINTAINER_HINT_LABELS = {
+    demo_requested: 'demo/screenshot requested',
+    tests_requested: 'tests requested',
+    changes_requested: 'code changes requested',
+    docs_requested: 'documentation requested',
+    rebase_requested: 'rebase requested',
+};
+/**
+ * Format an array of hints as a comma-joined human label, in the same
+ * order the caller passed them. Unknown hint values are dropped silently —
+ * a future CLI version might emit a hint type the workflow doesn't yet
+ * know about; rendering "undefined" would be worse than omitting it.
+ */
+export function formatMaintainerHints(hints) {
+    const labels = [];
+    for (const h of hints) {
+        const label = MAINTAINER_HINT_LABELS[h];
+        if (label)
+            labels.push(label);
+    }
+    return labels.join(', ');
+}

package/dist/core/placeholder-usernames.js

@@ -20,6 +20,13 @@ const PLACEHOLDER_USERNAMES = [
     'example-user',
     'your-username',
     'your-github-username',
+    // GitHub's mascot accounts. Real users on github.com but seeded into countless
+    // example configs, READMEs, and SDK docs (Octokit's quickstarts use `octocat`
+    // as the canonical login). Treating them as placeholders keeps a stale example
+    // value from silently swapping a real user's PR feed with the mascot's open
+    // PRs in violet-org/boysenberry-repo (octocat's public test fixtures).
+    'octocat',
+    'monalisa',
 ];
 const KNOWN_PLACEHOLDER_USERNAMES = new Set(PLACEHOLDER_USERNAMES);
 export function isPlaceholderUsername(username) {

package/dist/core/pr-quality-rubric.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Canonical PR quality rubric (#1252).
+ *
+ * Single source of truth for the PR-quality checks shared between
+ * `skills/pr-etiquette/SKILL.md` (human-facing checklist) and
+ * `agents/pr-compliance-checker.md` (agent-facing scoring via
+ * `computeComplianceScore` in compliance-score.ts).
+ *
+ * Both surfaces had the same checks listed independently, with the
+ * "< 10 files, < 400 lines ideal" threshold duplicated. Drift was
+ * inevitable as either surface evolved. This module exports the
+ * rubric as structured data so the two consumers cannot drift
+ * silently — `compliance-score.ts` re-exports its WEIGHTS /
+ * FOCUSED_CHANGES from here, and the skill prose references this
+ * file as the canonical definition.
+ *
+ * Same architectural shape as the typed-core extractions in
+ * #858 / #910 / #911 / #1245 / #1242 / #1243 — pull the rubric out
+ * of prose into typed code so it's testable and tunable.
+ */
+export type PRQualityTier = 'required' | 'conditional' | 'optional';
+export interface PRQualityCheck {
+    /** Stable identifier referenced by the agent's scoring code. */
+    id: 'issueReference' | 'description' | 'title' | 'focusedChanges' | 'minimalDiff' | 'tests' | 'docs' | 'branch' | 'screenshots';
+    /** Human-facing label as it appears in the skill checklist. */
+    label: string;
+    /** One-line description for both the skill checklist and the
+     * agent's recommendation prose. */
+    description: string;
+    tier: PRQualityTier;
+    /**
+     * Percent weight in the agent's compliance score, when the check
+     * is part of the scored set. `null` for checks the skill lists but
+     * the agent doesn't currently score (Minimal Diff, Docs, Screenshots).
+     */
+    weight: number | null;
+}
+/**
+ * Canonical "focused changes" thresholds. Mirrored by
+ * compliance-score.ts's `FOCUSED_CHANGES` constant — that file
+ * imports these values.
+ */
+export declare const FOCUSED_CHANGES_THRESHOLDS: {
+    readonly passFiles: 10;
+    readonly passLines: 400;
+    readonly warnFiles: 20;
+    readonly warnLines: 800;
+};
+/**
+ * Title byte budget. Mirrored by compliance-score.ts's
+ * `TITLE_LENGTH_BUDGET` — that file imports this value.
+ */
+export declare const TITLE_LENGTH_BUDGET = 72;
+/**
+ * The full rubric. The order is the order the skill renders the
+ * checklist in; the weights total 100 across the scored entries.
+ */
+export declare const PR_QUALITY_RUBRIC: readonly PRQualityCheck[];
+/**
+ * Look up a check by id. Used by `compliance-score.ts` to wire the
+ * scored checks to their canonical weight without hardcoding the
+ * value in two places.
+ */
+export declare function getRubricCheck(id: PRQualityCheck['id']): PRQualityCheck | undefined;
+/**
+ * Sum of the weights for scored checks. Should equal 100. Tests pin
+ * this so a future edit that fails to balance the weights surfaces
+ * at CI time rather than silently shipping a < 100 rubric.
+ */
+export declare function totalScoredWeight(): number;