@snappedly-tools/shipyard 0.7.0 → 0.9.0

package/dist/workflow.d.ts

@@ -0,0 +1,472 @@
+import { U as CoordinatorStorage, V as CoordinatorStorageTransaction, X as Assignment, W as WorkBrief, Y as RepositoryPolicy, Z as AgentSelection, _ as RevisionReference, $ as CheckEvidence, a0 as Finding, a1 as ReviewAxis, a2 as PhaseResult, a3 as FindingSeverity, a4 as ReviewEvidence, a5 as WorkflowCoordinator, I as GitHubPublication, a6 as WorkflowJob, a7 as DispatchResult, a8 as BranchLease, K as GitHubPublicationResult, O as GitHubPullRequestSnapshot, a9 as DispatchIntent, aa as WorkflowPhase, ab as RepositoryControl, D as GitHubIssueSnapshot, x as GitHubCommentSnapshot, ac as PostgresQueryClient } from './publication-BPoy_M9M.js';
+export { ad as AcquireBranchLeaseInput, ae as AgentModelRoles, af as AgentRole, ag as Authorization, ah as BranchProtectionState, ai as CheckCommand, aj as CheckStatus, ak as ClarificationReply, al as CloseSourceIssueOptions, am as CompletionInput, an as CompletionResult, ao as ContractValidationError, ap as CoordinatorClock, aq as CreateAssignmentInput, ar as CreateRepositoryPolicyInput, as as CreateWorkBriefInput, at as DispatchBlockReason, au as DispatchRequest, av as DispatchStatus, aw as EffectExecution, ax as EffectIntent, ay as EffectOperationContext, az as EffectStatus, aA as EventIgnoreReason, aB as EventStatus, aC as FindingDisposition, aD as HandoffCandidate, aE as HandoffOutcome, aF as HandoffPacket, aG as HandoffReadinessInput, aH as HandoffReadinessResult, aI as HumanApproval, aJ as HumanHandoffPublisher, aK as HumanReviewDecision, H as HumanReviewDecisionInput, aL as HumanReviewRoundTripOptions, aM as HumanReviewRoundTripResult, aN as InMemoryTriageStore, aO as InfrastructureFailureInput, aP as InfrastructureRetryResult, aQ as IngestResult, aR as JobControl, aS as LeaseBusyError, aT as LeaseLostError, aU as LifecycleState, aV as MergeCandidateOptions, aW as MergeResult, aX as MergeTransport, aY as PhaseBudget, aZ as PhaseOutcome, a_ as PhaseResultSubmission, a$ as PostgresConnection, b0 as PostgresCoordinatorStorage, b1 as PostgresCoordinatorStorageOptions, b2 as PostgresQueryResult, b3 as PostgresTriageStore, b4 as PostgresTriageStoreOptions, b5 as PrepareHandoffOptions, b6 as PublishEffectInput, b7 as RepairBudgetUsage, b8 as RepairRequestResult, b9 as RiskLevel, ba as RunTriageOptions, bb as SchedulePhaseInput, bc as SchedulePhaseResult, bd as SourceIssueCloser, be as SourceIssueClosureResult, bf as SourceReference, bg as StoredEvent, bh as SubmitPhaseResultInput, bi as TransitionContext, bj as TriageAssessment, bk as TriageCategory, bl as TriageInvestigationRequest, bm as TriageInvestigator, bn as TriageOutcome, bo as TriageRecord, bp as TriageResult, bq as TriageSource, br as TriageSourceConflict, bs as TriageStore, bt as VerificationPlan, bu as WORKFLOW_CONTRACT_VERSION, bv as WorkIdentity, bw as WorkItemKind, bx as WorkKey, by as WorkRisk, bz as WorkScope, bA as WorkerPolicy, bB as WorkflowCoordinatorOptions, bC as WorkflowEventInput, bD as closeSourceIssue, bE as completeSourceIssue, bF as createAssignment, bG as createRepositoryPolicy, bH as createWorkBrief, bI as defaultTriageInvestigator, bJ as evaluateHandoffReadiness, bK as isAuthorizationAllowed, bL as mergeProtectedCandidate, bM as parseCheckEvidence, bN as parsePhaseResult, bO as parseRepositoryPolicy, bP as parseWorkBrief, bQ as prepareHumanHandoff, bR as processHumanReviewDecision, bS as requireTransition, bT as resolveAgentSelection, bU as resolveHumanReviewDecision, bV as runTriage } from './publication-BPoy_M9M.js';
+import { l as OutputDefinition, A as AgentProvider, j as CreateSandboxOptions, a as Sandbox, p as RunOptions, q as RunResult } from './createSandbox-DmbnWAZv.js';
+import { S as SandboxProvider } from './SandboxProvider-oUAwYlWm.js';
+import '@standard-schema/spec';
+
+/**
+ * Deterministic storage for coordinator tests. Each transaction runs against
+ * an isolated draft and commits atomically when the callback succeeds.
+ */
+declare class InMemoryCoordinatorStorage implements CoordinatorStorage {
+    private state;
+    private transactionTail;
+    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
+}
+
+interface TrustedPhaseInputs {
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly skill: {
+        readonly revision: string;
+        readonly content: string;
+    };
+}
+interface UntrustedPhaseInputs {
+    readonly sourceText: string;
+    readonly repositoryContent: readonly string[];
+}
+interface PhaseControls {
+    readonly toolAllowlist: readonly string[];
+    readonly credentialAllowlist: readonly string[];
+    readonly timeoutSeconds: number;
+    readonly maxIterations: number;
+}
+interface CredentialResolver {
+    resolve(name: string): Promise<string | undefined>;
+}
+declare class CredentialNotAllowedError extends Error {
+    constructor(name: string);
+}
+declare class CredentialUnavailableError extends Error {
+    constructor(name: string);
+}
+interface PhaseCredentials {
+    get(name: string): Promise<string>;
+}
+interface PhaseCheckout {
+    readonly branch: string;
+    readonly candidate?: RevisionReference;
+    readonly immutable: boolean;
+}
+interface PhaseEngineRequest {
+    readonly assignment: Assignment;
+    readonly agentSelection: AgentSelection;
+    readonly trusted: TrustedPhaseInputs;
+    readonly untrusted: UntrustedPhaseInputs;
+    readonly controls: PhaseControls;
+    readonly credentials: PhaseCredentials;
+    readonly signal: AbortSignal;
+    readonly checkout: PhaseCheckout;
+    readonly output?: OutputDefinition;
+}
+interface PhaseArtifact {
+    readonly name: string;
+    readonly kind: "stdout" | "stderr" | "patch" | "log" | "worktree" | "other";
+    readonly content: string;
+}
+interface ArtifactStore {
+    save(artifact: PhaseArtifact): Promise<void>;
+}
+interface InMemoryArtifactStore extends ArtifactStore {
+    readonly artifacts: PhaseArtifact[];
+}
+declare const createInMemoryArtifactStore: () => InMemoryArtifactStore;
+interface PhaseReport {
+    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[];
+    readonly reviewAxes?: readonly ReviewAxis[];
+}
+interface PhaseEngineResponse {
+    readonly stdout: string;
+    readonly stderr?: string;
+    readonly completionSignal?: string;
+    /** Kept for adapters that already validate output; executePhase revalidates stdout. */
+    readonly structuredOutput?: unknown;
+    readonly commits: readonly (string | {
+        readonly sha: string;
+    })[];
+    readonly branch: string;
+    readonly headSha: string;
+    readonly report: PhaseReport;
+    readonly artifacts?: readonly PhaseArtifact[];
+    readonly preservedWorktreePath?: string;
+    readonly outcome?: "completed" | "needs-info";
+}
+interface PhaseEngineAdapter {
+    /**
+     * Execute one phase. After `request.signal` aborts, this promise MUST settle
+     * only after the provider has stopped all work that can mutate the candidate.
+     */
+    execute(request: PhaseEngineRequest): Promise<PhaseEngineResponse>;
+}
+interface FakePhaseEngineAdapterOptions {
+    readonly response?: PhaseEngineResponse;
+    readonly respond?: (request: PhaseEngineRequest) => Promise<PhaseEngineResponse>;
+}
+declare const createFakePhaseEngineAdapter: (options: FakePhaseEngineAdapterOptions) => PhaseEngineAdapter;
+type PhaseExecutionStatus = "completed" | "needs-info" | "provider-failure" | "cancelled" | "timed-out" | "failed-verification";
+interface PhaseFailure {
+    readonly kind: "provider" | "timeout" | "cancellation" | "validation";
+    readonly message: string;
+}
+interface PhaseExecutionResult {
+    readonly status: PhaseExecutionStatus;
+    readonly phaseResult: PhaseResult;
+    readonly output?: unknown;
+    readonly failure?: PhaseFailure;
+}
+interface ExecutePhaseOptions {
+    readonly assignment: Assignment;
+    /** Dedicated mutation branch for implementation and repair phases. */
+    readonly branch?: string;
+    readonly trusted: TrustedPhaseInputs;
+    readonly untrusted: UntrustedPhaseInputs;
+    readonly controls: PhaseControls;
+    readonly adapter: PhaseEngineAdapter;
+    readonly artifactStore: ArtifactStore;
+    readonly credentialResolver: CredentialResolver;
+    readonly output?: OutputDefinition;
+    readonly signal?: AbortSignal;
+}
+declare const executePhase: (options: ExecutePhaseOptions) => Promise<PhaseExecutionResult>;
+type PhaseAgentResolver = {
+    /** Pre-resolved provider for legacy single-model policies. */
+    readonly agent: AgentProvider;
+    readonly resolveAgent?: never;
+} | {
+    readonly agent?: never;
+    /** Creates the provider selected by the assignment's trusted policy. */
+    readonly resolveAgent: (selection: AgentSelection) => AgentProvider;
+};
+type RunPhaseEngineAdapterOptions = PhaseAgentResolver & {
+    readonly sandbox: SandboxProvider;
+    readonly cwd?: string;
+    readonly run: (options: RunOptions) => Promise<RunResult & {
+        output?: unknown;
+    }>;
+};
+declare const createRunPhaseEngineAdapter: (options: RunPhaseEngineAdapterOptions) => PhaseEngineAdapter;
+type CreateSandboxPhaseEngineAdapterOptions = PhaseAgentResolver & {
+    readonly sandbox: SandboxProvider;
+    readonly cwd?: string;
+    readonly createSandbox: (options: CreateSandboxOptions) => Promise<Sandbox>;
+};
+declare const createCreateSandboxPhaseEngineAdapter: (options: CreateSandboxPhaseEngineAdapterOptions) => PhaseEngineAdapter;
+
+type ReviewRunOutcome = "passed" | "actionable-findings" | "incomplete" | "blocked" | "failed";
+interface ReviewCandidate {
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly requiredAxes?: readonly ReviewAxis[];
+}
+interface ReviewCheckout {
+    readonly base: RevisionReference;
+    readonly candidate: RevisionReference;
+    readonly immutable: true;
+}
+interface ReviewRequest {
+    readonly candidate: ReviewCandidate;
+    readonly checkout: ReviewCheckout;
+    readonly signal: AbortSignal;
+}
+interface ReviewFindingInput {
+    readonly id: string;
+    readonly severity: FindingSeverity;
+    readonly axis: ReviewAxis;
+    readonly title: string;
+    readonly evidence: string;
+    readonly location?: string;
+    readonly requirement?: string;
+    readonly verification?: string;
+}
+interface ReviewResponse {
+    readonly outcome?: ReviewRunOutcome;
+    readonly axes: readonly ReviewAxis[];
+    readonly findings: readonly ReviewFindingInput[];
+    readonly evidence: readonly string[];
+    readonly headSha: string;
+    readonly baseSha?: string;
+    readonly briefHash: string;
+    /** Any returned commit or changed file means the reviewer violated read-only review. */
+    readonly commits?: readonly string[];
+    readonly changedFiles?: readonly string[];
+}
+interface ReviewProvider {
+    review(request: ReviewRequest): Promise<ReviewResponse>;
+}
+interface CurrentCandidate {
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly briefHash: string;
+}
+interface IndependentReviewOptions {
+    readonly candidate: ReviewCandidate;
+    readonly provider: ReviewProvider;
+    readonly readCurrent?: () => Promise<CurrentCandidate>;
+    readonly signal?: AbortSignal;
+}
+interface ReviewFailure {
+    readonly kind: "provider" | "malformed" | "stale-candidate" | "mutation";
+    readonly message: string;
+}
+interface IndependentReviewResult {
+    readonly outcome: ReviewRunOutcome;
+    readonly candidate: ReviewCandidate;
+    readonly reviewAxes: readonly ReviewAxis[];
+    readonly findings: readonly Finding[];
+    readonly evidence: readonly string[];
+    readonly reviewEvidence: ReviewEvidence;
+    readonly failure?: ReviewFailure;
+}
+/** Run a read-only, candidate-bound review and normalize its evidence. */
+declare const runIndependentReview: (options: IndependentReviewOptions) => Promise<IndependentReviewResult>;
+
+interface CurrentImplementationCandidate {
+    readonly base: RevisionReference;
+    readonly briefHash: string;
+}
+interface ImplementationExecutionTemplate extends Omit<ExecutePhaseOptions, "assignment" | "branch"> {
+    readonly branch?: string;
+}
+interface AuthorizedImplementationOptions {
+    readonly coordinator: WorkflowCoordinator;
+    readonly publication: GitHubPublication;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly workerId: string;
+    readonly issueNumber?: number;
+    readonly branch?: string;
+    readonly execution?: ImplementationExecutionTemplate;
+    readonly readCurrent?: () => Promise<CurrentImplementationCandidate>;
+    readonly now?: () => string;
+    readonly leaseTtlMs?: number;
+}
+type ImplementationOutcome = "dispatched" | "completed" | "needs-info" | "blocked" | "failed";
+interface ImplementationPublication {
+    readonly brief?: GitHubPublicationResult<unknown>;
+    readonly checks: readonly GitHubPublicationResult<unknown>[];
+    readonly branch?: GitHubPublicationResult<unknown>;
+    readonly pullRequest?: GitHubPublicationResult<GitHubPullRequestSnapshot>;
+}
+interface AuthorizedImplementationResult {
+    readonly outcome: ImplementationOutcome;
+    readonly reason?: string;
+    readonly job?: WorkflowJob;
+    readonly dispatch?: DispatchResult;
+    readonly assignment?: Assignment;
+    readonly lease?: BranchLease;
+    readonly phaseResult?: PhaseResult;
+    readonly execution?: PhaseExecutionResult;
+    readonly publication?: ImplementationPublication;
+    readonly pullRequest?: GitHubPullRequestSnapshot;
+    readonly nextPhase?: "review";
+    readonly nextDispatch?: DispatchIntent;
+    readonly readyForReview: boolean;
+}
+interface ReviewSchedulingInput {
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly checks: readonly CheckEvidence[];
+    readonly requiredAxes?: ReviewCandidate["requiredAxes"];
+}
+interface ReviewSchedulingResult {
+    readonly status: "ready" | "blocked";
+    readonly reasons: readonly string[];
+    readonly candidate?: ReviewCandidate;
+}
+/** Build a review candidate only after the current implementation checks pass. */
+declare const prepareIndependentReview: (input: ReviewSchedulingInput) => ReviewSchedulingResult;
+declare const runAuthorizedImplementation: (options: AuthorizedImplementationOptions) => Promise<AuthorizedImplementationResult>;
+
+interface CostMeasurement {
+    readonly currency?: string;
+    readonly amount?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly provider?: string;
+    readonly model?: string;
+}
+interface OperatorStatusOptions {
+    readonly cost?: CostMeasurement;
+    readonly now?: string;
+}
+interface OperatorCheckStatus {
+    readonly name: string;
+    readonly command: string;
+    readonly status: CheckEvidence["status"];
+    readonly summary: string;
+    readonly artifactRefs?: readonly string[];
+}
+interface OperatorStatus {
+    readonly jobId: string;
+    readonly repository: string;
+    readonly itemId: string;
+    readonly kind: string;
+    readonly state: WorkflowJob["state"];
+    readonly control: WorkflowJob["control"];
+    readonly phase: WorkflowPhase;
+    readonly waitingReason?: string;
+    readonly queueAgeSeconds: number;
+    readonly attempts: Readonly<Record<WorkflowPhase, number>>;
+    readonly activeAssignmentId?: string;
+    readonly latestObservedAt: string;
+    readonly checks: readonly OperatorCheckStatus[];
+    readonly artifacts: readonly string[];
+    readonly cost: {
+        readonly status: "unknown";
+    } | ({
+        readonly status: "measured";
+    } & CostMeasurement);
+    readonly interventions: readonly OperatorIntervention[];
+    readonly repositoryControl?: RepositoryControl;
+}
+interface OperatorIntervention {
+    readonly action: "pause" | "cancel" | "resume" | "stop-repository" | "resume-repository";
+    readonly reason?: string;
+    readonly at: string;
+}
+interface WorkflowOperatorOptions {
+    readonly coordinator: WorkflowCoordinator;
+    readonly now?: () => string;
+}
+declare const redact: (value: string) => string;
+declare class WorkflowOperator {
+    private readonly coordinator;
+    private readonly now;
+    private readonly interventions;
+    constructor(options: WorkflowOperatorOptions);
+    status(jobId: string, options?: OperatorStatusOptions): Promise<OperatorStatus>;
+    pause(jobId: string, reason?: string): Promise<WorkflowJob>;
+    cancel(jobId: string, reason?: string): Promise<WorkflowJob>;
+    resume(jobId: string): Promise<WorkflowJob>;
+    stopRepository(repository: string, reason?: string): Promise<RepositoryControl>;
+    resumeRepository(repository: string): Promise<RepositoryControl>;
+    private record;
+}
+
+interface RepairCandidate {
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly briefHash: string;
+}
+interface RepairBatch {
+    readonly id: string;
+    readonly jobId: string;
+    readonly sourceIssueNumber?: number;
+    readonly pullRequestNumber?: number;
+    readonly candidate: RepairCandidate;
+    readonly brief: WorkBrief;
+    readonly findings: readonly Finding[];
+    readonly followUp: boolean;
+    readonly createdAt: string;
+}
+interface RepairBatchStore {
+    get(key: string): RepairBatchResult | undefined | Promise<RepairBatchResult | undefined>;
+    save(key: string, result: RepairBatchResult, updatedAt?: string): void | Promise<void>;
+}
+declare class InMemoryRepairBatchStore implements RepairBatchStore {
+    private readonly results;
+    get(key: string): RepairBatchResult | undefined;
+    save(key: string, result: RepairBatchResult): void;
+}
+interface PostgresRepairBatchStoreOptions {
+    readonly client: PostgresQueryClient;
+}
+/** Durable bounded-repair records backed by the coordinator's PostgreSQL database. */
+declare class PostgresRepairBatchStore implements RepairBatchStore {
+    private readonly records;
+    constructor(options: PostgresRepairBatchStoreOptions);
+    get(key: string): Promise<RepairBatchResult | undefined>;
+    save(key: string, result: RepairBatchResult, updatedAt?: string): Promise<void>;
+}
+interface CurrentRepairCandidate {
+    readonly base: RevisionReference;
+    readonly head: RevisionReference;
+    readonly briefHash: string;
+    readonly pullRequest?: GitHubPullRequestSnapshot;
+}
+interface ScheduleRepairOptions {
+    readonly coordinator: WorkflowCoordinator;
+    readonly publication: GitHubPublication;
+    readonly store: RepairBatchStore;
+    readonly jobId: string;
+    readonly brief: WorkBrief;
+    readonly policy: RepositoryPolicy;
+    readonly candidate: RepairCandidate;
+    readonly workerId: string;
+    readonly sourceIssueNumber?: number;
+    readonly pullRequestNumber?: number;
+    readonly followUp?: boolean;
+    readonly pullRequestState?: "open" | "closed";
+    readonly readCurrent?: () => Promise<CurrentRepairCandidate>;
+    readonly now?: () => string;
+    readonly leaseTtlMs?: number;
+}
+type RepairScheduleOutcome = "scheduled" | "duplicate" | "blocked";
+interface RepairBatchResult {
+    readonly outcome: RepairScheduleOutcome;
+    readonly reason?: string;
+    readonly batch: RepairBatch;
+    readonly job?: WorkflowJob;
+    readonly dispatch?: DispatchIntent;
+    /** Fresh dispatch ID to reclaim when its saved claim has expired. */
+    readonly resumeDispatchId?: string;
+    readonly lease?: BranchLease;
+    readonly repairIssue?: GitHubIssueSnapshot;
+    readonly issuePublication?: GitHubPublicationResult<GitHubIssueSnapshot>;
+    readonly linkPublication?: GitHubPublicationResult<GitHubCommentSnapshot>;
+}
+interface ScheduleRepairInput extends ScheduleRepairOptions {
+    readonly findings: readonly Finding[];
+}
+interface RepairExecutionTemplate extends Omit<ExecutePhaseOptions, "assignment" | "branch"> {
+    readonly branch?: string;
+}
+interface RunBoundedRepairOptions extends ScheduleRepairInput {
+    readonly execution: RepairExecutionTemplate;
+}
+interface BoundedRepairExecutionResult {
+    readonly outcome: "completed" | "needs-info" | "failed" | "blocked";
+    readonly reason?: string;
+    readonly repair: RepairBatchResult;
+    readonly assignment?: Assignment;
+    readonly dispatch?: DispatchResult;
+    readonly execution?: PhaseExecutionResult;
+    readonly phaseResult?: PhaseResult;
+    readonly nextPhase?: "checking" | "review";
+    readonly nextDispatch?: DispatchIntent;
+}
+declare const scheduleBoundedRepair: (input: ScheduleRepairInput) => Promise<RepairBatchResult>;
+/** Execute a scheduled repair on the existing leased branch; review remains a separate phase. */
+declare const runBoundedRepair: (input: RunBoundedRepairOptions) => Promise<BoundedRepairExecutionResult>;
+
+type WorkflowPhaseRecordKind = "triage" | "repair-batch";
+/** Persistence shared by workflow phases whose records do not belong in the coordinator ledger. */
+interface WorkflowPhaseRecordStore {
+    get(kind: WorkflowPhaseRecordKind, key: string): Promise<unknown | undefined>;
+    save(kind: "repair-batch", key: string, record: unknown, updatedAt: string): Promise<void>;
+    compareAndSaveTriage(key: string, expectedRevision: number | undefined, record: unknown, updatedAt: string): Promise<boolean>;
+}
+interface PostgresWorkflowPhaseRecordStoreOptions {
+    readonly client: PostgresQueryClient;
+}
+/** Stores resumable triage and repair records in the coordinator database. */
+declare class PostgresWorkflowPhaseRecordStore implements WorkflowPhaseRecordStore {
+    private readonly client;
+    constructor(options: PostgresWorkflowPhaseRecordStoreOptions);
+    get(kind: WorkflowPhaseRecordKind, key: string): Promise<unknown | undefined>;
+    save(kind: "repair-batch", key: string, record: unknown, updatedAt: string): Promise<void>;
+    compareAndSaveTriage(key: string, expectedRevision: number | undefined, record: unknown, updatedAt: string): Promise<boolean>;
+}
+
+export { AgentSelection, type ArtifactStore, Assignment, type AuthorizedImplementationOptions, type AuthorizedImplementationResult, type BoundedRepairExecutionResult, BranchLease, CheckEvidence, CoordinatorStorage, CoordinatorStorageTransaction, type CostMeasurement, type CreateSandboxPhaseEngineAdapterOptions, CredentialNotAllowedError, type CredentialResolver, CredentialUnavailableError, type CurrentCandidate, type CurrentImplementationCandidate, type CurrentRepairCandidate, DispatchIntent, DispatchResult, type ExecutePhaseOptions, type FakePhaseEngineAdapterOptions, Finding, FindingSeverity, type ImplementationExecutionTemplate, type ImplementationOutcome, type ImplementationPublication, type InMemoryArtifactStore, InMemoryCoordinatorStorage, InMemoryRepairBatchStore, type IndependentReviewOptions, type IndependentReviewResult, type OperatorCheckStatus, type OperatorIntervention, type OperatorStatus, type OperatorStatusOptions, type PhaseAgentResolver, type PhaseArtifact, type PhaseCheckout, type PhaseControls, type PhaseCredentials, type PhaseEngineAdapter, type PhaseEngineRequest, type PhaseEngineResponse, type PhaseExecutionResult, type PhaseExecutionStatus, type PhaseFailure, type PhaseReport, PhaseResult, PostgresQueryClient, PostgresRepairBatchStore, type PostgresRepairBatchStoreOptions, PostgresWorkflowPhaseRecordStore, type PostgresWorkflowPhaseRecordStoreOptions, type RepairBatch, type RepairBatchResult, type RepairBatchStore, type RepairCandidate, type RepairExecutionTemplate, type RepairScheduleOutcome, RepositoryControl, RepositoryPolicy, ReviewAxis, type ReviewCandidate, type ReviewCheckout, ReviewEvidence, type ReviewFailure, type ReviewFindingInput, type ReviewProvider, type ReviewRequest, type ReviewResponse, type ReviewRunOutcome, type ReviewSchedulingInput, type ReviewSchedulingResult, RevisionReference, type RunBoundedRepairOptions, type RunPhaseEngineAdapterOptions, type ScheduleRepairInput, type ScheduleRepairOptions, type TrustedPhaseInputs, type UntrustedPhaseInputs, WorkBrief, WorkflowCoordinator, WorkflowJob, WorkflowOperator, type WorkflowOperatorOptions, WorkflowPhase, type WorkflowPhaseRecordKind, type WorkflowPhaseRecordStore, createCreateSandboxPhaseEngineAdapter, createFakePhaseEngineAdapter, createInMemoryArtifactStore, createRunPhaseEngineAdapter, executePhase, prepareIndependentReview, redact as redactOperatorText, runAuthorizedImplementation, runBoundedRepair, runIndependentReview, scheduleBoundedRepair };