@triagepilot/application 1.1.0

package/dist/routing-recovery.d.ts

@@ -0,0 +1,68 @@
+import { type ChangeRequestId, type ProviderConnectionId, type ProviderKind, type RepositoryRef, type RoutingJobPayload, type WorkspaceId } from "@triagepilot/contracts";
+declare const routingRecoveryDecisionIdBrand: unique symbol;
+type RoutingRecoveryDecisionId = string & {
+    readonly [routingRecoveryDecisionIdBrand]: true;
+};
+export type RoutingRecoveryRequest = {
+    decisionId: string;
+} | {
+    changeRequest: {
+        repository: RepositoryRef;
+        externalId: ChangeRequestId;
+        number: number;
+    };
+};
+type ValidatedRoutingRecoveryRequest = {
+    decisionId: RoutingRecoveryDecisionId;
+} | Exclude<RoutingRecoveryRequest, {
+    decisionId: string;
+}>;
+export interface RoutingRecoveryTarget {
+    providerConnectionId: ProviderConnectionId;
+    repository: RepositoryRef;
+    changeRequestId: ChangeRequestId;
+    changeRequestNumber: number;
+}
+export interface RoutingRecoveryCurrentState {
+    state: string;
+    baseRevision: string;
+    headRevision: string;
+    isDraft: boolean;
+}
+export interface EnqueueRoutingRecoveryInput {
+    workspaceId: WorkspaceId;
+    provider: ProviderKind;
+    providerConnectionId: ProviderConnectionId;
+    payload: RoutingJobPayload;
+    idempotencyKey: string;
+}
+export interface RoutingRecoveryPorts {
+    findTarget(input: {
+        workspaceId: WorkspaceId;
+        request: ValidatedRoutingRecoveryRequest;
+    }): Promise<RoutingRecoveryTarget | null>;
+    fetchCurrentState(input: {
+        workspaceId: WorkspaceId;
+    } & RoutingRecoveryTarget): Promise<RoutingRecoveryCurrentState | null>;
+    enqueue(input: EnqueueRoutingRecoveryInput): Promise<{
+        jobId: string;
+    } | null>;
+    createRunId(): string;
+}
+export declare class RoutingRecoveryValidationError extends Error {
+    readonly code: "invalid_target";
+}
+export declare class RoutingRecoveryTargetUnavailableError extends Error {
+    readonly code: "not_found_or_inactive";
+}
+export declare class RoutingRecoveryClosedError extends Error {
+    readonly code: "change_request_closed";
+}
+export declare function queueRoutingRecovery(input: {
+    workspaceId: WorkspaceId;
+    request: RoutingRecoveryRequest;
+}, ports: RoutingRecoveryPorts): Promise<{
+    jobId: string;
+    routingKey: string;
+}>;
+export {};

package/dist/routing-recovery.js

