@snappedly-tools/shipyard 0.8.0 → 0.9.0

package/dist/publication-BPoy_M9M.d.ts

@@ -0,0 +1,1200 @@
+declare const WORKFLOW_CONTRACT_VERSION: 1;
+type WorkItemKind = "planning-spec" | "executable-issue" | "pr-repair";
+type RiskLevel = "low" | "medium" | "high" | "critical";
+type WorkRisk = RiskLevel | "unknown";
+type WorkScope = "small" | "substantial" | "unknown";
+type WorkflowPhase = "triage" | "implementation" | "checking" | "review" | "repair" | "handoff" | "merge" | "release-verification";
+type LifecycleState = "queued" | "waiting-info" | "authorized" | "implementing" | "checking" | "reviewing" | "repairing" | "human-review" | "merged" | "release-verifying" | "completed" | "failed" | "blocked" | "cancelled";
+type PhaseOutcome = "completed" | "needs-info" | "blocked" | "failed" | "cancelled";
+type CheckStatus = "passed" | "failed" | "incomplete" | "blocked" | "unknown";
+type FindingSeverity = "info" | "low" | "medium" | "high" | "critical";
+type ReviewAxis = "standards" | "spec" | "interface";
+type FindingDisposition = "open" | "fixed" | "rejected" | "accepted" | "deferred";
+interface WorkIdentity {
+    readonly repository: string;
+    readonly itemId: string;
+    readonly kind: WorkItemKind;
+}
+interface SourceReference {
+    readonly provider: "github" | "slack" | "manual";
+    readonly repository: string;
+    readonly itemId: string;
+    readonly url?: string;
+    /** Original content is retained durably but must not be echoed to an unauthorized destination. */
+    readonly originalBody: string;
+    readonly author?: string;
+}
+interface RevisionReference {
+    readonly branch: string;
+    readonly sha: string;
+}
+interface Authorization {
+    readonly status: "pending" | "approved" | "withdrawn";
+    readonly actor?: string;
+    readonly actorRole?: "maintainer" | "owner" | "policy";
+    readonly approvedAt?: string;
+}
+interface VerificationPlan {
+    readonly checks: readonly string[];
+    readonly artifacts: readonly string[];
+}
+interface WorkBrief {
+    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
+    readonly id: string;
+    readonly revision: number;
+    readonly hash: string;
+    readonly identity: WorkIdentity;
+    readonly source: SourceReference;
+    readonly problem: string;
+    readonly evidence: readonly string[];
+    readonly acceptanceCriteria: readonly string[];
+    readonly exclusions: readonly string[];
+    readonly risk: WorkRisk;
+    readonly scope?: WorkScope;
+    readonly verification: VerificationPlan;
+    readonly unresolvedQuestions: readonly string[];
+    readonly authorization: Authorization;
+    readonly base: RevisionReference;
+    readonly policyRevision: string;
+    readonly skillRevision: string;
+    readonly createdAt: string;
+}
+interface CheckCommand {
+    readonly name: string;
+    readonly command: string;
+    readonly required: boolean;
+}
+interface PhaseBudget {
+    readonly maxAttempts: number;
+    readonly timeoutSeconds: number;
+}
+type AgentRole = "routine" | "strong";
+interface AgentModelRoles {
+    readonly routine: string;
+    readonly strong: string;
+}
+type WorkerPolicy = {
+    readonly provider: string;
+    readonly sandbox: string;
+    readonly skillRevision: string;
+} & ({
+    readonly model: string;
+    readonly models?: never;
+} | {
+    readonly model?: never;
+    readonly models: AgentModelRoles;
+});
+interface AgentSelection {
+    readonly provider: string;
+    readonly model: string;
+    readonly role: AgentRole;
+}
+interface RepositoryPolicy {
+    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
+    readonly repository: string;
+    readonly revision: string;
+    readonly baseBranch: string;
+    readonly issueClosure: "merge-and-ci" | "staging-verification" | "production-verification";
+    readonly authorization: {
+        readonly required: boolean;
+        readonly allowedActors: readonly ("maintainer" | "owner" | "policy")[];
+        readonly autoStartRisk: readonly RiskLevel[];
+    };
+    readonly worker: WorkerPolicy;
+    readonly checks: readonly CheckCommand[];
+    readonly phaseBudgets: Readonly<Record<WorkflowPhase, PhaseBudget>>;
+    readonly repairBudget: {
+        readonly maxBatches: number;
+        readonly maxFollowUps: number;
+    };
+}
+/** Whether a brief carries an authorization accepted by this repository policy. */
+declare const isAuthorizationAllowed: (brief: Pick<WorkBrief, "authorization">, policy: Pick<RepositoryPolicy, "authorization">) => boolean;
+interface CheckEvidence {
+    readonly name: string;
+    readonly command: string;
+    readonly status: CheckStatus;
+    readonly summary: string;
+    /** Candidate identity for checks that are used as a lifecycle gate. */
+    readonly baseSha?: string;
+    readonly headSha?: string;
+    readonly briefHash?: string;
+    readonly startedAt?: string;
+    readonly completedAt?: string;
+    readonly exitCode?: number;
+    readonly artifactRefs?: readonly string[];
+}
+interface Finding {
+    readonly id: string;
+    readonly severity: FindingSeverity;
+    readonly axis: ReviewAxis;
+    readonly disposition: FindingDisposition;
+    readonly title: string;
+    readonly evidence: string;
+    readonly location?: string;
+    readonly requirement?: string;
+    readonly verification?: string;
+}
+interface ReviewEvidence {
+    readonly outcome: "passed" | "actionable-findings" | "incomplete" | "blocked" | "failed";
+    readonly axes: readonly ReviewAxis[];
+    readonly findings: readonly Finding[];
+    readonly headSha: string;
+    readonly baseSha?: string;
+    readonly briefHash: string;
+}
+interface PhaseResult {
+    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
+    readonly assignmentId: string;
+    readonly phase: WorkflowPhase;
+    readonly outcome: PhaseOutcome;
+    readonly identity: WorkIdentity;
+    /** Brief revision executed by this phase. */
+    readonly briefHash: string;
+    readonly base?: RevisionReference;
+    readonly head?: RevisionReference;
+    readonly summary: string;
+    readonly evidence: readonly string[];
+    readonly checks: readonly CheckEvidence[];
+    readonly commits: readonly string[];
+    readonly artifacts: readonly string[];
+    readonly questions: readonly string[];
+    readonly findings: readonly Finding[];
+    /** Review axes explicitly completed, including axes with no findings. */
+    readonly reviewAxes?: readonly ReviewAxis[];
+    readonly completedAt: string;
+}
+interface Assignment {
+    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
+    readonly id: string;
+    readonly phase: WorkflowPhase;
+    readonly attempt: number;
+    readonly identity: WorkIdentity;
+    readonly briefId: string;
+    readonly briefRevision: number;
+    readonly briefHash: string;
+    readonly policyRevision: string;
+    readonly skillRevision: string;
+    /** Missing only on assignments persisted before role model selection shipped. */
+    readonly agentSelection?: AgentSelection;
+    readonly base: RevisionReference;
+    readonly head?: RevisionReference;
+    readonly createdAt: string;
+}
+interface TransitionContext {
+    readonly kind: WorkItemKind;
+    readonly authorization: Authorization["status"];
+    readonly checks?: readonly CheckEvidence[];
+    /** Required check names from the repository policy. */
+    readonly requiredCheckNames?: readonly string[];
+    /** Exact candidate identity required for lifecycle-gating check evidence. */
+    readonly checkCandidate?: {
+        readonly baseSha: string;
+        readonly headSha: string;
+        readonly briefHash: string;
+    };
+    readonly review?: ReviewEvidence;
+    readonly currentHeadSha?: string;
+    readonly assignedHeadSha?: string;
+}
+declare class ContractValidationError extends Error {
+    readonly issues: readonly string[];
+    constructor(message: string, issues?: readonly string[]);
+}
+type CreateWorkBriefInput = Omit<WorkBrief, "contractVersion" | "id" | "revision" | "hash"> & {
+    readonly id?: string;
+    readonly revision?: number;
+    /** Accepted for callers carrying a previously materialized brief; always recomputed. */
+    readonly hash?: string;
+    readonly contractVersion?: typeof WORKFLOW_CONTRACT_VERSION;
+};
+declare const createWorkBrief: (input: CreateWorkBriefInput) => WorkBrief;
+declare const parseWorkBrief: (value: unknown) => WorkBrief;
+type CreateRepositoryPolicyInput = Omit<RepositoryPolicy, "contractVersion">;
+declare const parseRepositoryPolicy: (value: unknown) => RepositoryPolicy;
+declare const createRepositoryPolicy: (input: CreateRepositoryPolicyInput) => RepositoryPolicy;
+declare const resolveAgentSelection: (policy: Pick<RepositoryPolicy, "worker">, phase: WorkflowPhase, risk?: WorkRisk, scope?: WorkScope) => AgentSelection;
+declare const parseCheckEvidence: (value: unknown) => CheckEvidence;
+declare const requireTransition: (from: LifecycleState, to: LifecycleState, context: TransitionContext) => void;
+interface CreateAssignmentInput {
+    readonly id: string;
+    readonly phase: WorkflowPhase;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly attempt: number;
+    readonly head?: RevisionReference;
+    readonly createdAt: string;
+}
+declare const createAssignment: (input: CreateAssignmentInput) => Assignment;
+declare const parsePhaseResult: (value: unknown) => PhaseResult;
+
+type JobControl = "active" | "paused" | "cancelled" | "superseded";
+type EventStatus = "received" | "accepted" | "ignored";
+type EventIgnoreReason = "out-of-order" | "closed-item" | "withdrawn-authorization" | "repository-stopped" | "invalid-policy";
+type DispatchStatus = "pending" | "claimed" | "started" | "completed" | "failed" | "cancelled";
+type EffectStatus = "pending" | "claimed" | "succeeded" | "uncertain" | "failed" | "cancelled";
+interface WorkKey {
+    readonly repository: string;
+    readonly itemId: string;
+    readonly briefRevision: number;
+    readonly phase: WorkflowPhase;
+    readonly relevantRevision: string;
+}
+interface WorkflowEventInput {
+    readonly deliveryId: string;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly phase: WorkflowPhase;
+    readonly relevantRevision: string;
+    readonly observedAt: string;
+    /** A closed source item invalidates queued and active work. */
+    readonly sourceState?: "open" | "closed";
+    readonly payload?: unknown;
+}
+interface StoredEvent extends WorkflowEventInput {
+    readonly id: string;
+    readonly key: WorkKey;
+    readonly status: EventStatus;
+    readonly ignoreReason?: EventIgnoreReason;
+    readonly jobId?: string;
+    readonly receivedAt: string;
+}
+interface RepairBudgetUsage {
+    readonly repairBatches: number;
+    readonly followUps: number;
+}
+interface WorkflowJob {
+    readonly id: string;
+    readonly key: WorkKey;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly state: LifecycleState;
+    readonly control: JobControl;
+    readonly phaseAttempts: Readonly<Record<WorkflowPhase, number>>;
+    readonly repairBatches: number;
+    readonly followUps: number;
+    readonly infrastructureRetries: number;
+    readonly infrastructureRetryLimit: number;
+    readonly assignments: readonly Assignment[];
+    readonly phaseResults: readonly PhaseResult[];
+    readonly activeAssignmentId?: string;
+    readonly latestObservedAt: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly version: number;
+}
+interface DispatchIntent {
+    readonly id: string;
+    readonly dedupeKey: string;
+    readonly key: WorkKey;
+    readonly jobId: string;
+    readonly status: DispatchStatus;
+    readonly assignment?: Assignment;
+    readonly workerId?: string;
+    readonly claimedAt?: number;
+    readonly claimExpiresAt?: number;
+    readonly error?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface EffectIntent {
+    readonly id: string;
+    readonly jobId: string;
+    readonly kind: string;
+    readonly marker: string;
+    readonly payload?: unknown;
+    readonly status: EffectStatus;
+    readonly externalRef?: unknown;
+    readonly workerId?: string;
+    readonly fencingToken?: number;
+    readonly claimedAt?: number;
+    readonly claimExpiresAt?: number;
+    readonly error?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface BranchLease {
+    readonly leaseId: string;
+    readonly resourceKey: string;
+    readonly repository: string;
+    readonly branch: string;
+    readonly jobId: string;
+    readonly workerId: string;
+    readonly fencingToken: number;
+    readonly acquiredAt: number;
+    readonly heartbeatAt: number;
+    readonly expiresAt: number;
+}
+interface RepositoryControl {
+    readonly repository: string;
+    readonly stopped: boolean;
+    readonly reason?: string;
+    readonly updatedAt: string;
+}
+interface CoordinatorStorageTransaction {
+    insertEventIfAbsent(event: StoredEvent): Promise<{
+        readonly event: StoredEvent;
+        readonly inserted: boolean;
+    }>;
+    saveEvent(event: StoredEvent): Promise<void>;
+    /** Serialize intake for an identity even before its first job row exists. */
+    lockWorkIdentity(identity: WorkIdentity): Promise<void>;
+    getJob(jobId: string): Promise<WorkflowJob | undefined>;
+    findJobByKey(key: WorkKey, briefHash: string): Promise<WorkflowJob | undefined>;
+    findCurrentJob(identity: WorkIdentity): Promise<WorkflowJob | undefined>;
+    insertJob(job: WorkflowJob): Promise<void>;
+    saveJob(job: WorkflowJob): Promise<void>;
+    findDispatchByDedupeKey(dedupeKey: string): Promise<DispatchIntent | undefined>;
+    findDispatchByAssignmentId(assignmentId: string): Promise<DispatchIntent | undefined>;
+    findPendingDispatch(repository: string, nowMilliseconds: number, selector?: {
+        readonly jobId?: string;
+        readonly dispatchId?: string;
+    }): Promise<DispatchIntent | undefined>;
+    insertDispatchIfAbsent(dispatch: DispatchIntent): Promise<{
+        readonly dispatch: DispatchIntent;
+        readonly inserted: boolean;
+    }>;
+    saveDispatch(dispatch: DispatchIntent): Promise<void>;
+    findEffect(jobId: string, kind: string, marker: string): Promise<EffectIntent | undefined>;
+    insertEffectIfAbsent(effect: EffectIntent): Promise<{
+        readonly effect: EffectIntent;
+        readonly inserted: boolean;
+    }>;
+    saveEffect(effect: EffectIntent): Promise<void>;
+    getLease(repository: string, branch: string): Promise<BranchLease | undefined>;
+    /** Serialize lease acquisition even when no lease row exists yet. */
+    lockLeaseResource(repository: string, branch: string): Promise<void>;
+    saveLease(lease: BranchLease): Promise<void>;
+    findLeasesForJob(jobId: string): Promise<readonly BranchLease[]>;
+    findLeasesForRepository(repository: string): Promise<readonly BranchLease[]>;
+    getRepositoryControl(repository: string): Promise<RepositoryControl | undefined>;
+    saveRepositoryControl(control: RepositoryControl): Promise<void>;
+}
+interface CoordinatorStorage {
+    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
+}
+interface CoordinatorClock {
+    now(): string;
+    nowMilliseconds(): number;
+}
+interface WorkflowCoordinatorOptions {
+    readonly storage: CoordinatorStorage;
+    readonly clock?: CoordinatorClock;
+    readonly idFactory?: (prefix: string) => string;
+    readonly infrastructureRetryLimit?: number;
+    readonly dispatchClaimTtlMs?: number;
+    readonly effectClaimTtlMs?: number;
+}
+interface DispatchRequest {
+    readonly repository: string;
+    readonly workerId: string;
+    /** Restrict dispatch to a known job/intent when a workflow runner is resuming. */
+    readonly jobId?: string;
+    readonly dispatchId?: string;
+}
+type DispatchBlockReason = "repository-stopped" | "job-paused" | "job-cancelled" | "job-superseded" | "authorization-withdrawn" | "authorization-pending" | "invalid-policy" | "semantic-budget-exhausted" | "infrastructure-retries-exhausted" | "invalid-transition";
+interface IngestResult {
+    readonly disposition: "accepted" | "duplicate" | "out-of-order" | "ignored";
+    readonly event: StoredEvent;
+    readonly job?: WorkflowJob;
+    readonly dispatch?: DispatchIntent;
+    readonly reason?: EventIgnoreReason;
+}
+interface DispatchResult {
+    readonly status: "dispatched" | "none" | "blocked";
+    readonly dispatch?: DispatchIntent;
+    readonly assignment?: Assignment;
+    readonly job?: WorkflowJob;
+    readonly reason?: DispatchBlockReason;
+}
+interface AcquireBranchLeaseInput {
+    readonly repository: string;
+    readonly branch: string;
+    readonly jobId: string;
+    readonly workerId: string;
+    readonly ttlMs: number;
+}
+interface SubmitPhaseResultInput {
+    readonly jobId: string;
+    readonly result: PhaseResult;
+    /** Every non-duplicate result must be fenced by the worker's active lease. */
+    readonly lease: BranchLease;
+}
+interface SchedulePhaseInput {
+    readonly jobId: string;
+    readonly phase: WorkflowPhase;
+    readonly relevantRevision: string;
+    readonly head?: {
+        readonly branch: string;
+        readonly sha: string;
+    };
+}
+interface SchedulePhaseResult {
+    readonly status: "scheduled" | "duplicate" | "blocked";
+    readonly job: WorkflowJob;
+    readonly dispatch?: DispatchIntent;
+    readonly reason?: string;
+}
+interface PhaseResultSubmission {
+    readonly job: WorkflowJob;
+    readonly duplicate: boolean;
+    readonly transitioned: boolean;
+}
+interface InfrastructureFailureInput {
+    readonly jobId: string;
+    readonly assignmentId: string;
+    readonly error: string;
+}
+interface InfrastructureRetryResult {
+    readonly status: "retry-scheduled" | "exhausted" | "not-retryable";
+    readonly job: WorkflowJob;
+    readonly dispatch?: DispatchIntent;
+}
+interface RepairRequestResult {
+    readonly status: "scheduled" | "blocked" | "not-allowed";
+    readonly job: WorkflowJob;
+    readonly dispatch?: DispatchIntent;
+    readonly dispatchClaimExpired?: boolean;
+    readonly reason?: string;
+}
+interface EffectOperationContext {
+    readonly effect: EffectIntent;
+    readonly fencingToken: number;
+}
+interface PublishEffectInput<T> {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    /** Optional resource binding for effects that operate on a branch. */
+    readonly branch?: string;
+    /** Optional resource binding for effects that target the workflow item. */
+    readonly itemId?: string;
+    /** Optional candidate binding for effects that publish a commit head. */
+    readonly headSha?: string;
+    readonly kind: string;
+    readonly marker: string;
+    readonly payload?: unknown;
+    readonly reconcile?: (context: EffectOperationContext) => Promise<T | undefined>;
+    readonly publish: (context: EffectOperationContext) => Promise<T>;
+}
+interface EffectExecution<T> {
+    readonly disposition: "published" | "reconciled" | "already-succeeded" | "in-flight";
+    readonly effect: EffectIntent;
+    readonly externalRef?: T;
+}
+
+/** Minimal query surface implemented by `pg`, Neon, and compatible clients. */
+interface PostgresQueryResult<Row extends Record<string, unknown> = Record<string, unknown>> {
+    readonly rows: readonly Row[];
+    readonly rowCount?: number | null;
+}
+interface PostgresQueryClient {
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(text: string, values?: readonly unknown[]): Promise<PostgresQueryResult<Row>>;
+}
+interface PostgresConnection extends PostgresQueryClient {
+    release?: () => void;
+}
+interface PostgresCoordinatorStorageOptions {
+    /** A connected client or a pool with a transaction-scoped `connect()` method. */
+    readonly client: PostgresQueryClient & {
+        readonly connect?: () => Promise<PostgresConnection>;
+    };
+}
+/** PostgreSQL-backed implementation; schema installation remains an operator concern. */
+declare class PostgresCoordinatorStorage implements CoordinatorStorage {
+    private readonly client;
+    constructor(options: PostgresCoordinatorStorageOptions);
+    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
+}
+
+declare class LeaseLostError extends Error {
+    constructor(message?: string);
+}
+declare class LeaseBusyError extends Error {
+    constructor(message: string);
+}
+declare class WorkflowCoordinator {
+    private readonly storage;
+    private readonly clock;
+    private readonly idFactory;
+    private readonly infrastructureRetryLimit;
+    private readonly dispatchClaimTtlMs;
+    private readonly effectClaimTtlMs;
+    constructor(options: WorkflowCoordinatorOptions);
+    getJob(jobId: string): Promise<WorkflowJob | undefined>;
+    getCurrentJob(identity: WorkIdentity): Promise<WorkflowJob | undefined>;
+    getRepositoryControl(repository: string): Promise<RepositoryControl | undefined>;
+    ingest(input: WorkflowEventInput): Promise<IngestResult>;
+    dispatchNext(request: DispatchRequest): Promise<DispatchResult>;
+    private latestHeadForRevision;
+    private dispatchBlockReason;
+    acquireBranchLease(input: AcquireBranchLeaseInput): Promise<BranchLease>;
+    heartbeatBranchLease(lease: BranchLease): Promise<BranchLease>;
+    private assertLease;
+    publishEffect<T>(input: PublishEffectInput<T>): Promise<EffectExecution<T>>;
+    private assertPublicationAllowed;
+    private finishEffect;
+    recordPhaseResult(input: SubmitPhaseResultInput): Promise<{
+        job: WorkflowJob;
+        duplicate: boolean;
+        transitioned: boolean;
+    }>;
+    recordInfrastructureFailure(input: InfrastructureFailureInput): Promise<InfrastructureRetryResult>;
+    setRepositoryStop(input: {
+        readonly repository: string;
+        readonly stopped: boolean;
+        readonly reason?: string;
+    }): Promise<RepositoryControl>;
+    pauseJob(jobId: string, reason?: string): Promise<WorkflowJob>;
+    cancelJob(jobId: string, reason?: string): Promise<WorkflowJob>;
+    supersedeJob(jobId: string, reason?: string): Promise<WorkflowJob>;
+    resumeJob(jobId: string): Promise<WorkflowJob>;
+    private updateJobControl;
+    schedulePhase(input: SchedulePhaseInput): Promise<SchedulePhaseResult>;
+    scheduleRepair(input: {
+        readonly jobId: string;
+        readonly brief: WorkBrief;
+        readonly policy: RepositoryPolicy;
+        readonly followUp?: boolean;
+        readonly relevantRevision?: string;
+    }): Promise<RepairRequestResult>;
+    private cancelStoredJob;
+}
+
+interface HandoffCandidate {
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly briefHash: string;
+}
+interface BranchProtectionState {
+    readonly enforced: boolean;
+    readonly humanApprovalRequired: boolean;
+    /** Fresh provider evidence; caller-supplied booleans alone are not a merge gate. */
+    readonly provider: "github";
+    readonly verifiedAt: string;
+}
+interface HumanApproval {
+    readonly actor: string;
+    readonly actorRole: "owner" | "maintainer";
+    readonly approvedAt: string;
+    readonly baseSha: string;
+    readonly headSha: string;
+    readonly briefHash: string;
+}
+interface HandoffReadinessInput {
+    readonly job: WorkflowJob;
+    readonly candidate: HandoffCandidate;
+    readonly checks: readonly CheckEvidence[];
+    readonly review: ReviewEvidence;
+    readonly requiredAxes?: readonly ReviewAxis[];
+    readonly branchProtection?: BranchProtectionState;
+    readonly humanApproval?: HumanApproval;
+    readonly now?: () => string;
+    readonly freshnessWindowSeconds?: number;
+}
+interface HandoffPacket {
+    readonly sourceIssue: string;
+    readonly pullRequest?: string;
+    readonly candidate: HandoffCandidate;
+    readonly briefRevision: number;
+    readonly briefHash: string;
+    readonly change: string;
+    readonly risk: WorkBrief["risk"];
+    readonly acceptanceCriteria: readonly string[];
+    readonly acceptanceEvidence: readonly string[];
+    readonly checks: readonly CheckEvidence[];
+    readonly reviewAxes: readonly ReviewAxis[];
+    readonly findings: readonly Finding[];
+    readonly limitations: readonly string[];
+}
+type HandoffOutcome = "blocked" | "ready-for-review" | "review-requested"
+/** Retained for source-item triage; PR handoff uses ready-for-review. */
+ | "ready-for-human" | "repair-needed" | "rejected" | "abandoned" | "merge-ready" | "merged" | "open";
+interface HandoffReadinessResult {
+    readonly outcome: "blocked" | "ready-for-review" | "review-requested" | "merge-ready";
+    readonly readyForReview: boolean;
+    readonly reviewRequested: boolean;
+    readonly readyForHuman: boolean;
+    readonly mergeReady: boolean;
+    readonly reasons: readonly string[];
+    readonly packet: HandoffPacket;
+}
+interface HumanHandoffPublisher {
+    requestReview(input: {
+        readonly packet: HandoffPacket;
+        readonly pullRequestNumber: number;
+    }): Promise<void>;
+}
+interface PrepareHandoffOptions extends HandoffReadinessInput {
+    readonly sourceIssueNumber: number;
+    readonly pullRequestNumber: number;
+    readonly publisher?: HumanHandoffPublisher;
+    readonly readCurrent?: () => Promise<HandoffCandidate>;
+}
+interface HumanReviewDecisionInput {
+    readonly decision: "approved" | "changes-requested" | "rejected" | "abandoned";
+    readonly reason?: string;
+}
+interface HumanReviewDecision {
+    readonly outcome: Extract<HandoffOutcome, "merge-ready" | "repair-needed" | "rejected" | "abandoned">;
+    readonly reason?: string;
+}
+interface HumanReviewRoundTripOptions {
+    readonly candidate: HandoffCandidate;
+    readonly pullRequestNumber: number;
+    readonly decision: HumanReviewDecisionInput;
+    /** Re-reads the PR head and brief before applying the human decision. */
+    readonly readCurrent: () => Promise<HandoffCandidate>;
+    /** Keeps a requested-changes repair on the existing PR branch. */
+    readonly requestRepair: (input: {
+        readonly candidate: HandoffCandidate;
+        readonly pullRequestNumber: number;
+        readonly reason: string;
+    }) => Promise<void>;
+}
+interface HumanReviewRoundTripResult {
+    readonly outcome: "blocked" | Extract<HandoffOutcome, "merge-ready" | "repair-needed" | "rejected" | "abandoned">;
+    readonly reason?: string;
+    readonly candidate: HandoffCandidate;
+    readonly pullRequestNumber: number;
+}
+interface MergeTransport {
+    mergeProtected(input: {
+        readonly pullRequestNumber: number;
+        readonly headSha: string;
+        readonly baseBranch: string;
+    }): Promise<{
+        readonly mergedSha: string;
+    }>;
+}
+interface MergeCandidateOptions extends Omit<HandoffReadinessInput, "branchProtection"> {
+    readonly pullRequestNumber: number;
+    readonly humanApproval: HumanApproval;
+    /** Re-reads the PR, branch and brief identity immediately before merging. */
+    readonly readCurrent: () => Promise<HandoffCandidate>;
+    /** Fetches fresh provider evidence immediately before a protected merge. */
+    readonly readBranchProtection: () => Promise<BranchProtectionState>;
+    readonly transport: MergeTransport;
+}
+interface MergeResult {
+    readonly outcome: "blocked" | "merged";
+    readonly reason?: string;
+    readonly mergedSha?: string;
+}
+interface CompletionInput {
+    readonly policy: RepositoryPolicy;
+    readonly mergedSha: string;
+    readonly candidate: HandoffCandidate;
+    readonly checks: readonly CheckEvidence[];
+}
+interface CompletionResult {
+    readonly outcome: "completed" | "open";
+    readonly reason?: string;
+    readonly mergedSha: string;
+    readonly checks: readonly CheckEvidence[];
+}
+interface SourceIssueCloser {
+    closeIssue(input: {
+        readonly issueNumber: number;
+        readonly mergedSha: string;
+        readonly checks: readonly CheckEvidence[];
+    }): Promise<void>;
+}
+interface CloseSourceIssueOptions extends CompletionInput {
+    readonly sourceIssueNumber: number;
+    readonly closer: SourceIssueCloser;
+}
+interface SourceIssueClosureResult extends CompletionResult {
+    readonly closed: boolean;
+}
+declare const evaluateHandoffReadiness: (input: HandoffReadinessInput) => HandoffReadinessResult;
+declare const prepareHumanHandoff: (input: PrepareHandoffOptions) => Promise<HandoffReadinessResult>;
+declare const resolveHumanReviewDecision: (input: HumanReviewDecisionInput) => HumanReviewDecision;
+declare const processHumanReviewDecision: (input: HumanReviewRoundTripOptions) => Promise<HumanReviewRoundTripResult>;
+declare const mergeProtectedCandidate: (input: MergeCandidateOptions) => Promise<MergeResult>;
+declare const completeSourceIssue: (input: CompletionInput) => CompletionResult;
+declare const closeSourceIssue: (input: CloseSourceIssueOptions) => Promise<SourceIssueClosureResult>;
+
+type TriageCategory = "bug" | "enhancement" | "support" | "duplicate" | "sensitive" | "non-actionable";
+type TriageOutcome = "completed" | "needs-info" | "duplicate" | "sensitive" | "non-actionable" | "blocked" | "failed";
+interface TriageSource {
+    readonly provider: "github" | "slack" | "manual";
+    readonly repository: string;
+    readonly itemId: string;
+    readonly title: string;
+    readonly body: string;
+    readonly author?: string;
+    readonly url?: string;
+    readonly updatedAt: string;
+    readonly kind?: WorkItemKind;
+    readonly labels?: readonly string[];
+}
+interface ClarificationReply {
+    readonly id: string;
+    readonly body: string;
+    readonly author?: string;
+    readonly updatedAt: string;
+}
+interface TriageSourceConflict {
+    readonly fingerprint: string;
+    readonly updatedAt: string;
+}
+interface TriageAssessment {
+    readonly category: TriageCategory;
+    readonly evidence: readonly string[];
+    readonly relevantFiles: readonly string[];
+    readonly acceptanceCriteria: readonly string[];
+    readonly exclusions: readonly string[];
+    readonly risk: RiskLevel;
+    readonly verification: readonly string[];
+    readonly unresolvedQuestions: readonly string[];
+    readonly requirementsConfirmed: boolean;
+    readonly duplicateOf?: string;
+    readonly sensitiveReason?: string;
+}
+interface TriageInvestigationRequest {
+    readonly source: TriageSource;
+    readonly policy: RepositoryPolicy;
+    readonly base: RevisionReference;
+    readonly previous?: TriageRecord;
+    readonly clarificationReply?: ClarificationReply;
+}
+type TriageInvestigator = ((request: TriageInvestigationRequest) => Promise<TriageAssessment>) | {
+    investigate(request: TriageInvestigationRequest): Promise<TriageAssessment>;
+};
+interface TriageRecord {
+    readonly id: string;
+    readonly sourceKey: string;
+    /** Retained for durable investigation and resumption; never used as public output. */
+    readonly source: TriageSource;
+    readonly sourceUpdatedAt: string;
+    readonly sourceFingerprint: string;
+    readonly revision: number;
+    readonly category: TriageCategory;
+    readonly outcome: TriageOutcome;
+    readonly assessment: TriageAssessment;
+    readonly brief?: WorkBrief;
+    readonly questions: readonly string[];
+    readonly clarificationIds: readonly string[];
+    readonly pendingClarificationReplies?: readonly ClarificationReply[];
+    readonly sourceConflict?: TriageSourceConflict;
+    readonly duplicateOf?: string;
+    readonly publicMessage: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface TriageStore {
+    get(sourceKey: string): TriageRecord | undefined | Promise<TriageRecord | undefined>;
+    /**
+     * Atomically save only when the stored revision still matches the read
+     * revision. Custom stores must implement this as one compare-and-save.
+     */
+    compareAndSave(record: TriageRecord, expectedRevision: number | undefined): boolean | Promise<boolean>;
+}
+declare class InMemoryTriageStore implements TriageStore {
+    private readonly records;
+    get(sourceKey: string): TriageRecord | undefined;
+    compareAndSave(record: TriageRecord, expectedRevision: number | undefined): boolean;
+}
+interface PostgresTriageStoreOptions {
+    readonly client: PostgresQueryClient;
+}
+/** Durable triage records backed by the coordinator's PostgreSQL database. */
+declare class PostgresTriageStore implements TriageStore {
+    private readonly records;
+    constructor(options: PostgresTriageStoreOptions);
+    get(sourceKey: string): Promise<TriageRecord | undefined>;
+    compareAndSave(record: TriageRecord, expectedRevision: number | undefined): Promise<boolean>;
+}
+interface RunTriageOptions {
+    readonly source: TriageSource;
+    readonly policy: RepositoryPolicy;
+    readonly base: RevisionReference;
+    readonly store: TriageStore;
+    readonly investigator?: TriageInvestigator;
+    readonly clarificationReply?: ClarificationReply;
+    readonly now?: () => string;
+}
+interface TriageResult {
+    readonly outcome: TriageOutcome;
+    readonly category: TriageCategory;
+    readonly brief?: WorkBrief;
+    readonly questions: readonly string[];
+    readonly publicMessage: string;
+    readonly record: TriageRecord;
+    readonly implementationEligible: boolean;
+}
+declare const defaultInvestigator: TriageInvestigator;
+declare const runTriage: ({ source: rawSource, policy, base, store, investigator, clarificationReply, now, }: RunTriageOptions) => Promise<TriageResult>;
+
+type GitHubEventName = "issues" | "issue_comment" | "pull_request" | "pull_request_review" | "pull_request_review_comment" | "check_run" | "check_suite";
+type GitHubActorType = "User" | "Bot" | "Organization" | string;
+interface GitHubActor {
+    readonly login: string;
+    readonly type?: GitHubActorType;
+}
+interface GitHubIssueSnapshot {
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly state: "open" | "closed";
+    readonly updatedAt: string;
+    readonly htmlUrl?: string;
+    readonly authorLogin?: string;
+    readonly labels: readonly string[];
+    readonly pullRequestNumber?: number;
+}
+interface GitHubCommentSnapshot {
+    readonly id: string;
+    readonly body: string;
+    readonly updatedAt: string;
+    readonly htmlUrl?: string;
+    readonly authorLogin?: string;
+}
+interface GitHubPullRequestSnapshot {
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly state: "open" | "closed";
+    readonly draft: boolean;
+    readonly branch: string;
+    readonly baseBranch: string;
+    readonly headSha: string;
+    readonly updatedAt: string;
+    readonly htmlUrl?: string;
+    readonly authorLogin?: string;
+}
+type GitHubPullRequestReviewState = "approved" | "changes-requested" | "commented" | "dismissed" | "pending";
+interface GitHubPullRequestReviewSnapshot {
+    readonly id: string;
+    readonly state: GitHubPullRequestReviewState;
+    readonly headSha: string;
+    readonly submittedAt: string;
+    readonly authorLogin?: string;
+}
+interface GitHubBranchSnapshot {
+    readonly name: string;
+    readonly headSha: string;
+    readonly htmlUrl?: string;
+}
+interface GitHubCheckSnapshot {
+    readonly id: string;
+    readonly name: string;
+    readonly headSha: string;
+    readonly status: "queued" | "in_progress" | "completed";
+    readonly conclusion?: "success" | "failure" | "neutral" | "cancelled" | "timed_out" | "action_required" | "stale" | "skipped";
+    readonly htmlUrl?: string;
+}
+interface GitHubWebhookRequest {
+    readonly body: string | Uint8Array;
+    readonly headers: Readonly<Record<string, string | undefined>>;
+}
+interface GitHubWebhookEnvelope {
+    readonly eventName: string;
+    readonly deliveryId: string;
+    readonly payload: unknown;
+    readonly receivedAt: string;
+}
+interface GitHubAuthorizationPolicy {
+    /** Exact repository names allowed to produce workflow input. */
+    readonly allowedRepositories: readonly string[];
+    /** Exact GitHub logins allowed to submit workflow input. */
+    readonly allowedSenders: readonly string[];
+    /** Exact GitHub logins allowed to approve or request changes on tracked pull requests. */
+    readonly allowedReviewers: readonly string[];
+    /** Additional service logins treated as bot-originated. */
+    readonly botLogins?: readonly string[];
+}
+interface GitHubBriefDefaults {
+    readonly risk?: RiskLevel;
+    readonly acceptanceCriteria?: readonly string[];
+    readonly exclusions?: readonly string[];
+    readonly unresolvedQuestions?: readonly string[];
+    readonly verificationArtifacts?: readonly string[];
+}
+type GitHubIssueEventKind = "issue-created" | "issue-edited" | "issue-replied";
+type GitHubTrackedPullRequestEventKind = "tracked-pr-updated";
+type GitHubNormalizedEventKind = GitHubIssueEventKind | GitHubTrackedPullRequestEventKind;
+type GitHubEventIgnoreReason = "unsupported-event" | "unsupported-action" | "bot-originated" | "unrelated-pull-request" | "triage-source-conflict" | "triage-incomplete";
+interface GitHubNormalizedEvent {
+    readonly kind: GitHubNormalizedEventKind;
+    readonly eventName: GitHubEventName;
+    readonly action: string;
+    readonly deliveryId: string;
+    readonly repository: string;
+    readonly sender: GitHubActor;
+    readonly issueNumber: number;
+    readonly pullRequestNumber?: number;
+    readonly title: string;
+    readonly body: string;
+    readonly labels: readonly string[];
+    readonly relevantRevision: string;
+    readonly observedAt: string;
+    readonly sourceState: "open" | "closed";
+    readonly reply?: GitHubCommentSnapshot;
+    readonly review?: GitHubPullRequestReviewSnapshot;
+    readonly trackedPullRequest?: GitHubTrackedPullRequest;
+    readonly workflowEvent: WorkflowEventInput;
+}
+interface GitHubIgnoredEvent {
+    readonly disposition: "ignored";
+    readonly reason: GitHubEventIgnoreReason;
+    readonly eventName: string;
+    readonly action?: string;
+    readonly deliveryId: string;
+    readonly repository: string;
+    readonly sender: GitHubActor;
+}
+type GitHubNormalizationResult = {
+    readonly disposition: "accepted";
+    readonly event: GitHubNormalizedEvent;
+} | GitHubIgnoredEvent;
+type GitHubDeliveryStatus = "received" | "accepted" | "ignored" | "rejected";
+interface GitHubDeliveryRecord {
+    readonly deliveryId: string;
+    readonly eventName: string;
+    readonly repository: string;
+    readonly senderLogin: string;
+    readonly receivedAt: string;
+    readonly payloadHash: string;
+    readonly payload: unknown;
+    readonly status: GitHubDeliveryStatus;
+    readonly eventKind?: GitHubNormalizedEventKind;
+    readonly reason?: string;
+    readonly jobId?: string;
+}
+interface GitHubDeliveryStore {
+    recordDeliveryIfAbsent(delivery: GitHubDeliveryRecord): Promise<{
+        readonly delivery: GitHubDeliveryRecord;
+        readonly inserted: boolean;
+    }>;
+    getDelivery(deliveryId: string): Promise<GitHubDeliveryRecord | undefined>;
+    updateDelivery(delivery: GitHubDeliveryRecord): Promise<void>;
+}
+interface GitHubTrackedPullRequest {
+    readonly repository: string;
+    readonly pullRequestNumber: number;
+    readonly jobId: string;
+    readonly itemId: string;
+    readonly branch: string;
+    readonly headSha: string;
+    readonly marker: string;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly createdAt: string;
+}
+interface GitHubPullRequestReviewHandler {
+    readCurrent(input: {
+        readonly candidate: HandoffCandidate;
+        readonly trackedPullRequest: GitHubTrackedPullRequest;
+    }): Promise<HandoffCandidate>;
+    requestRepair(input: {
+        readonly candidate: HandoffCandidate;
+        readonly pullRequestNumber: number;
+        readonly reason: string;
+    }): Promise<void>;
+}
+interface GitHubTrackingStore {
+    findTrackedPullRequest(repository: string, pullRequestNumber: number): Promise<GitHubTrackedPullRequest | undefined>;
+    saveTrackedPullRequest(pullRequest: GitHubTrackedPullRequest): Promise<void>;
+}
+interface GitHubBriefFactoryInput {
+    readonly event: Omit<GitHubNormalizedEvent, "workflowEvent">;
+    readonly itemKind: "planning-spec" | "executable-issue" | "pr-repair";
+    readonly policy: RepositoryPolicy;
+    readonly base: RevisionReference;
+    readonly authorization: Authorization;
+    readonly revision: number;
+    readonly defaults?: GitHubBriefDefaults;
+}
+type GitHubBriefFactory = (input: GitHubBriefFactoryInput) => WorkBrief;
+interface GitHubIntegrationOptions {
+    readonly coordinator: WorkflowCoordinator;
+    readonly policy: RepositoryPolicy;
+    readonly base: RevisionReference;
+    readonly authorization: GitHubAuthorizationPolicy;
+    readonly deliveryStore: GitHubDeliveryStore;
+    readonly webhookSecret: string | Uint8Array;
+    readonly trackingStore?: GitHubTrackingStore;
+    /** Review events fail closed unless the caller wires candidate-bound handoff handling. */
+    readonly reviewHandler?: GitHubPullRequestReviewHandler;
+    readonly briefDefaults?: GitHubBriefDefaults;
+    readonly briefFactory?: GitHubBriefFactory;
+    /** Optional automatic investigation adapter; absent means intake remains raw triage. */
+    readonly triage?: {
+        readonly store: TriageStore;
+        readonly investigator?: TriageInvestigator;
+    };
+    readonly now?: () => string;
+}
+interface GitHubWebhookReceipt {
+    readonly status: "accepted" | "duplicate" | "ignored" | "rejected";
+    readonly deliveryId: string;
+    readonly reason?: string;
+    readonly event?: GitHubNormalizedEvent;
+    readonly ingest?: IngestResult;
+    readonly review?: HumanReviewRoundTripResult;
+}
+interface GitHubReconciliationInput {
+    readonly repository: string;
+    readonly issueNumber?: number;
+    readonly pullRequestNumber?: number;
+    readonly transport: GitHubReadTransport;
+}
+interface GitHubReconciliationResult {
+    readonly status: "accepted" | "duplicate" | "ignored" | "not-found";
+    readonly deliveryId: string;
+    readonly reason?: string;
+    readonly event?: GitHubNormalizedEvent;
+    readonly ingest?: IngestResult;
+}
+interface GitHubReadTransport {
+    fetchIssue(input: {
+        readonly repository: string;
+        readonly issueNumber: number;
+    }): Promise<GitHubIssueSnapshot | undefined>;
+    fetchPullRequest(input: {
+        readonly repository: string;
+        readonly pullRequestNumber: number;
+    }): Promise<GitHubPullRequestSnapshot | undefined>;
+    findCommentByMarker(input: {
+        readonly repository: string;
+        readonly issueNumber: number;
+        readonly marker: string;
+    }): Promise<GitHubCommentSnapshot | undefined>;
+    findBranchByName(input: {
+        readonly repository: string;
+        readonly branch: string;
+    }): Promise<GitHubBranchSnapshot | undefined>;
+    findPullRequestByMarker(input: {
+        readonly repository: string;
+        readonly marker: string;
+    }): Promise<GitHubPullRequestSnapshot | undefined>;
+    findCheckByMarker(input: {
+        readonly repository: string;
+        readonly marker: string;
+        readonly headSha: string;
+    }): Promise<GitHubCheckSnapshot | undefined>;
+    findIssueByMarker(input: {
+        readonly repository: string;
+        readonly marker: string;
+    }): Promise<GitHubIssueSnapshot | undefined>;
+}
+interface GitHubWriteTransport {
+    createComment(input: {
+        readonly repository: string;
+        readonly issueNumber: number;
+        readonly body: string;
+    }): Promise<GitHubCommentSnapshot>;
+    createBranch(input: {
+        readonly repository: string;
+        readonly branch: string;
+        readonly headSha: string;
+        readonly marker: string;
+    }): Promise<GitHubBranchSnapshot>;
+    createPullRequest(input: {
+        readonly repository: string;
+        readonly title: string;
+        readonly body: string;
+        readonly branch: string;
+        readonly baseBranch: string;
+        readonly draft: boolean;
+        readonly marker: string;
+    }): Promise<GitHubPullRequestSnapshot>;
+    createCheck(input: {
+        readonly repository: string;
+        readonly name: string;
+        readonly headSha: string;
+        readonly marker: string;
+        readonly status: GitHubCheckSnapshot["status"];
+        readonly conclusion?: GitHubCheckSnapshot["conclusion"];
+        readonly summary: string;
+    }): Promise<GitHubCheckSnapshot>;
+    createRepairIssue(input: {
+        readonly repository: string;
+        readonly title: string;
+        readonly body: string;
+        readonly marker: string;
+        readonly labels: readonly string[];
+    }): Promise<GitHubIssueSnapshot>;
+}
+interface GitHubPublicationOptions {
+    readonly coordinator: WorkflowCoordinator;
+    readonly transport: GitHubReadTransport & GitHubWriteTransport;
+    readonly trackingStore: GitHubTrackingStore;
+    readonly now?: () => string;
+}
+interface GitHubPublicationResult<T> {
+    readonly marker: string;
+    readonly remote: T | undefined;
+    readonly disposition: EffectExecution<T>["disposition"];
+    readonly effect: EffectIntent;
+}
+interface GitHubCommentPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly issueNumber: number;
+    readonly body: string;
+    readonly key?: string;
+}
+interface GitHubBriefPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly issueNumber: number;
+    readonly brief: WorkBrief;
+}
+interface GitHubBranchPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly branch: string;
+    readonly headSha: string;
+}
+interface GitHubPullRequestPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly title: string;
+    readonly body: string;
+    readonly branch: string;
+    readonly baseBranch: string;
+    readonly headSha: string;
+    readonly draft?: boolean;
+}
+interface GitHubCheckPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    /** Candidate branch used to bind the check to the active lease. */
+    readonly branch?: string;
+    readonly name: string;
+    readonly headSha: string;
+    readonly status: GitHubCheckSnapshot["status"];
+    readonly conclusion?: GitHubCheckSnapshot["conclusion"];
+    readonly summary: string;
+    readonly key?: string;
+}
+interface GitHubRepairIssuePublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly title: string;
+    readonly body: string;
+    readonly labels?: readonly string[];
+}
+interface GitHubRepairLinkPublicationInput {
+    readonly jobId: string;
+    readonly lease: BranchLease;
+    readonly issueNumber: number;
+    readonly repairIssueUrl: string;
+}
+
+/** Coordinator-owned GitHub effects with stable markers and remote reconciliation. */
+declare class GitHubPublication {
+    private readonly options;
+    constructor(options: GitHubPublicationOptions);
+    publishComment(input: GitHubCommentPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
+    publishBrief(input: GitHubBriefPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
+    publishBranch(input: GitHubBranchPublicationInput): Promise<GitHubPublicationResult<GitHubBranchSnapshot>>;
+    publishPullRequest(input: GitHubPullRequestPublicationInput): Promise<GitHubPublicationResult<GitHubPullRequestSnapshot>>;
+    publishCheck(input: GitHubCheckPublicationInput): Promise<GitHubPublicationResult<GitHubCheckSnapshot>>;
+    publishRepairIssue(input: GitHubRepairIssuePublicationInput): Promise<GitHubPublicationResult<GitHubIssueSnapshot>>;
+    publishRepairLink(input: GitHubRepairLinkPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
+}
+
+export { type CheckEvidence as $, type GitHubEventName as A, type GitHubIgnoredEvent as B, type GitHubIssueEventKind as C, type GitHubIssueSnapshot as D, type GitHubNormalizedEvent as E, type GitHubNormalizedEventKind as F, type GitHubDeliveryStore as G, type HumanReviewDecisionInput as H, GitHubPublication as I, type GitHubPublicationOptions as J, type GitHubPublicationResult as K, type GitHubPullRequestPublicationInput as L, type GitHubPullRequestReviewHandler as M, type GitHubPullRequestReviewState as N, type GitHubPullRequestSnapshot as O, type GitHubReadTransport as P, type GitHubRepairIssuePublicationInput as Q, type GitHubRepairLinkPublicationInput as R, type GitHubTrackedPullRequestEventKind as S, type GitHubWriteTransport as T, type CoordinatorStorage as U, type CoordinatorStorageTransaction as V, type WorkBrief as W, type Assignment as X, type RepositoryPolicy as Y, type AgentSelection as Z, type RevisionReference as _, type GitHubTrackingStore as a, type PostgresConnection as a$, type Finding as a0, type ReviewAxis as a1, type PhaseResult as a2, type FindingSeverity as a3, type ReviewEvidence as a4, WorkflowCoordinator as a5, type WorkflowJob as a6, type DispatchResult as a7, type BranchLease as a8, type DispatchIntent as a9, type EventIgnoreReason as aA, type EventStatus as aB, type FindingDisposition as aC, type HandoffCandidate as aD, type HandoffOutcome as aE, type HandoffPacket as aF, type HandoffReadinessInput as aG, type HandoffReadinessResult as aH, type HumanApproval as aI, type HumanHandoffPublisher as aJ, type HumanReviewDecision as aK, type HumanReviewRoundTripOptions as aL, type HumanReviewRoundTripResult as aM, InMemoryTriageStore as aN, type InfrastructureFailureInput as aO, type InfrastructureRetryResult as aP, type IngestResult as aQ, type JobControl as aR, LeaseBusyError as aS, LeaseLostError as aT, type LifecycleState as aU, type MergeCandidateOptions as aV, type MergeResult as aW, type MergeTransport as aX, type PhaseBudget as aY, type PhaseOutcome as aZ, type PhaseResultSubmission as a_, type WorkflowPhase as aa, type RepositoryControl as ab, type PostgresQueryClient as ac, type AcquireBranchLeaseInput as ad, type AgentModelRoles as ae, type AgentRole as af, type Authorization as ag, type BranchProtectionState as ah, type CheckCommand as ai, type CheckStatus as aj, type ClarificationReply as ak, type CloseSourceIssueOptions as al, type CompletionInput as am, type CompletionResult as an, ContractValidationError as ao, type CoordinatorClock as ap, type CreateAssignmentInput as aq, type CreateRepositoryPolicyInput as ar, type CreateWorkBriefInput as as, type DispatchBlockReason as at, type DispatchRequest as au, type DispatchStatus as av, type EffectExecution as aw, type EffectIntent as ax, type EffectOperationContext as ay, type EffectStatus as az, type GitHubDeliveryRecord as b, PostgresCoordinatorStorage as b0, type PostgresCoordinatorStorageOptions as b1, type PostgresQueryResult as b2, PostgresTriageStore as b3, type PostgresTriageStoreOptions as b4, type PrepareHandoffOptions as b5, type PublishEffectInput as b6, type RepairBudgetUsage as b7, type RepairRequestResult as b8, type RiskLevel as b9, type WorkerPolicy as bA, type WorkflowCoordinatorOptions as bB, type WorkflowEventInput as bC, closeSourceIssue as bD, completeSourceIssue as bE, createAssignment as bF, createRepositoryPolicy as bG, createWorkBrief as bH, defaultInvestigator as bI, evaluateHandoffReadiness as bJ, isAuthorizationAllowed as bK, mergeProtectedCandidate as bL, parseCheckEvidence as bM, parsePhaseResult as bN, parseRepositoryPolicy as bO, parseWorkBrief as bP, prepareHumanHandoff as bQ, processHumanReviewDecision as bR, requireTransition as bS, resolveAgentSelection as bT, resolveHumanReviewDecision as bU, runTriage as bV, type RunTriageOptions as ba, type SchedulePhaseInput as bb, type SchedulePhaseResult as bc, type SourceIssueCloser as bd, type SourceIssueClosureResult as be, type SourceReference as bf, type StoredEvent as bg, type SubmitPhaseResultInput as bh, type TransitionContext as bi, type TriageAssessment as bj, type TriageCategory as bk, type TriageInvestigationRequest as bl, type TriageInvestigator as bm, type TriageOutcome as bn, type TriageRecord as bo, type TriageResult as bp, type TriageSource as bq, type TriageSourceConflict as br, type TriageStore as bs, type VerificationPlan as bt, WORKFLOW_CONTRACT_VERSION as bu, type WorkIdentity as bv, type WorkItemKind as bw, type WorkKey as bx, type WorkRisk as by, type WorkScope as bz, type GitHubTrackedPullRequest as c, type GitHubIntegrationOptions as d, type GitHubWebhookRequest as e, type GitHubWebhookReceipt as f, type GitHubWebhookEnvelope as g, type GitHubNormalizationResult as h, type GitHubReconciliationInput as i, type GitHubReconciliationResult as j, type GitHubBriefFactoryInput as k, type GitHubPullRequestReviewSnapshot as l, type GitHubActor as m, type GitHubActorType as n, type GitHubAuthorizationPolicy as o, type GitHubBranchPublicationInput as p, type GitHubBranchSnapshot as q, type GitHubBriefDefaults as r, type GitHubBriefFactory as s, type GitHubBriefPublicationInput as t, type GitHubCheckPublicationInput as u, type GitHubCheckSnapshot as v, type GitHubCommentPublicationInput as w, type GitHubCommentSnapshot as x, type GitHubDeliveryStatus as y, type GitHubEventIgnoreReason as z };