@triagepilot/core 1.1.0

package/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 Miroslav Babjak
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/dist/availability.d.ts

@@ -0,0 +1,25 @@
+export interface ReviewerAbsenceWindow {
+    externalActorId: string;
+    startAt: Date;
+    endAt: Date;
+}
+export declare function availableActorsAt(input: {
+    actors: string[];
+    absences: ReviewerAbsenceWindow[];
+    now: Date;
+}): string[];
+export declare function selectReplacement(input: {
+    author: string;
+    unavailableActor: string;
+    activeCohort: string[];
+    approvedActors: string[];
+    originalEligibleActors: string[];
+    originalPreferredActors: string[];
+    absences: ReviewerAbsenceWindow[];
+    load: Record<string, number>;
+    selectionKey: string;
+    now: Date;
+}): {
+    replacementActor: string | null;
+    candidates: string[];
+};

package/dist/availability.js

@@ -0,0 +1,31 @@
+import { normalizeReviewer, selectTieredReviewers, uniqueReviewers } from "./reviewer-selection.js";
+export function availableActorsAt(input) {
+    const unavailableActors = new Set(input.absences
+        .filter((absence) => absence.startAt <= input.now && input.now < absence.endAt)
+        .map((absence) => normalizeReviewer(absence.externalActorId))
+        .filter(Boolean));
+    return uniqueReviewers(input.actors).filter((actor) => !unavailableActors.has(actor));
+}
+export function selectReplacement(input) {
+    const excludedActors = new Set(uniqueReviewers([
+        input.author,
+        input.unavailableActor,
+        ...input.activeCohort,
+        ...input.approvedActors,
+    ]));
+    const candidates = availableActorsAt({
+        actors: input.originalEligibleActors,
+        absences: input.absences,
+        now: input.now,
+    })
+        .filter((actor) => !excludedActors.has(actor))
+        .sort();
+    const replacementActor = selectTieredReviewers({
+        candidates,
+        preferredReviewers: input.originalPreferredActors,
+        load: input.load,
+        selectionKey: input.selectionKey,
+        count: 1,
+    })[0] ?? null;
+    return { replacementActor, candidates };
+}

package/dist/branch.d.ts

@@ -0,0 +1 @@
+export declare function isBranchExcluded(branch: string, patterns: string[]): boolean;

package/dist/branch.js