@@ -0,0 +1,150 @@
+import { buildRoutingKey, } from "@triagepilot/contracts";
+const PROVIDERS = new Set(["github", "gitlab", "bitbucket"]);
+const MAX_CHANGE_REQUEST_NUMBER = 2_147_483_647;
+const routingRecoveryDecisionIdBrand = Symbol("RoutingRecoveryDecisionId");
+export class RoutingRecoveryValidationError extends Error {
+    code = "invalid_target";
+}
+export class RoutingRecoveryTargetUnavailableError extends Error {
+    code = "not_found_or_inactive";
+}
+export class RoutingRecoveryClosedError extends Error {
+    code = "change_request_closed";
+}
+export async function queueRoutingRecovery(input, ports) {
+    const request = parseRoutingRecoveryRequest(input.workspaceId, input.request);
+    const target = await ports.findTarget({ workspaceId: input.workspaceId, request });
+    if (target === null) {
+        throw new RoutingRecoveryTargetUnavailableError("Routing recovery target is unavailable in this workspace");
+    }
+    const providerState = await ports.fetchCurrentState({ workspaceId: input.workspaceId, ...target });
+    if (providerState === null) {
+        throw new RoutingRecoveryTargetUnavailableError("Routing recovery target is unavailable in this workspace");
+    }
+    const current = parseCurrentState(providerState);
+    if (current.state !== "open") {
+        throw new RoutingRecoveryClosedError("Only an open change request can be routed again");
+    }
+    const runId = parseRunId(ports.createRunId());
+    const routingKey = `${buildRoutingKey({
+        workspaceId: input.workspaceId,
+        provider: target.repository.provider,
+        repositoryId: target.repository.externalId,
+        changeRequestId: target.changeRequestId,
+        trustedConfigRevision: current.baseRevision,
+        headRevision: current.headRevision,
+        isDraft: current.isDraft,
+    })}:operator:${runId}`;
+    const payload = {
+        kind: "process_change_request",
+        deliveryId: `operator:${runId}`,
+        eventName: "operator.routing_recovery",
+        workspaceId: input.workspaceId,
+        providerConnectionId: target.providerConnectionId,
+        changeRequest: {
+            repository: target.repository,
+            externalId: target.changeRequestId,
+            number: target.changeRequestNumber,
+            baseRevision: current.baseRevision,
+            headRevision: current.headRevision,
+        },
+        isDraft: current.isDraft,
+        routingKey,
+    };
+    const queued = await ports.enqueue({
+        workspaceId: input.workspaceId,
+        provider: target.repository.provider,
+        providerConnectionId: target.providerConnectionId,
+        payload,
+        idempotencyKey: routingKey,
+    });
+    if (queued === null) {
+        throw new RoutingRecoveryTargetUnavailableError("Routing recovery target is unavailable in this workspace");
+    }
+    return { jobId: queued.jobId, routingKey };
+}
+function parseRoutingRecoveryRequest(workspaceId, request) {
+    if (!isNonEmptyString(workspaceId) || !isRecord(request)) {
+        throw new RoutingRecoveryValidationError("Routing recovery target is invalid");
+    }
+    const keys = Object.keys(request);
+    if (keys.length !== 1)
+        throw new RoutingRecoveryValidationError("Exactly one routing recovery target is required");
+    if (keys[0] === "decisionId") {
+        return { decisionId: parseDecisionId(request.decisionId) };
+    }
+    if (keys[0] !== "changeRequest" || !isRecord(request.changeRequest)) {
+        throw new RoutingRecoveryValidationError("Routing recovery target is invalid");
+    }
+    const changeRequest = request.changeRequest;
+    if (!hasExactKeys(changeRequest, ["repository", "externalId", "number"])
+        || !isRecord(changeRequest.repository)
+        || !hasExactKeys(changeRequest.repository, ["provider", "externalId", "owner", "name"])
+        || !PROVIDERS.has(changeRequest.repository.provider)
+        || !isNonEmptyString(changeRequest.repository.externalId)
+        || !isNonEmptyString(changeRequest.repository.owner)
+        || !isNonEmptyString(changeRequest.repository.name)
+        || !isNonEmptyString(changeRequest.externalId)
+        || typeof changeRequest.number !== "number"
+        || !Number.isSafeInteger(changeRequest.number)
+        || changeRequest.number < 1
+        || changeRequest.number > MAX_CHANGE_REQUEST_NUMBER) {
+        throw new RoutingRecoveryValidationError("Routing recovery change-request reference is invalid");
+    }
+    return {
+        changeRequest: {
+            repository: {
+                provider: changeRequest.repository.provider,
+                externalId: changeRequest.repository.externalId.trim(),
+                owner: changeRequest.repository.owner.trim(),
+                name: changeRequest.repository.name.trim(),
+            },
+            externalId: changeRequest.externalId.trim(),
+            number: changeRequest.number,
+        },
+    };
+}
+function parseCurrentState(state) {
+    if (!isRecord(state)
+        || !hasExactKeys(state, ["state", "baseRevision", "headRevision", "isDraft"])
+        || !isNonEmptyString(state.state)
+        || !isNonEmptyString(state.baseRevision)
+        || !isNonEmptyString(state.headRevision)
+        || typeof state.isDraft !== "boolean") {
+        throw new RoutingRecoveryValidationError("Current provider change-request state is invalid");
+    }
+    const normalizedState = state.state.trim().toLowerCase();
+    if (normalizedState !== "open" && normalizedState !== "closed") {
+        throw new RoutingRecoveryValidationError("Current provider change-request state is invalid");
+    }
+    return {
+        state: normalizedState,
+        baseRevision: state.baseRevision.trim(),
+        headRevision: state.headRevision.trim(),
+        isDraft: state.isDraft,
+    };
+}
+function parseDecisionId(value) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(normalized)) {
+        throw new RoutingRecoveryValidationError("Routing recovery decision ID is invalid");
+    }
+    return normalized;
+}
+function parseRunId(value) {
+    if (!isNonEmptyString(value) || !/^[A-Za-z0-9._-]+$/.test(value)) {
+        throw new RoutingRecoveryValidationError("Routing recovery run identity is invalid");
+    }
+    return value;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(record, keys) {
+    const actual = Object.keys(record).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}

package/dist/routing.d.ts

@@ -0,0 +1,96 @@
+import type { EffectiveConfigurationProvenance, EffectiveConfigurationResult } from "@triagepilot/config";
+import { type ActionStatus, type ChangeRequestId, type Clock, type DecisionEventV1, type ExternalActorId, type HumanReviewPolicyJobPayload, type ProviderConnectionId, type RepositoryMode, type RepositoryRef, type RoutingAction, type RoutingJobPayload, type WorkspaceId } from "@triagepilot/contracts";
+import { type ChangedFileMetadata, type ReviewerAbsenceWindow, type RiskScoringResult } from "@triagepilot/core";
+export interface DecisionInput {
+    workspaceId: WorkspaceId;
+    repository: RepositoryRef;
+    deliveryId: string;
+    routingKey: string;
+    changeRequestId: ChangeRequestId;
+    changeRequestNumber: number;
+    headRevision: string;
+    mode: RepositoryMode;
+    action: RoutingAction;
+    actionStatus: ActionStatus;
+    riskScore: number;
+    selectedActors?: ExternalActorId[];
+    noHumanReason?: string;
+    details: unknown;
+    organizationConfigVersion: string | null;
+    repositoryConfigPath: string | null;
+    repositoryConfigRevision: string | null;
+    effectiveConfigHash: string | null;
+    inheritanceMode: EffectiveConfigurationProvenance["inheritanceMode"];
+    configDiagnostics: unknown[];
+    configSources: Record<string, unknown>;
+}
+export interface PersistedDecision {
+    decisionId: string;
+    actionStatus: ActionStatus;
+    actionError: string | null;
+    actionAppliedAt: Date | null;
+}
+export interface PersistedDecisionEventContext extends PersistedDecision {
+    occurredAt: Date;
+}
+export type DecisionEventFactory = (persisted: PersistedDecisionEventContext) => DecisionEventV1;
+export interface RoutingApplicationPorts {
+    resolveConfiguration(job: RoutingJobPayload): Promise<EffectiveConfigurationResult>;
+    provider: {
+        fetchChangeRequestMetadata(job: RoutingJobPayload): Promise<{
+            author: ExternalActorId;
+            sourceBranch: string;
+            targetBranch: string;
+            currentHeadRevision: string;
+        }>;
+        fetchChangedFiles(job: RoutingJobPayload): Promise<ChangedFileMetadata[]>;
+        fetchCommitMessages(job: RoutingJobPayload): Promise<string[]>;
+        fetchCurrentRevisionApprovals(job: RoutingJobPayload): Promise<ExternalActorId[]>;
+        applyActions(input: {
+            workspaceId: WorkspaceId;
+            providerConnectionId: ProviderConnectionId;
+            repository: RepositoryRef;
+            changeRequestId: ChangeRequestId;
+            changeRequestNumber: number;
+            expectedHeadRevision: string;
+            decisionId: string;
+            action: RoutingAction;
+            risk: RiskScoringResult;
+            selectedActors: ExternalActorId[];
+            actorsToRequest: ExternalActorId[];
+            noHumanReason?: string;
+        }): Promise<void>;
+    };
+    reviewerLoad(input: {
+        workspaceId: WorkspaceId;
+        actors: ExternalActorId[];
+    }): Promise<Record<string, number>>;
+    availability: {
+        findActive(input: {
+            workspaceId: WorkspaceId;
+            providerConnectionId: ProviderConnectionId;
+            actors: ExternalActorId[];
+            at: Date;
+        }): Promise<ReviewerAbsenceWindow[]>;
+    };
+    decisions: {
+        persistWithEvent(input: DecisionInput, event: DecisionEventFactory): Promise<PersistedDecision>;
+        markActionSucceeded(decisionId: string, at: Date): Promise<void>;
+        markActionFailed(decisionId: string, error: string, at: Date): Promise<void>;
+    };
+    enqueueReviewPolicy(input: HumanReviewPolicyJobPayload): Promise<void>;
+    clock: Clock;
+}
+export type RoutingOutcome = {
+    status: "skipped";
+    reason: "draft" | "target_branch" | "source_branch" | "stale_revision";
+} | {
+    status: "configuration_failure";
+    decisionId: string;
+} | {
+    status: "decided";
+    decisionId: string;
+    mode: RepositoryMode;
+    actionStatus: ActionStatus;
+};
+export declare function processChangeRequest(job: RoutingJobPayload, ports: RoutingApplicationPorts): Promise<RoutingOutcome>;

package/dist/routing.js

@@ -0,0 +1,221 @@
+import { availableActorsAt, decideRouting, isBranchExcluded, matchOwnership, scorePullRequestRisk, } from "@triagepilot/core";
+export async function processChangeRequest(job, ports) {
+    const configuration = await ports.resolveConfiguration(job);
+    if (!configuration.ok) {
+        const persisted = await ports.decisions.persistWithEvent({
+            ...decisionIdentity(job),
+            mode: "shadow",
+            action: "configuration_failure",
+            actionStatus: "not_applied",
+            riskScore: 0,
+            details: { changeRequestNumber: job.changeRequest.number, diagnostics: configuration.diagnostics },
+            ...persistenceProvenance(configuration.provenance, configuration.diagnostics),
+        }, ({ decisionId, occurredAt }) => decisionEvent({
+            job,
+            decisionId,
+            mode: "shadow",
+            action: "configuration_failure",
+            riskScore: 0,
+            selectedActors: [],
+            effectiveConfigurationHash: configuration.provenance.effectiveHash ?? "invalid",
+            occurredAt,
+        }));
+        return { status: "configuration_failure", decisionId: persisted.decisionId };
+    }
+    const { config, provenance } = configuration;
+    if (job.isDraft && !config.routing.includeDraftPullRequests) {
+        return { status: "skipped", reason: "draft" };
+    }
+    const metadata = await ports.provider.fetchChangeRequestMetadata(job);
+    if (metadata.currentHeadRevision !== job.changeRequest.headRevision) {
+        return { status: "skipped", reason: "stale_revision" };
+    }
+    if (config.routing.excludeTargetBranches.includes(metadata.targetBranch)) {
+        return { status: "skipped", reason: "target_branch" };
+    }
+    if (isBranchExcluded(metadata.sourceBranch, config.routing.excludeSourceBranchPatterns)) {
+        return { status: "skipped", reason: "source_branch" };
+    }
+    const [changedFiles, commitMessages] = await Promise.all([
+        ports.provider.fetchChangedFiles(job),
+        ports.provider.fetchCommitMessages(job),
+    ]);
+    const ownership = matchOwnership({
+        files: changedFiles.map((file) => file.path),
+        rules: config.ownership.rules,
+        fallbackReviewers: config.ownership.fallbackReviewers,
+    });
+    const availabilityEvaluatedAt = ports.clock.now();
+    const availabilityActors = availableActorsAt({
+        actors: [...ownership.preferredReviewers, ...ownership.eligibleReviewers],
+        absences: [],
+        now: availabilityEvaluatedAt,
+    });
+    const absences = await ports.availability.findActive({
+        workspaceId: job.workspaceId,
+        providerConnectionId: job.providerConnectionId,
+        actors: availabilityActors,
+        at: availabilityEvaluatedAt,
+    });
+    const canonicalEligibleReviewers = availableActorsAt({
+        actors: ownership.eligibleReviewers,
+        absences: [],
+        now: availabilityEvaluatedAt,
+    });
+    const availableEligibleReviewers = availableActorsAt({
+        actors: ownership.eligibleReviewers,
+        absences,
+        now: availabilityEvaluatedAt,
+    });
+    const availablePreferredReviewers = availableActorsAt({
+        actors: ownership.preferredReviewers,
+        absences,
+        now: availabilityEvaluatedAt,
+    });
+    const availableEligibleSet = new Set(availableEligibleReviewers);
+    const excludedReviewers = canonicalEligibleReviewers.filter((actor) => !availableEligibleSet.has(actor));
+    const load = await ports.reviewerLoad({
+        workspaceId: job.workspaceId,
+        actors: availableEligibleReviewers,
+    });
+    const risk = scorePullRequestRisk({
+        files: changedFiles,
+        author: metadata.author,
+        branchName: metadata.sourceBranch,
+        commitMessages,
+        config: config.risk,
+    });
+    const existingApprovedReviewers = risk.tier === "low"
+        ? []
+        : await ports.provider.fetchCurrentRevisionApprovals(job);
+    const routing = decideRouting({
+        risk,
+        author: metadata.author,
+        preferredReviewers: availablePreferredReviewers,
+        eligibleReviewers: availableEligibleReviewers,
+        existingApprovedReviewers,
+        load,
+        highRiskReviewers: config.routing.highRiskReviewers,
+        selectionKey: `${job.changeRequest.repository.owner}/${job.changeRequest.repository.name}#${job.changeRequest.number}`,
+    });
+    const initialActionStatus = config.mode === "enforce" && routing.action !== "no_eligible_reviewer"
+        ? "pending"
+        : "not_applied";
+    const decision = {
+        ...decisionIdentity(job),
+        mode: config.mode,
+        action: routing.action,
+        actionStatus: initialActionStatus,
+        riskScore: risk.score,
+        details: {
+            changeRequestNumber: job.changeRequest.number,
+            risk,
+            ownership,
+            availability: {
+                evaluatedAt: availabilityEvaluatedAt.toISOString(),
+                excludedReviewers,
+            },
+            routing,
+        },
+        ...persistenceProvenance(provenance, []),
+    };
+    if (routing.selectedReviewers.length > 0)
+        decision.selectedActors = routing.selectedReviewers;
+    if (routing.noHumanReason !== undefined)
+        decision.noHumanReason = routing.noHumanReason;
+    const persisted = await ports.decisions.persistWithEvent(decision, ({ decisionId, occurredAt }) => decisionEvent({
+        job,
+        decisionId,
+        mode: config.mode,
+        action: routing.action,
+        riskScore: risk.score,
+        selectedActors: routing.selectedReviewers,
+        effectiveConfigurationHash: provenance.effectiveHash ?? "invalid",
+        occurredAt,
+    }));
+    if (persisted.actionStatus === "succeeded") {
+        return { status: "decided", decisionId: persisted.decisionId, mode: config.mode, actionStatus: "succeeded" };
+    }
+    let actionStatus = persisted.actionStatus;
+    if (config.mode === "enforce") {
+        try {
+            await ports.provider.applyActions({
+                workspaceId: job.workspaceId,
+                providerConnectionId: job.providerConnectionId,
+                repository: job.changeRequest.repository,
+                changeRequestId: job.changeRequest.externalId,
+                changeRequestNumber: job.changeRequest.number,
+                expectedHeadRevision: job.changeRequest.headRevision,
+                decisionId: persisted.decisionId,
+                action: routing.action,
+                risk,
+                selectedActors: routing.selectedReviewers,
+                actorsToRequest: routing.reviewersToRequest,
+                ...(routing.noHumanReason === undefined ? {} : { noHumanReason: routing.noHumanReason }),
+            });
+            if (routing.action === "request_human_review") {
+                await ports.enqueueReviewPolicy({
+                    kind: "evaluate_human_review_policy",
+                    deliveryId: `routing-policy:${job.deliveryId}`,
+                    workspaceId: job.workspaceId,
+                    providerConnectionId: job.providerConnectionId,
+                    changeRequest: {
+                        repository: job.changeRequest.repository,
+                        externalId: job.changeRequest.externalId,
+                        number: job.changeRequest.number,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            await ports.decisions.markActionFailed(persisted.decisionId, error instanceof Error ? error.message : "provider action failed", ports.clock.now());
+            throw error;
+        }
+        if (persisted.actionStatus === "pending") {
+            await ports.decisions.markActionSucceeded(persisted.decisionId, ports.clock.now());
+            actionStatus = "succeeded";
+        }
+    }
+    return { status: "decided", decisionId: persisted.decisionId, mode: config.mode, actionStatus };
+}
+function decisionIdentity(job) {
+    return {
+        workspaceId: job.workspaceId,
+        repository: job.changeRequest.repository,
+        deliveryId: job.deliveryId,
+        routingKey: job.routingKey,
+        changeRequestId: job.changeRequest.externalId,
+        changeRequestNumber: job.changeRequest.number,
+        headRevision: job.changeRequest.headRevision,
+    };
+}
+function persistenceProvenance(provenance, diagnostics) {
+    return {
+        organizationConfigVersion: provenance.organizationVersion,
+        repositoryConfigPath: provenance.repositoryPath,
+        repositoryConfigRevision: provenance.repositoryRevision,
+        effectiveConfigHash: provenance.effectiveHash,
+        inheritanceMode: provenance.inheritanceMode,
+        configDiagnostics: diagnostics,
+        configSources: provenance.sources,
+    };
+}
+function decisionEvent(input) {
+    return {
+        schemaVersion: 1,
+        eventType: "routing_decision",
+        eventId: `decision:${input.decisionId}:v1`,
+        occurredAt: input.occurredAt.toISOString(),
+        workspaceId: input.job.workspaceId,
+        provider: input.job.changeRequest.repository.provider,
+        decisionId: input.decisionId,
+        repositoryId: input.job.changeRequest.repository.externalId,
+        changeRequestId: input.job.changeRequest.externalId,
+        routingKey: input.job.routingKey,
+        mode: input.mode,
+        action: input.action,
+        riskScore: input.riskScore,
+        selectedActors: input.selectedActors,
+        effectiveConfigurationHash: input.effectiveConfigurationHash,
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@triagepilot/application",
+  "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/application"
+  },
+  "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/config": "1.1.0",
+    "@triagepilot/contracts": "1.1.0",
+    "@triagepilot/core": "1.1.0"
+  },
+  "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 && tsc -p tsconfig.type-tests.json"
+  }
+}