@@ -0,0 +1,4 @@
+import { minimatch } from "minimatch";
+export function isBranchExcluded(branch, patterns) {
+    return patterns.some((pattern) => minimatch(branch, pattern, { dot: true }));
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./branch.js";
+export * from "./availability.js";
+export * from "./ownership.js";
+export * from "./review-policy.js";
+export * from "./risk.js";
+export * from "./routing.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./branch.js";
+export * from "./availability.js";
+export * from "./ownership.js";
+export * from "./review-policy.js";
+export * from "./risk.js";
+export * from "./routing.js";

package/dist/ownership.d.ts

@@ -0,0 +1,21 @@
+export interface OwnershipRule {
+    paths: string[];
+    reviewers: string[];
+}
+export interface OwnershipInput {
+    files: string[];
+    rules: OwnershipRule[];
+    fallbackReviewers: string[];
+}
+export interface OwnershipMatchResult {
+    matchedRules: Array<{
+        pattern: string;
+        reviewers: string[];
+        matchedFiles: string[];
+    }>;
+    preferredReviewers: string[];
+    eligibleReviewers: string[];
+    uncoveredFiles: string[];
+    usedFallback: boolean;
+}
+export declare function matchOwnership(input: OwnershipInput): OwnershipMatchResult;

package/dist/ownership.js

@@ -0,0 +1,24 @@
+import { minimatch } from "minimatch";
+export function matchOwnership(input) {
+    const matchedRules = input.rules
+        .flatMap((rule) => rule.paths.map((pattern) => ({
+        pattern,
+        reviewers: rule.reviewers,
+        matchedFiles: input.files.filter((file) => minimatch(file, pattern, { dot: true, matchBase: true })),
+    })))
+        .filter((rule) => rule.matchedFiles.length > 0);
+    const matchedFiles = new Set(matchedRules.flatMap((rule) => rule.matchedFiles));
+    const matchedReviewers = dedupe(matchedRules.flatMap((rule) => rule.reviewers));
+    const usedFallback = matchedReviewers.length === 0;
+    const preferredReviewers = usedFallback ? dedupe(input.fallbackReviewers) : matchedReviewers;
+    return {
+        matchedRules,
+        preferredReviewers,
+        eligibleReviewers: dedupe([...preferredReviewers, ...input.fallbackReviewers]),
+        uncoveredFiles: input.files.filter((file) => !matchedFiles.has(file)),
+        usedFallback,
+    };
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}

package/dist/review-policy.d.ts

@@ -0,0 +1,20 @@
+export type HumanReviewPolicyState = "in_progress" | "success" | "failure";
+export interface ReviewMetadata {
+    actor: string;
+    actorType?: "human" | "bot" | string;
+    state: "approved" | "changes_requested" | "commented" | "pending" | "dismissed" | string;
+    submittedAt: string | null;
+}
+export interface HumanReviewPolicyEvaluationInput {
+    route: "no_human" | "human_review" | "no_eligible_reviewer";
+    selectedReviewers: string[];
+    requiredApprovalCount?: number;
+    reviews: ReviewMetadata[];
+}
+export interface HumanReviewPolicyEvaluation {
+    state: HumanReviewPolicyState;
+    summary: string;
+    missingReviewers: string[];
+}
+export declare function evaluateHumanReviewPolicy(input: HumanReviewPolicyEvaluationInput): HumanReviewPolicyEvaluation;
+export declare function activeApprovedReviewers(reviews: ReviewMetadata[]): string[];

package/dist/review-policy.js

@@ -0,0 +1,67 @@
+export function evaluateHumanReviewPolicy(input) {
+    if (input.route === "no_human") {
+        return {
+            state: "success",
+            summary: "No human approval is required for this pull request.",
+            missingReviewers: [],
+        };
+    }
+    if (input.route === "no_eligible_reviewer") {
+        return {
+            state: "failure",
+            summary: "No eligible human reviewer is available for this required review.",
+            missingReviewers: [],
+        };
+    }
+    const approvedReviewers = new Set(activeApprovedReviewers(input.reviews).map(normalizeReviewer));
+    const requiredApprovalCount = input.requiredApprovalCount ?? input.selectedReviewers.length;
+    const missingApprovalCount = Math.max(requiredApprovalCount - approvedReviewers.size, 0);
+    const missingReviewers = input.selectedReviewers
+        .filter((reviewer) => !approvedReviewers.has(normalizeReviewer(reviewer)))
+        .slice(0, missingApprovalCount);
+    if (missingApprovalCount === 0) {
+        return {
+            state: "success",
+            summary: "Required human approval count met.",
+            missingReviewers: [],
+        };
+    }
+    return {
+        state: "in_progress",
+        summary: missingApprovalCount === 1
+            ? "Waiting for 1 more human approval."
+            : `Waiting for ${missingApprovalCount} more human approvals.`,
+        missingReviewers,
+    };
+}
+export function activeApprovedReviewers(reviews) {
+    const latestReviews = new Map();
+    reviews.forEach((review, index) => {
+        if (review.actorType !== undefined && review.actorType !== "human")
+            return;
+        const actor = normalizeReviewer(review.actor);
+        const submittedAt = parseSubmittedAt(review.submittedAt);
+        const latest = latestReviews.get(actor);
+        if (!latest || isLaterReview({ submittedAt, index }, latest)) {
+            latestReviews.set(actor, { review, submittedAt, index });
+        }
+    });
+    return [...latestReviews.entries()]
+        .filter(([, entry]) => entry.review.state === "approved")
+        .map(([actor]) => `@${actor}`);
+}
+function normalizeReviewer(reviewer) {
+    return reviewer.replace(/^@/, "").toLowerCase();
+}
+function isLaterReview(candidate, current) {
+    if (candidate.submittedAt === null || current.submittedAt === null)
+        return candidate.index > current.index;
+    return candidate.submittedAt > current.submittedAt ||
+        (candidate.submittedAt === current.submittedAt && candidate.index > current.index);
+}
+function parseSubmittedAt(value) {
+    if (value === null)
+        return null;
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? null : timestamp;
+}

package/dist/reviewer-selection.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeReviewer(reviewer: string): string;
+export declare function uniqueReviewers(reviewers: string[]): string[];
+export declare function selectTieredReviewers(input: {
+    candidates: string[];
+    preferredReviewers: string[];
+    load: Record<string, number>;
+    selectionKey: string;
+    count: number;
+}): string[];

package/dist/reviewer-selection.js

@@ -0,0 +1,33 @@
+export function normalizeReviewer(reviewer) {
+    const normalized = reviewer.trim().replace(/^@/, "").toLowerCase();
+    return normalized ? `@${normalized}` : "";
+}
+export function uniqueReviewers(reviewers) {
+    return [...new Set(reviewers.map(normalizeReviewer).filter(Boolean))];
+}
+export function selectTieredReviewers(input) {
+    const candidateSet = new Set(input.candidates);
+    const preferredCandidates = uniqueReviewers(input.preferredReviewers).filter((reviewer) => candidateSet.has(reviewer));
+    const preferredCandidateSet = new Set(preferredCandidates);
+    const fallbackCandidates = input.candidates.filter((reviewer) => !preferredCandidateSet.has(reviewer));
+    const selectedPreferredReviewers = selectLowestLoadReviewers(preferredCandidates, input.load, input.selectionKey, input.count);
+    const selectedFallbackReviewers = selectLowestLoadReviewers(fallbackCandidates, input.load, input.selectionKey, input.count - selectedPreferredReviewers.length);
+    return [...selectedPreferredReviewers, ...selectedFallbackReviewers];
+}
+function selectLowestLoadReviewers(candidates, load, selectionKey, count) {
+    return [...candidates].sort((a, b) => {
+        const loadDifference = (load[a] ?? 0) - (load[b] ?? 0);
+        if (loadDifference !== 0)
+            return loadDifference;
+        const rankDifference = stableRank(`${selectionKey}:${a}`) - stableRank(`${selectionKey}:${b}`);
+        return rankDifference === 0 ? a.localeCompare(b) : rankDifference;
+    }).slice(0, count);
+}
+function stableRank(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash;
+}

package/dist/risk.d.ts

@@ -0,0 +1,49 @@
+import type { RiskTier, ScoreComponent } from "@triagepilot/contracts";
+export declare const CLASSIFIER_VERSION = "risk-v2";
+export interface ChangedFileMetadata {
+    path: string;
+    additions: number;
+    deletions: number;
+}
+export interface RiskPathConfig {
+    pattern: string;
+    weight: number;
+    tag: string;
+}
+export interface RiskSuppressorConfig {
+    ifAllMatch: string[];
+    ceiling: number;
+}
+export interface AiAuthorshipConfig {
+    enabled: boolean;
+    modifier: number;
+}
+export interface RiskThresholdConfig {
+    low: number;
+    high: number;
+}
+export interface RiskSizeConfig {
+    highChangedFiles: number;
+    highChangedLines: number;
+}
+export interface RiskScoringConfig {
+    size: RiskSizeConfig;
+    thresholds: RiskThresholdConfig;
+    paths: RiskPathConfig[];
+    suppressors: RiskSuppressorConfig[];
+    aiAuthorship: AiAuthorshipConfig;
+}
+export interface RiskScoringInput {
+    files: ChangedFileMetadata[];
+    author: string;
+    branchName: string;
+    commitMessages: string[];
+    config: RiskScoringConfig;
+}
+export interface RiskScoringResult {
+    classifierVersion: typeof CLASSIFIER_VERSION;
+    score: number;
+    tier: RiskTier;
+    components: ScoreComponent[];
+}
+export declare function scorePullRequestRisk(input: RiskScoringInput): RiskScoringResult;

package/dist/risk.js

@@ -0,0 +1,164 @@
+import { minimatch } from "minimatch";
+export const CLASSIFIER_VERSION = "risk-v2";
+const LOCKFILE_NAMES = new Set([
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lockb",
+    "Cargo.lock",
+    "Gemfile.lock",
+]);
+const MIGRATION_OR_SCHEMA_PATTERNS = [
+    "**/migrations/**",
+    "migrations/**",
+    "**/migration/**",
+    "migration/**",
+    "**/schema/**",
+    "schema/**",
+    "**/schema.sql",
+    "**/schema.ts",
+    "**/schema.prisma",
+    "prisma/schema.prisma",
+];
+const TEST_PATH_PATTERNS = ["**/*.spec.ts", "**/*.test.ts", "**/__tests__/**", "test/**", "tests/**"];
+const AI_BRANCH_PREFIXES = ["codex/", "copilot/", "cursor/", "devin/", "lovable/"];
+const AI_AUTHORS = new Set(["copilot", "copilot-swe-agent", "devin-ai-integration", "lovable"]);
+const AI_COAUTHOR_MARKERS = ["copilot", "codex", "cursor", "devin", "lovable"];
+export function scorePullRequestRisk(input) {
+    const components = [];
+    const { config, files } = input;
+    const scoredFiles = files.filter((file) => !isTestPath(file.path));
+    if (scoredFiles.length > 0) {
+        components.push({
+            reason: "changed_file_count",
+            score: Math.min(20, Math.ceil(scoredFiles.length / 5) * 5),
+            detail: `${scoredFiles.length} changed file${scoredFiles.length === 1 ? "" : "s"}`,
+        });
+    }
+    const lineDelta = scoredFiles.reduce((sum, file) => sum + file.additions + file.deletions, 0);
+    if (lineDelta >= 200) {
+        components.push({
+            reason: "large_line_delta",
+            score: 15,
+            detail: `${lineDelta} changed lines`,
+        });
+    }
+    for (const riskPath of config.paths) {
+        const matchedFiles = scoredFiles.filter((file) => matchesPath(file.path, riskPath.pattern));
+        if (matchedFiles.length > 0) {
+            components.push({
+                reason: `high_risk_path:${riskPath.tag}`,
+                score: riskPath.weight,
+                detail: `${matchedFiles.length} file${matchedFiles.length === 1 ? "" : "s"} matched ${riskPath.pattern}`,
+            });
+        }
+    }
+    if (files.some((file) => LOCKFILE_NAMES.has(pathBasename(file.path)))) {
+        components.push({
+            reason: "dependency_lockfile_change",
+            score: 15,
+            detail: "Dependency lockfile changed",
+        });
+    }
+    if (files.some((file) => MIGRATION_OR_SCHEMA_PATTERNS.some((pattern) => matchesPath(file.path, pattern)))) {
+        components.push({
+            reason: "migration_or_schema_change",
+            score: 20,
+            detail: "Migration or schema file changed",
+        });
+    }
+    if (config.aiAuthorship.enabled && hasAiAuthorshipSignal(input)) {
+        components.push({
+            reason: "ai_authorship_signal",
+            score: config.aiAuthorship.modifier,
+            detail: "Author, branch, or commit metadata indicates AI-authored changes",
+        });
+    }
+    const reachedFileThreshold = scoredFiles.length >= config.size.highChangedFiles;
+    const reachedLineThreshold = lineDelta >= config.size.highChangedLines;
+    const sizeEscalated = reachedFileThreshold || reachedLineThreshold;
+    if (sizeEscalated) {
+        const scoreFloor = Math.min(100, config.thresholds.high + 1);
+        components.push({
+            reason: "large_change_size",
+            score: Math.max(0, scoreFloor - sumComponentScores(components)),
+            detail: formatSizeEscalationDetail({
+                changedFiles: scoredFiles.length,
+                changedLines: lineDelta,
+                highChangedFiles: config.size.highChangedFiles,
+                highChangedLines: config.size.highChangedLines,
+                reachedFileThreshold,
+                reachedLineThreshold,
+            }),
+        });
+    }
+    let score = Math.min(100, sumComponentScores(components));
+    const suppressor = findMatchingSuppressor(files, config.suppressors);
+    if (suppressor) {
+        if (!sizeEscalated) {
+            score = Math.min(score, suppressor.ceiling);
+        }
+        components.push({
+            reason: "docs_or_test_suppressor",
+            score: 0,
+            detail: sizeEscalated
+                ? "Risk suppressor ignored for a size-escalated pull request"
+                : `Risk score capped at ${suppressor.ceiling}`,
+        });
+    }
+    return {
+        classifierVersion: CLASSIFIER_VERSION,
+        score,
+        tier: sizeEscalated ? "high" : tierForScore(score, config),
+        components,
+    };
+}
+function sumComponentScores(components) {
+    return components.reduce((sum, component) => sum + component.score, 0);
+}
+function tierForScore(score, config) {
+    if (score <= config.thresholds.low) {
+        return "low";
+    }
+    if (score <= config.thresholds.high) {
+        return "medium";
+    }
+    return "high";
+}
+function findMatchingSuppressor(files, suppressors) {
+    if (files.length === 0) {
+        return undefined;
+    }
+    return suppressors.find((suppressor) => suppressor.ifAllMatch.length > 0 &&
+        files.every((file) => suppressor.ifAllMatch.some((pattern) => matchesPath(file.path, pattern))));
+}
+function hasAiAuthorshipSignal(input) {
+    const author = input.author.toLowerCase();
+    const branchName = input.branchName.toLowerCase();
+    return (AI_AUTHORS.has(author) ||
+        AI_BRANCH_PREFIXES.some((prefix) => branchName.startsWith(prefix)) ||
+        input.commitMessages.some(hasAiCommitMarker));
+}
+function hasAiCommitMarker(message) {
+    return message
+        .toLowerCase()
+        .split(/\r?\n/)
+        .some((line) => line.trimStart().startsWith("co-authored-by:") &&
+        AI_COAUTHOR_MARKERS.some((marker) => line.includes(marker)));
+}
+function matchesPath(path, pattern) {
+    return minimatch(path, pattern, { dot: true, matchBase: true });
+}
+function isTestPath(path) {
+    return TEST_PATH_PATTERNS.some((pattern) => matchesPath(path, pattern));
+}
+function formatSizeEscalationDetail({ changedFiles, changedLines, highChangedFiles, highChangedLines, reachedFileThreshold, reachedLineThreshold, }) {
+    const thresholds = [
+        reachedFileThreshold && `${highChangedFiles} file threshold`,
+        reachedLineThreshold && `${highChangedLines} line threshold`,
+    ].filter((threshold) => Boolean(threshold));
+    return `${changedFiles} non-test changed file${changedFiles === 1 ? "" : "s"}, ${changedLines} non-test changed lines; reached ${thresholds.join(" and ")}`;
+}
+function pathBasename(path) {
+    return path.split("/").at(-1) ?? path;
+}

package/dist/routing.d.ts

@@ -0,0 +1,25 @@
+import type { RiskTier, RoutingAction } from "@triagepilot/contracts";
+export interface RoutingInput {
+    risk: {
+        score: number;
+        tier: RiskTier;
+    };
+    author: string;
+    preferredReviewers?: string[];
+    eligibleReviewers: string[];
+    existingApprovedReviewers?: string[];
+    load: Record<string, number>;
+    highRiskReviewers: 1 | 2;
+    selectionKey: string;
+}
+export interface RoutingDecision {
+    action: Exclude<RoutingAction, "configuration_failure">;
+    candidates: string[];
+    requestedReviewerCount: number;
+    selectedReviewers: string[];
+    reviewersToRequest: string[];
+    reviewerShortfall: number;
+    noHumanReason?: string;
+    loadSnapshot: Record<string, number>;
+}
+export declare function decideRouting(input: RoutingInput): RoutingDecision;

package/dist/routing.js

@@ -0,0 +1,51 @@
+import { normalizeReviewer, selectTieredReviewers, uniqueReviewers } from "./reviewer-selection.js";
+export function decideRouting(input) {
+    const existingApprovedReviewers = uniqueReviewers(input.existingApprovedReviewers ?? []).filter((reviewer) => reviewer !== normalizeReviewer(input.author));
+    const candidates = uniqueReviewers(input.eligibleReviewers)
+        .filter((reviewer) => reviewer !== normalizeReviewer(input.author) && !existingApprovedReviewers.includes(reviewer))
+        .sort();
+    const loadSnapshot = Object.fromEntries(candidates.map((candidate) => [candidate, input.load[candidate] ?? 0]));
+    if (input.risk.tier === "low") {
+        return {
+            action: "policy_approval",
+            candidates,
+            requestedReviewerCount: 0,
+            selectedReviewers: [],
+            reviewersToRequest: [],
+            reviewerShortfall: 0,
+            noHumanReason: "risk_at_or_below_low_threshold",
+            loadSnapshot,
+        };
+    }
+    const requestedReviewerCount = input.risk.tier === "high" ? input.highRiskReviewers : 1;
+    const reviewersToRequest = selectTieredReviewers({
+        candidates,
+        preferredReviewers: input.preferredReviewers ?? [],
+        load: input.load,
+        selectionKey: input.selectionKey,
+        count: requestedReviewerCount,
+    });
+    const selectedReviewers = reviewersToRequest;
+    const reviewerShortfall = requestedReviewerCount - selectedReviewers.length;
+    if (selectedReviewers.length === 0) {
+        return {
+            action: "no_eligible_reviewer",
+            candidates,
+            requestedReviewerCount,
+            selectedReviewers,
+            reviewersToRequest,
+            reviewerShortfall,
+            noHumanReason: "no_eligible_reviewer",
+            loadSnapshot,
+        };
+    }
+    return {
+        action: "request_human_review",
+        candidates,
+        requestedReviewerCount,
+        selectedReviewers,
+        reviewersToRequest,
+        reviewerShortfall,
+        loadSnapshot,
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@triagepilot/core",
+  "version": "1.1.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TriagePilot/triage-pilot.git",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@triagepilot/contracts": "1.1.0",
+    "minimatch": "^10.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "publishedAt": "2026-09-22T09:41:47.000Z",
+  "futureLicenseEffectiveAt": "2028-09-22T09:41:47.000Z",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit"
+  }
+}