@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { loadConfig, loadConfigAsync, type AiSdlcConfig } from './config.js';
+export { loadConfig, loadConfigAsync, type AiSdlcConfig, type ConfigLoadWarning, } from './config.js';
 export { validateIssue, validateIssueWithExtensions, parseComplexity } from './validate-issue.js';
 export { executePipeline, type ExecuteOptions, type PipelineResult, type PromotionResult, } from './execute.js';
 export { validateAgentOutput, type ValidationContext, type ValidationResult, type ValidationViolation, } from './validate-agent-output.js';
 export { createLogger, type Logger } from './logger.js';
 export { validateConfigFiles, type FileValidationResult } from './validate-config.js';
 export { executeFixCI, countRetryAttempts, fetchCILogs, type FixCIOptions } from './fix-ci.js';
+export { executeFixReview, countRetryAttempts as countReviewRetryAttempts, fetchReviewFindings, type FixReviewOptions, } from './fix-review.js';
 export { executeTriage, type TriageOptions, type TriageResult } from './triage.js';
 export { getGitHubConfig, resolveRepoRoot, createDefaultAuditLog, resolveAutonomyLevel, resolveConstraints, mergeBlockedPaths, isAutonomousStrategy, recordMetric, validateAndAuditOutput, createPipelineMemory, evaluatePipelineCompliance, authorizeFilesChanged, extractIssueNumber, extractIssueId, issueIdToNumber, formatIssueRef, BRANCH_PATTERN, createAbacPermissionHook, createBlockedPathsHook, createAuditLoggingHook, createPipelineAuthorizationChain, type GitHubEnvConfig, type ValidateAndAuditParams, } from './shared.js';
 export { DEFAULT_MODEL, DEFAULT_GITHUB_ORG, DEFAULT_GITHUB_REPO, DEFAULT_GITHUB_REPOSITORY, DEFAULT_CONFIG_DIR_NAME, DEFAULT_SANDBOX_MEMORY_MB, DEFAULT_SANDBOX_CPU_PERCENT, DEFAULT_SANDBOX_NETWORK_POLICY, DEFAULT_SANDBOX_TIMEOUT_MS, defaultSandboxConstraints, DEFAULT_RUNNER_TIMEOUT_MS, DEFAULT_ALLOWED_TOOLS, DEFAULT_MAX_FILES_PER_CHANGE, DEFAULT_REQUIRE_TESTS, DEFAULT_BLOCKED_PATHS, DEFAULT_MAX_FIX_ATTEMPTS, DEFAULT_MAX_LOG_LINES, DEFAULT_GH_CLI_TIMEOUT_MS, DEFAULT_JIT_TTL_MS, DEFAULT_JIT_SCOPE, DEFAULT_BRANCH_TEMPLATE, DEFAULT_BRANCH_PATTERN, DEFAULT_PR_TITLE_TEMPLATE, DEFAULT_PR_FOOTER, DEFAULT_COMPLEXITY_THRESHOLDS, DEFAULT_MAX_LINES_PER_PR, DEFAULT_ANALYSIS_INCLUDE, DEFAULT_ANALYSIS_EXCLUDE, DEFAULT_GIT_HISTORY_DAYS, DEFAULT_HOTSPOT_THRESHOLD, NOTIFICATION_TITLES, DEFAULT_MODEL_COSTS, DEFAULT_COST_BUDGET_USD, DEFAULT_DASHBOARD_REFRESH_MS, PROGRESSIVE_GATE_PROFILES, DEFAULT_LINT_COMMAND, DEFAULT_FORMAT_COMMAND, DEFAULT_COMMIT_MESSAGE_TEMPLATE, DEFAULT_COMMIT_CO_AUTHOR, DEFAULT_OPENAI_API_URL, DEFAULT_OPENAI_MODEL, DEFAULT_ANTHROPIC_API_URL, DEFAULT_ANTHROPIC_MODEL, DEFAULT_GENERIC_LLM_MODEL, DEFAULT_LLM_TIMEOUT_MS, DEFAULT_LLM_MAX_TOKENS, DEFAULT_LLM_SYSTEM_PROMPT, DEFAULT_DOCKER_IMAGE, DEFAULT_WORKFLOW_FILE, DEFAULT_LABEL_TO_SKILL_MAP, DEFAULT_ANALYSIS_CACHE_TTL_MS, } from './defaults.js';
@@ -18,6 +19,28 @@ export { createPipelineDiscovery, findMatchingAgent, resolveAgentForIssue, match
 export { createStructuredConsoleLogger, createStructuredBufferLogger, } from './structured-logger.js';
 export { startWatch, type WatchOptions, type WatchHandle } from './watch.js';
 export { computePriority, rankWorkItems, type PriorityScore, type PriorityInput, type PriorityConfig, } from './priority.js';
+export { checkAction, enforceAction, DEFAULT_BLOCKED_ACTIONS, type ActionEnforcementResult, } from './action-enforcement.js';
+export { scoreIssueForAdmission, mapIssueToPriorityInput, type AdmissionInput, type AdmissionThresholds, type IssueAdmissionResult, type AuthorAssociation, type DesignSystemContext, type AutonomyContext, type CodeAreaQuality, type DesignAuthoritySignal, type DesignAuthoritySignalType, type DesignQualityMetrics, } from './admission-score.js';
+export { enrichAdmissionInput, computeDesignSystemReadiness, computeReadinessFromDesignSystemContext, computeDefectRiskFactor, computeAutonomyFactor, computeDesignAuthorityWeight, complexityToAutonomyLevel, type EnrichmentContext, type LifecyclePhase, } from './admission-enrichment.js';
+export { computeAdmissionComposite, type AdmissionComposite } from './admission-composite.js';
+export { parseBacklogTask, loadBacklogTaskFromRoot, mapBacklogTaskToAdmissionInput, loadSoulTracks, loadMaintainers, type BacklogTaskSnapshot, type BacklogAcceptanceCriterion, type BacklogMappingOptions, type BacklogAdmissionMapping, } from './backlog-adapter.js';
+export { computePillarBreakdown, detectTensions, pillarSignalScore, type PillarBreakdown, type PillarContribution, type PillarName, type SharedDimensions, type TensionFlag, type TensionFlagType, type HcChannelBreakdown, } from './pillar-breakdown.js';
+export { compileDid, validatePhase2bReadiness, hashDidSpec, canonicalJson, tokenize, serializeForStore, deserializeFromStore, type CompiledDid, type CompiledScopeLists, type CompiledScopeEntry, type CompiledConstraintRule, type CompiledAntiPattern, type CompiledAntiPatternLists, type CompiledMeasurableSignal, type Bm25Corpus, type Bm25Document, type PrincipleCorpora, type ReadinessResult, } from './sa-scoring/did-compiler.js';
+export { HttpDepparseClient, FakeDepparseClient, DepparseError, type DepparseClient, type DepparseMatch, type DepparseMatchRequest, type DepparseMatchResponse, type DepparseHealth, type DepparseErrorKind, } from './sa-scoring/depparse-client.js';
+export { runLayer1, checkScopeGate, detectConstraintViolations, detectAntiPatterns, checkMeasurableSignals, renderPreVerifiedSummary, type DeterministicScoringResult, type ScopeGateResult, type ScopeGateMatch, type ConstraintViolation, type ConstraintViolationResult, type AntiPatternHit, type AntiPatternResult, type MeasurableSignalCheck, type MeasurableSignalResult, type Layer1Input, } from './sa-scoring/layer1-deterministic.js';
+export { computeDomainRelevance, computePrincipleCoverage, type DomainRelevanceResult, type PrincipleCoverageVector, type PrincipleCoverageEntry, type ContributingTerm, } from './sa-scoring/layer2-structural.js';
+export { runLayer3, buildSa1Prompt, buildSa2Prompt, extractJson, RecordedLLMClient, LayerLlmError, CONFIDENCE_THRESHOLD, type LLMClient, type LLMScoringResult, type SubtleConflict, type SubtleDesignConflict, type Layer3Input, type PromptContext, type LayerLlmErrorKind, } from './sa-scoring/layer3-llm.js';
+export { computeSoulAlignment, computeSa1, computeSa2, getPhaseWeights, W_STRUCTURAL_FLOOR, type SoulAlignmentResult, type SoulAlignmentInput, type Sa1Inputs, type Sa2Inputs, type Sa1Result, type Sa2Result, type SaPhase, type PhaseWeights, } from './sa-scoring/composite.js';
+export { computeSa2Computable, type Sa2ComputableResult } from './sa-scoring/c1-sa2-computable.js';
+export { SAFeedbackStore, SA_FEEDBACK_LABELS, classifyLabel, recordOverrideFeedback, type RecordFeedbackInput, type PrecisionWindow, type PrecisionResult, type CategoryFalsePositive, type OverrideFeedbackInput, } from './sa-scoring/feedback-store.js';
+export { computeCalibrationCoefficient, buildCategoryCoefficients, type CategoryFeedback, type BuildCategoryCoefficientsInput, } from './calibration.js';
+export { autoCalibratePhaseWeights, computePhase3Weights, decideCalibrationDirection, renderCalibrationDiff, WEIGHT_FLOOR, WEIGHT_CEILING, DEFAULT_SHIFT_SIZE, DEFAULT_WINDOW_DAYS, PRECISION_DELTA_THRESHOLD, type PrecisionPair, type CalibrationDecision, type ComputePhase3WeightsInput, type AutoCalibrateDeps, type AutoCalibrateResult, type DimensionDiff, } from './sa-scoring/auto-calibrate.js';
+export { detectSoulDrift, computeWindowStats, computeTrend, describeDriftSource, DEFAULT_MEAN_THRESHOLD, DEFAULT_STDDEV_THRESHOLD, DEFAULT_CONSECUTIVE_WINDOWS, DEFAULT_RECOVERY_MS, type SoulDriftDetectedEvent, type DriftTrend, type WindowStats, type DriftDetectorDeps, } from './sa-scoring/drift-monitor.js';
+export { handleCoreIdentityChanged, type CoreIdentityChangedEvent, type BacklogReshuffledEvent, type SoulGraphStaleFlag, type RescoreDeps, type HandleResult, } from './sa-scoring/rescore-orchestrator.js';
+export { scoreSoulAlignment, resolveSoulAlignmentOverride, type ScoreSoulAlignmentInput, type ScoreSoulAlignmentDeps, type SoulAlignmentScoringResult, } from './sa-scoring/index.js';
+export type { SaDimension, FeedbackSignal } from './state/types.js';
+export { executeReview, type ReviewContext, type ReviewOptions } from './review.js';
+export { metaReview, ReviewFeedbackStore, type MetaReviewDecision, type MetaReviewResult, type ReviewFeedback, } from './review-meta.js';
 export { createPipelineOrchestration, executePipelineOrchestration, validatePipelineHandoffs, sequential, parallel, hybrid, hierarchical, swarm, validateHandoff, simpleSchemaValidate, } from './orchestration.js';
 export { createPipelineRegoEvaluator, createPipelineCELEvaluator, createPipelineABACHook, createPipelineExpressionEvaluator, createPipelineLLMEvaluator, evaluatePipelineGate, scorePipelineComplexity, evaluatePipelineComplexityRouting, } from './policy-evaluators.js';
 export { createPipelineAdapterRegistry, createPipelineWebhookBridge, resolveAdapterFromGit, resolveInfrastructure, resolveIssueTrackerFromConfig, scanPipelineAdapters, } from './adapters.js';
@@ -25,12 +48,14 @@ export { createPipelineReconciler, createGateReconciler, createAutonomyReconcile
 export { createFileAuditLog, verifyAuditIntegrity, loadAuditEntries, rotateAuditLog, computeAuditHash, } from './audit-extended.js';
 export { checkFrameworkCompliance, getControlCatalog, getFrameworkMappings, listSupportedFrameworks, } from './compliance-extended.js';
 export { createSilentLogger, withPipelineSpanSync, getPipelineTracer, validateResourceSchema, } from './telemetry-extended.js';
-export { ClaudeCodeRunner, ClaudeCodeRunner as GitHubActionsRunner, GenericLLMRunner, CopilotRunner, CursorRunner, CodexRunner, RunnerRegistry, createRunnerRegistry, SecurityTriageRunner, type AgentRunner, type AgentContext, type AgentResult, type GenericLLMConfig, type RegisteredRunner, type SecurityTriageConfig, type TriageVerdict, } from './runners/index.js';
+export { ClaudeCodeRunner, ClaudeCodeRunner as GitHubActionsRunner, GenericLLMRunner, CopilotRunner, CursorRunner, CodexRunner, RunnerRegistry, createRunnerRegistry, SecurityTriageRunner, ReviewAgentRunner, REVIEW_PROMPTS, type AgentRunner, type AgentContext, type AgentResult, type AgentProgressEvent, type GenericLLMConfig, type RegisteredRunner, type SecurityTriageConfig, type TriageVerdict, type ReviewAgentConfig, type ReviewType, type ReviewFinding, type ReviewVerdict, } from './runners/index.js';
 export type { TokenUsage } from './runners/index.js';
 export { SlackMessenger, TeamsMessenger, NotificationRouter } from './notifications/index.js';
 export type { SlackConfig, TeamsConfig, PipelineEvent, PipelineEventType, NotificationRoute, NotificationTemplate, } from './notifications/index.js';
 export { StateStore } from './state/index.js';
-export type { HotspotRecord, RoutingDecision, CostLedgerEntry, GateThresholdOverride, AutonomyEvent, AutonomyEventType, HandoffEvent, DeploymentRecord, DeploymentRecordState, RolloutStepRecord, AuditEntryRecord, PriorityCalibrationSample, } from './state/index.js';
+export type { HotspotRecord, RoutingDecision, CostLedgerEntry, GateThresholdOverride, AutonomyEvent, AutonomyEventType, HandoffEvent, DeploymentRecord, DeploymentRecordState, RolloutStepRecord, AuditEntryRecord, PriorityCalibrationSample, ToolSequenceEvent, WorkflowPattern, PatternProposal, } from './state/index.js';
+export { readToolSequenceJSONL, readSessionMetaFiles, sessionMetaToEvents, categorizeAction, DEFAULT_DETECTION_OPTIONS, } from './workflow-patterns/index.js';
+export type { CanonicalStep, NGram, DetectedPattern, DetectionOptions, RawToolSequenceEntry, SessionMeta, } from './workflow-patterns/index.js';
 export { createKubernetesTarget, createVercelTarget, createFlyioTarget, createHttpMetricsCollector, createStubMetricsCollector, RolloutController, } from './deploy/index.js';
 export type { DeploymentTargetConfig, HealthCheckConfig, DeploymentState, DeploymentResult, DeploymentTarget, ExecFn, FetchFn, KubernetesConfig, VercelConfig, FlyioConfig, CanaryStep, CanaryConfig, BlueGreenConfig, RollingConfig, RolloutStrategy, RolloutPhase, RolloutStatus, RolloutMetrics, MetricsSource, RolloutControllerConfig, HttpMetricsConfig, } from './deploy/index.js';
 export { getComplexityBand, getGateProfile, adjustEnforcement, adjustGateForComplexity, adjustGatesForComplexity, computeGateAdjustments, } from './progressive-gates.js';
@@ -49,8 +74,8 @@ export { createOTelBridge, isOTelAvailable } from './otel-exporter.js';
 export type { OTelBridge, OTelBridgeOptions, OTelSpanHandle } from './otel-exporter.js';
 export { renderDashboardFrame } from './cli/dashboard-renderer.js';
 export type { DashboardData } from './cli/dashboard-renderer.js';
-export { walkFiles, detectModules, parseImports, buildModuleGraph, detectConventions, detectPatterns, analyzeHotspots, computeComplexityScore, analyzeCodebase, buildCodebaseContext, formatContextForPrompt, } from './analysis/index.js';
-export type { CodebaseProfile, CodebaseContext, Hotspot, ArchitecturalPattern, DetectedConvention, ModuleInfo, ModuleGraph, DependencyEdge, AnalyzerOptions, FileInfo, ImportStatement, } from './analysis/index.js';
+export { walkFiles, detectModules, parseImports, buildModuleGraph, detectConventions, detectReactProject, loadProjectAliases, parseTsConfigAliases, parseViteOrWebpackAliases, enumerateTestLocations, detectPatterns, analyzeHotspots, computeComplexityScore, analyzeCodebase, buildCodebaseContext, formatContextForPrompt, analyzeDiff, extractChangedFiles, } from './analysis/index.js';
+export type { CodebaseProfile, CodebaseContext, Hotspot, ArchitecturalPattern, DetectedConvention, ModuleInfo, ModuleGraph, DependencyEdge, AnalyzerOptions, FileInfo, ImportStatement, DiffFinding, DiffAnalysisResult, DetectConventionsOptions, PathAliasMap, TestLocationSummary, } from './analysis/index.js';
 export { createCheckRun, updateCheckRun, reportGateCheckRuns } from './check-runs.js';
 export { detectMonorepoLayout, detectWorkspace, buildServiceMap, detectCycles, topologicalOrder, getTransitiveDependents, analyzeImpact, formatImpactSummary, getAffectedBuildOrder, } from './multi-repo/index.js';
 export type { ServiceNode, ServiceMap, ServiceEdge, MonorepoLayout, WorkspaceConfig, WorkspacePackage, ImpactResult, } from './multi-repo/index.js';
@@ -69,5 +94,14 @@ export type { ArchiveManifest, ArchivalOptions } from './audit-archival.js';
 export { Orchestrator, type OrchestratorConfig, type WebhookConfig } from './orchestrator.js';
 export type { OrchestratorPlugin, PluginContext, BeforeRunEvent, AfterRunEvent, RunErrorEvent, } from './plugin.js';
 export { CostGovernancePlugin } from './cost-governance.js';
+export { WorktreePoolManager, WorktreePoolError, WorktreeOwnershipError, deterministicPort, allocatePort, allocateContiguousPorts, isPortFree, PortAllocationError, slugifyBranch, worktreePath, verifyOwnership, assertOwnership, isExistingWorktree, readParallelismMode, isParallelismEnabled, PARALLELISM_FLAG, DEFAULT_BASE_PORT, DEFAULT_POOL_ROOT, DEFAULT_STALE_THRESHOLD_DAYS, type WorktreePoolSpec, type WorktreePoolManagerDeps, type WorktreeHandle, type AllocateOptions, type AllocatePortOptions, type AllocateContiguousOptions, type OwnershipResult, type ParallelismMode, } from './runtime/index.js';
+export { HarnessRegistry, UnknownHarnessError, ClaudeCodeAdapter, CodexAdapter, createDefaultHarnessRegistry, probeVersion, matchesRange, enforceIndependence, validateIndependenceGraph, CyclicIndependenceConstraintError, type HarnessAdapter, type HarnessAvailability, type HarnessCapabilities, type HarnessEvent, type HarnessInput, type HarnessName, type HarnessRequires, type HarnessResult, type HarnessResultStatus, type ClaudeCodeAdapterDeps, type CodexAdapterDeps, type IndependenceResult, type UpstreamRun, type ToolDefinition, } from './harness/index.js';
+export { SubscriptionLedger, validateTenantShares, evaluateSchedule, CalibrationStore, COLD_START_DEFAULT, buildBurnDownReport, analyzeTier, PLAN_COSTS_USD, isOffPeakAt, nextOffPeakStart, ageInDays, freshnessLevel, DEFAULT_TENANT, COLD_START_DEFAULT_INPUT, COLD_START_DEFAULT_OUTPUT, ESTIMATE_VARIANCE_THRESHOLD, ROLLING_WINDOW_SIZE, type SubscriptionPlan, type Schedule, type TokenEstimate, type LedgerKey, type WindowState, type AdmissionDecision, type BurnDownReport, type LedgerEvent, type BillingMode, type QuotaSource, type OffPeakSchedule, type BurnDownInput, type CalibrationStoreDeps, type LedgerDeps, type ScheduleDecision, type ScheduleEvaluationContext, type Confidence, type ContentionEvent, type TierAnalysisInput, type TierAnalysisResult, type FreshnessLevel, } from './scheduling/index.js';
+export { DatabaseAdapterRegistry, UnknownDatabaseAdapterError, SqliteCopyAdapter, NeonAdapter, PgSnapshotRestoreAdapter, ExternalAdapter, createDefaultDatabaseAdapterRegistry, buildInjectionOverrides, parsePostgresUrl, maskConnectionString, enforceTopologyGuard, buildMigrationDivergedEvent, DatabaseBranchAdapterError, BranchTopologyForbiddenError, type DatabaseBranchAdapter, type DatabaseBranchCapabilities, type DatabaseBranchHandle, type DatabaseAdapterName, type ResolvedDatabaseBranchPool, type DatabaseAccess, type SqliteCopyAdapterDeps, type NeonAdapterDeps, type PgSnapshotRestoreAdapterDeps, type ExternalAdapterDeps, type InjectedEnvOverrides, type KnownInFlightBranches, type MigrationDivergedEvent, } from './database/index.js';
+export { StateWriter, appendEvent, readEvents, atomicWriteJson, listActiveStates, HEARTBEAT_INTERVAL_MS, HEARTBEAT_STALE_MS, type RuntimeState, type ArtifactEvent, type StageStatus, } from './artifacts/index.js';
+export { runWorkerPool, withMergeGate, forceReleaseMergeGate, isBranchUpToDate, MergeGateLockTimeoutError, decideRequeue, appendTriageHistory, type WorkItem, type WorkerPoolDeps, type WorkerPoolEvent, type WorkerPoolResult, type FailureEvent, type RequeueTrigger, type RequeueDecision, type RequeueDecisionInput, type TriageHistoryEntry, type FailureClassification, type MergeGateDeps, } from './dispatch/index.js';
+export { ModelRegistry, ModelRemovedError, UnknownAliasError, DEFAULT_REGISTRY, decideFromRawOutput, decideFromInvocationFailure, validateClassifierOutput, defaultRulesetDecision, appendCalibrationEntry, ALL_REVIEWERS, type ModelEntry, type ResolutionContext, type ResolutionResult, type ResolutionEvent, type ReviewerName, type ClassifierOutput, type ClassifierDecision, type FellOpenReason, type CalibrationLogEntry, type DiffSummary, } from './models/index.js';
+export { PipelineCycleDetector, createStageMarker, parseStageInvocations, DEFAULT_CYCLE_LIMITS, type PipelineStage, type CycleConfig, type CycleDetectionResult, } from './pipeline-cycle-detector.js';
+export { checkAndHandleCycle, createCycleDetectorFromConfig, type CycleHandlerOptions, type CycleCheckResult, } from './cycle-utils.js';
 export type { ApiVersion, Metadata, Condition, SecretRef, MetricCondition, Duration, Resource, TriggerFilter, Trigger, Provider, RoutingStrategy, ComplexityThreshold, Routing, Stage, PipelineSpec, PipelinePhase, PipelineStatus, Pipeline, AgentConstraints, HandoffContractRef, Handoff, SkillExample, Skill, AgentCard, AgentRoleSpec, AgentRoleStatus, AgentRole, GateScope, MetricRule, ToolRule, ReviewerRule, DocumentationRule, ProvenanceRule, ExpressionRule, GateRule, EnforcementLevel, Override, RetryPolicy, Evaluation, Gate, QualityGateSpec, QualityGateStatus, QualityGate, Permissions, ApprovalRequirement, Guardrails, MonitoringLevel, AutonomyLevel, PromotionCriteria, DemotionTrigger, AgentAutonomyStatus, AutonomyPolicySpec, AutonomyPolicyStatus, AutonomyPolicy, AdapterInterface, HealthCheck, AdapterBindingSpec, AdapterBindingStatus, AdapterBinding, AnyResource, ResourceKind, ValidationError, GateVerdict, DemotionResult, ComplexityFactor, AuthorizationContext, AuthorizationResult, AuthIdentity, AuthenticationResult, Authenticator, MutatingGateContext, ExpressionEvaluator, ExpressionVerdict, LLMEvaluationDimension, LLMEvaluationResult, LLMGateVerdict, AgentExecutionState, HandoffValidationError, SchemaResolver, SchemaValidationError, MemoryTier, MemoryEntry, WorkingMemory, ShortTermMemory, LongTermMemory, SharedMemory, EpisodicMemory, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,11 +1,12 @@
 // ── Core orchestration ───────────────────────────────────────────────
-export { loadConfig, loadConfigAsync } from './config.js';
+export { loadConfig, loadConfigAsync, } from './config.js';
 export { validateIssue, validateIssueWithExtensions, parseComplexity } from './validate-issue.js';
 export { executePipeline, } from './execute.js';
 export { validateAgentOutput, } from './validate-agent-output.js';
 export { createLogger } from './logger.js';
 export { validateConfigFiles } from './validate-config.js';
 export { executeFixCI, countRetryAttempts, fetchCILogs } from './fix-ci.js';
+export { executeFixReview, countRetryAttempts as countReviewRetryAttempts, fetchReviewFindings, } from './fix-review.js';
 export { executeTriage } from './triage.js';
 // Shared utilities
 export { getGitHubConfig, resolveRepoRoot, createDefaultAuditLog, resolveAutonomyLevel, resolveConstraints, mergeBlockedPaths, isAutonomousStrategy, recordMetric, validateAndAuditOutput, createPipelineMemory, evaluatePipelineCompliance, authorizeFilesChanged, extractIssueNumber, extractIssueId, issueIdToNumber, formatIssueRef, BRANCH_PATTERN, createAbacPermissionHook, createBlockedPathsHook, createAuditLoggingHook, createPipelineAuthorizationChain, } from './shared.js';
@@ -29,6 +30,31 @@ export { createStructuredConsoleLogger, createStructuredBufferLogger, } from './
 export { startWatch } from './watch.js';
 // Priority scoring (PPA)
 export { computePriority, rankWorkItems, } from './priority.js';
+// Action enforcement
+export { checkAction, enforceAction, DEFAULT_BLOCKED_ACTIONS, } from './action-enforcement.js';
+// Issue admission scoring
+export { scoreIssueForAdmission, mapIssueToPriorityInput, } from './admission-score.js';
+export { enrichAdmissionInput, computeDesignSystemReadiness, computeReadinessFromDesignSystemContext, computeDefectRiskFactor, computeAutonomyFactor, computeDesignAuthorityWeight, complexityToAutonomyLevel, } from './admission-enrichment.js';
+export { computeAdmissionComposite } from './admission-composite.js';
+export { parseBacklogTask, loadBacklogTaskFromRoot, mapBacklogTaskToAdmissionInput, loadSoulTracks, loadMaintainers, } from './backlog-adapter.js';
+export { computePillarBreakdown, detectTensions, pillarSignalScore, } from './pillar-breakdown.js';
+// RFC-0008 Addendum B — SA scoring (Layer 1/2/3 + composite)
+export { compileDid, validatePhase2bReadiness, hashDidSpec, canonicalJson, tokenize, serializeForStore, deserializeFromStore, } from './sa-scoring/did-compiler.js';
+export { HttpDepparseClient, FakeDepparseClient, DepparseError, } from './sa-scoring/depparse-client.js';
+export { runLayer1, checkScopeGate, detectConstraintViolations, detectAntiPatterns, checkMeasurableSignals, renderPreVerifiedSummary, } from './sa-scoring/layer1-deterministic.js';
+export { computeDomainRelevance, computePrincipleCoverage, } from './sa-scoring/layer2-structural.js';
+export { runLayer3, buildSa1Prompt, buildSa2Prompt, extractJson, RecordedLLMClient, LayerLlmError, CONFIDENCE_THRESHOLD, } from './sa-scoring/layer3-llm.js';
+export { computeSoulAlignment, computeSa1, computeSa2, getPhaseWeights, W_STRUCTURAL_FLOOR, } from './sa-scoring/composite.js';
+export { computeSa2Computable } from './sa-scoring/c1-sa2-computable.js';
+export { SAFeedbackStore, SA_FEEDBACK_LABELS, classifyLabel, recordOverrideFeedback, } from './sa-scoring/feedback-store.js';
+export { computeCalibrationCoefficient, buildCategoryCoefficients, } from './calibration.js';
+export { autoCalibratePhaseWeights, computePhase3Weights, decideCalibrationDirection, renderCalibrationDiff, WEIGHT_FLOOR, WEIGHT_CEILING, DEFAULT_SHIFT_SIZE, DEFAULT_WINDOW_DAYS, PRECISION_DELTA_THRESHOLD, } from './sa-scoring/auto-calibrate.js';
+export { detectSoulDrift, computeWindowStats, computeTrend, describeDriftSource, DEFAULT_MEAN_THRESHOLD, DEFAULT_STDDEV_THRESHOLD, DEFAULT_CONSECUTIVE_WINDOWS, DEFAULT_RECOVERY_MS, } from './sa-scoring/drift-monitor.js';
+export { handleCoreIdentityChanged, } from './sa-scoring/rescore-orchestrator.js';
+export { scoreSoulAlignment, resolveSoulAlignmentOverride, } from './sa-scoring/index.js';
+// PR review orchestration
+export { executeReview } from './review.js';
+export { metaReview, ReviewFeedbackStore, } from './review-meta.js';
 // Agent orchestration
 export { createPipelineOrchestration, executePipelineOrchestration, validatePipelineHandoffs, sequential, parallel, hybrid, hierarchical, swarm, validateHandoff, simpleSchemaValidate, } from './orchestration.js';
 // Policy evaluators
@@ -44,11 +70,13 @@ export { checkFrameworkCompliance, getControlCatalog, getFrameworkMappings, list
 // Extended telemetry
 export { createSilentLogger, withPipelineSpanSync, getPipelineTracer, validateResourceSchema, } from './telemetry-extended.js';
 // Runners
-export { ClaudeCodeRunner, ClaudeCodeRunner as GitHubActionsRunner, GenericLLMRunner, CopilotRunner, CursorRunner, CodexRunner, RunnerRegistry, createRunnerRegistry, SecurityTriageRunner, } from './runners/index.js';
+export { ClaudeCodeRunner, ClaudeCodeRunner as GitHubActionsRunner, GenericLLMRunner, CopilotRunner, CursorRunner, CodexRunner, RunnerRegistry, createRunnerRegistry, SecurityTriageRunner, ReviewAgentRunner, REVIEW_PROMPTS, } from './runners/index.js';
 // Notifications
 export { SlackMessenger, TeamsMessenger, NotificationRouter } from './notifications/index.js';
 // State store
 export { StateStore } from './state/index.js';
+// Workflow pattern detection
+export { readToolSequenceJSONL, readSessionMetaFiles, sessionMetaToEvents, categorizeAction, DEFAULT_DETECTION_OPTIONS, } from './workflow-patterns/index.js';
 // Deployment targets
 export { createKubernetesTarget, createVercelTarget, createFlyioTarget, createHttpMetricsCollector, createStubMetricsCollector, RolloutController, } from './deploy/index.js';
 // Progressive gates
@@ -68,7 +96,7 @@ export { createOTelBridge, isOTelAvailable } from './otel-exporter.js';
 // Dashboard renderer
 export { renderDashboardFrame } from './cli/dashboard-renderer.js';
 // Codebase analysis
-export { walkFiles, detectModules, parseImports, buildModuleGraph, detectConventions, detectPatterns, analyzeHotspots, computeComplexityScore, analyzeCodebase, buildCodebaseContext, formatContextForPrompt, } from './analysis/index.js';
+export { walkFiles, detectModules, parseImports, buildModuleGraph, detectConventions, detectReactProject, loadProjectAliases, parseTsConfigAliases, parseViteOrWebpackAliases, enumerateTestLocations, detectPatterns, analyzeHotspots, computeComplexityScore, analyzeCodebase, buildCodebaseContext, formatContextForPrompt, analyzeDiff, extractChangedFiles, } from './analysis/index.js';
 // Check runs
 export { createCheckRun, updateCheckRun, reportGateCheckRuns } from './check-runs.js';
 // Multi-repo orchestration
@@ -88,4 +116,21 @@ export { archiveEntries, loadArchivedEntries, verifyArchiveContinuity } from './
 export { Orchestrator } from './orchestrator.js';
 // Cost governance plugin
 export { CostGovernancePlugin } from './cost-governance.js';
+// RFC-0010 runtime primitives
+export { WorktreePoolManager, WorktreePoolError, WorktreeOwnershipError, deterministicPort, allocatePort, allocateContiguousPorts, isPortFree, PortAllocationError, slugifyBranch, worktreePath, verifyOwnership, assertOwnership, isExistingWorktree, readParallelismMode, isParallelismEnabled, PARALLELISM_FLAG, DEFAULT_BASE_PORT, DEFAULT_POOL_ROOT, DEFAULT_STALE_THRESHOLD_DAYS, } from './runtime/index.js';
+// RFC-0010 harness adapters
+export { HarnessRegistry, UnknownHarnessError, ClaudeCodeAdapter, CodexAdapter, createDefaultHarnessRegistry, probeVersion, matchesRange, enforceIndependence, validateIndependenceGraph, CyclicIndependenceConstraintError, } from './harness/index.js';
+// RFC-0010 subscription scheduling
+export { SubscriptionLedger, validateTenantShares, evaluateSchedule, CalibrationStore, COLD_START_DEFAULT, buildBurnDownReport, analyzeTier, PLAN_COSTS_USD, isOffPeakAt, nextOffPeakStart, ageInDays, freshnessLevel, DEFAULT_TENANT, COLD_START_DEFAULT_INPUT, COLD_START_DEFAULT_OUTPUT, ESTIMATE_VARIANCE_THRESHOLD, ROLLING_WINDOW_SIZE, } from './scheduling/index.js';
+// RFC-0010 database branching (DatabaseBranchAdapter framework + 4 adapters)
+export { DatabaseAdapterRegistry, UnknownDatabaseAdapterError, SqliteCopyAdapter, NeonAdapter, PgSnapshotRestoreAdapter, ExternalAdapter, createDefaultDatabaseAdapterRegistry, buildInjectionOverrides, parsePostgresUrl, maskConnectionString, enforceTopologyGuard, buildMigrationDivergedEvent, DatabaseBranchAdapterError, BranchTopologyForbiddenError, } from './database/index.js';
+// RFC-0010 artifacts (heartbeat + event stream + atomic JSON + state listing)
+export { StateWriter, appendEvent, readEvents, atomicWriteJson, listActiveStates, HEARTBEAT_INTERVAL_MS, HEARTBEAT_STALE_MS, } from './artifacts/index.js';
+// RFC-0010 dispatch (worker pool + merge gate + requeue)
+export { runWorkerPool, withMergeGate, forceReleaseMergeGate, isBranchUpToDate, MergeGateLockTimeoutError, decideRequeue, appendTriageHistory, } from './dispatch/index.js';
+// RFC-0010 model registry + classifier
+export { ModelRegistry, ModelRemovedError, UnknownAliasError, DEFAULT_REGISTRY, decideFromRawOutput, decideFromInvocationFailure, validateClassifierOutput, defaultRulesetDecision, appendCalibrationEntry, ALL_REVIEWERS, } from './models/index.js';
+// Pipeline cycle detection
+export { PipelineCycleDetector, createStageMarker, parseStageInvocations, DEFAULT_CYCLE_LIMITS, } from './pipeline-cycle-detector.js';
+export { checkAndHandleCycle, createCycleDetectorFromConfig, } from './cycle-utils.js';
 //# sourceMappingURL=index.js.map

package/dist/models/classifier.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Conditional review classifier (RFC-0010 §12). The classifier reads a PR diff and emits a
+ * structured decision listing which downstream review agents to invoke. This module provides:
+ *
+ *   - The output-schema validator (Q4 resolution: confident: bool + confidence: float with
+ *     consistency rule confident: true REQUIRES confidence ≥ 0.7).
+ *   - The default fall-open ruleset (RFC §12.3 baseline + the four fall-open triggers).
+ *   - The calibration-log writer for $ARTIFACTS_DIR/_classifier/calibration.jsonl.
+ */
+export type ReviewerName = 'testing' | 'critic' | 'security';
+export declare const ALL_REVIEWERS: readonly ReviewerName[];
+export interface ClassifierOutput {
+    reviewers: ReviewerName[];
+    rationale: Record<string, string>;
+    confident: boolean;
+    confidence: number;
+    modelOverride?: Partial<Record<ReviewerName, 'haiku' | 'sonnet' | 'opus' | 'opus[1m]'>>;
+    harnessOverride?: Partial<Record<ReviewerName, string>>;
+}
+export type FellOpenReason = 'parse-error' | 'schema-validation' | 'confident-false' | 'invocation-failed';
+export interface ClassifierDecision {
+    reviewers: readonly ReviewerName[];
+    fellOpen: boolean;
+    fellOpenReason: FellOpenReason | null;
+    rawOutput: ClassifierOutput | null;
+    parseError: string | null;
+}
+/**
+ * Parse and validate raw JSON output from a classifier-LLM invocation. Returns a structured
+ * decision; on any validation failure the decision falls open to the full reviewer set per
+ * RFC §12.3 (failing open is a non-negotiable safety property).
+ */
+export declare function decideFromRawOutput(rawJson: string): ClassifierDecision;
+/** Decision used when the classifier invocation itself fails (timeout, harness exhausted). */
+export declare function decideFromInvocationFailure(): ClassifierDecision;
+type ValidationResult = {
+    ok: true;
+    value: ClassifierOutput;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function validateClassifierOutput(value: unknown): ValidationResult;
+export interface DiffSummary {
+    filesChanged: number;
+    paths: string[];
+    linesAdded: number;
+    linesRemoved: number;
+}
+/**
+ * Apply the default classifier ruleset from RFC §12.3 to a diff summary. Used as the
+ * fallback when no LLM classifier is configured, and as the seed prompt for LLM-based
+ * classifiers. Always returns confident: true with confidence: 1.0 because these are
+ * deterministic rules.
+ */
+export declare function defaultRulesetDecision(diff: DiffSummary): ClassifierOutput;
+export interface CalibrationLogEntry {
+    timestamp: string;
+    issueId: string;
+    diffStats: DiffSummary;
+    classifierOutput: ClassifierOutput | null;
+    fellOpen: boolean;
+    fellOpenReason: FellOpenReason | null;
+    /** Back-filled later via cli-classifier-feedback when the operator attributes a miss. */
+    humanOverrideAfterMerge: {
+        addedReviewer: ReviewerName;
+        reason: string;
+    } | null;
+}
+/**
+ * Append one entry to $ARTIFACTS_DIR/_classifier/calibration.jsonl. Atomic per-line via
+ * appendFile. Creates the directory if missing.
+ */
+export declare function appendCalibrationEntry(artifactsDir: string, entry: CalibrationLogEntry): Promise<void>;
+export {};
+//# sourceMappingURL=classifier.d.ts.map

package/dist/models/classifier.js

@@ -0,0 +1,221 @@
+/**
+ * Conditional review classifier (RFC-0010 §12). The classifier reads a PR diff and emits a
+ * structured decision listing which downstream review agents to invoke. This module provides:
+ *
+ *   - The output-schema validator (Q4 resolution: confident: bool + confidence: float with
+ *     consistency rule confident: true REQUIRES confidence ≥ 0.7).
+ *   - The default fall-open ruleset (RFC §12.3 baseline + the four fall-open triggers).
+ *   - The calibration-log writer for $ARTIFACTS_DIR/_classifier/calibration.jsonl.
+ */
+import { appendFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export const ALL_REVIEWERS = ['testing', 'critic', 'security'];
+const VALID_MODEL_OVERRIDES = new Set(['haiku', 'sonnet', 'opus', 'opus[1m]']);
+const VALID_HARNESS_OVERRIDES = new Set([
+    'claude-code',
+    'codex',
+    'gemini-cli',
+    'opencode',
+    'aider',
+    'generic-api',
+]);
+const CONFIDENCE_FLOOR_FOR_TRUE = 0.7;
+/**
+ * Parse and validate raw JSON output from a classifier-LLM invocation. Returns a structured
+ * decision; on any validation failure the decision falls open to the full reviewer set per
+ * RFC §12.3 (failing open is a non-negotiable safety property).
+ */
+export function decideFromRawOutput(rawJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch (err) {
+        return failOpen('parse-error', null, err.message);
+    }
+    const validation = validateClassifierOutput(parsed);
+    if (!validation.ok) {
+        return failOpen('schema-validation', null, validation.error);
+    }
+    if (!validation.value.confident) {
+        return failOpen('confident-false', validation.value, null);
+    }
+    return {
+        reviewers: validation.value.reviewers,
+        fellOpen: false,
+        fellOpenReason: null,
+        rawOutput: validation.value,
+        parseError: null,
+    };
+}
+/** Decision used when the classifier invocation itself fails (timeout, harness exhausted). */
+export function decideFromInvocationFailure() {
+    return failOpen('invocation-failed', null, null);
+}
+function failOpen(reason, rawOutput, parseError) {
+    return {
+        reviewers: ALL_REVIEWERS,
+        fellOpen: true,
+        fellOpenReason: reason,
+        rawOutput,
+        parseError,
+    };
+}
+export function validateClassifierOutput(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { ok: false, error: 'output is not an object' };
+    }
+    const obj = value;
+    // reviewers: array of ReviewerName, unique
+    if (!Array.isArray(obj.reviewers)) {
+        return { ok: false, error: 'reviewers must be an array' };
+    }
+    const seen = new Set();
+    for (const r of obj.reviewers) {
+        if (typeof r !== 'string' || !ALL_REVIEWERS.includes(r)) {
+            return { ok: false, error: `reviewers contains invalid value: ${String(r)}` };
+        }
+        if (seen.has(r))
+            return { ok: false, error: `reviewers contains duplicate: ${r}` };
+        seen.add(r);
+    }
+    // rationale: object with string values
+    if (typeof obj.rationale !== 'object' || obj.rationale === null || Array.isArray(obj.rationale)) {
+        return { ok: false, error: 'rationale must be an object' };
+    }
+    for (const [k, v] of Object.entries(obj.rationale)) {
+        if (typeof v !== 'string') {
+            return { ok: false, error: `rationale.${k} must be a string` };
+        }
+    }
+    // confident: bool
+    if (typeof obj.confident !== 'boolean') {
+        return { ok: false, error: 'confident must be a boolean' };
+    }
+    // confidence: number in [0, 1]
+    if (typeof obj.confidence !== 'number' ||
+        !Number.isFinite(obj.confidence) ||
+        obj.confidence < 0 ||
+        obj.confidence > 1) {
+        return { ok: false, error: 'confidence must be a number in [0, 1]' };
+    }
+    // Consistency: confident: true REQUIRES confidence >= 0.7
+    if (obj.confident && obj.confidence < CONFIDENCE_FLOOR_FOR_TRUE) {
+        return {
+            ok: false,
+            error: `confident: true requires confidence >= ${CONFIDENCE_FLOOR_FOR_TRUE} (got ${obj.confidence})`,
+        };
+    }
+    // Optional modelOverride: { reviewerName?: alias }
+    if (obj.modelOverride !== undefined) {
+        if (typeof obj.modelOverride !== 'object' ||
+            obj.modelOverride === null ||
+            Array.isArray(obj.modelOverride)) {
+            return { ok: false, error: 'modelOverride must be an object' };
+        }
+        for (const [k, v] of Object.entries(obj.modelOverride)) {
+            if (!ALL_REVIEWERS.includes(k)) {
+                return { ok: false, error: `modelOverride contains unknown reviewer: ${k}` };
+            }
+            if (typeof v !== 'string' || !VALID_MODEL_OVERRIDES.has(v)) {
+                return {
+                    ok: false,
+                    error: `modelOverride.${k} must be one of ${[...VALID_MODEL_OVERRIDES].join('|')}`,
+                };
+            }
+        }
+    }
+    // Optional harnessOverride: { reviewerName?: harnessName }
+    if (obj.harnessOverride !== undefined) {
+        if (typeof obj.harnessOverride !== 'object' ||
+            obj.harnessOverride === null ||
+            Array.isArray(obj.harnessOverride)) {
+            return { ok: false, error: 'harnessOverride must be an object' };
+        }
+        for (const [k, v] of Object.entries(obj.harnessOverride)) {
+            if (!ALL_REVIEWERS.includes(k)) {
+                return { ok: false, error: `harnessOverride contains unknown reviewer: ${k}` };
+            }
+            if (typeof v !== 'string' || !VALID_HARNESS_OVERRIDES.has(v)) {
+                return {
+                    ok: false,
+                    error: `harnessOverride.${k} must be one of ${[...VALID_HARNESS_OVERRIDES].join('|')}`,
+                };
+            }
+        }
+    }
+    return { ok: true, value: obj };
+}
+/**
+ * Apply the default classifier ruleset from RFC §12.3 to a diff summary. Used as the
+ * fallback when no LLM classifier is configured, and as the seed prompt for LLM-based
+ * classifiers. Always returns confident: true with confidence: 1.0 because these are
+ * deterministic rules.
+ */
+export function defaultRulesetDecision(diff) {
+    if (diff.filesChanged === 0) {
+        return {
+            reviewers: [],
+            rationale: { all: 'no files changed; no review needed' },
+            confident: true,
+            confidence: 1,
+        };
+    }
+    const allDocs = diff.paths.every((p) => /\.(md|rst|txt)$/i.test(p) || p.startsWith('docs/'));
+    if (allDocs) {
+        return {
+            reviewers: ['critic'],
+            rationale: { critic: 'documentation-only change; critic suffices' },
+            confident: true,
+            confidence: 0.95,
+        };
+    }
+    const touchesAuth = diff.paths.some((p) => /(?:^|\/)(auth|crypto|secrets?)\b/i.test(p));
+    const touchesLockfiles = diff.paths.some((p) => /(?:^|\/)(package(-lock)?\.json|requirements\.txt|pnpm-lock\.yaml|yarn\.lock|Cargo\.lock|poetry\.lock|Pipfile\.lock)$/i.test(p));
+    const touchesCi = diff.paths.some((p) => p.startsWith('.github/workflows/'));
+    if (touchesAuth) {
+        return {
+            reviewers: ['testing', 'critic', 'security'],
+            rationale: {
+                testing: 'auth touched; verify regression coverage',
+                critic: 'auth touched; verify approach',
+                security: 'auth-touching diff; mandatory security review',
+            },
+            modelOverride: { security: 'opus' },
+            confident: true,
+            confidence: 0.99,
+        };
+    }
+    if (touchesLockfiles || touchesCi) {
+        return {
+            reviewers: ['security', 'critic'],
+            rationale: {
+                security: touchesLockfiles ? 'supply-chain (lockfile) change' : 'CI workflow change',
+                critic: 'verify approach',
+            },
+            confident: true,
+            confidence: 0.9,
+        };
+    }
+    // Default: all three
+    return {
+        reviewers: ['testing', 'critic', 'security'],
+        rationale: {
+            testing: 'default fallback',
+            critic: 'default fallback',
+            security: 'default fallback',
+        },
+        confident: true,
+        confidence: 0.8,
+    };
+}
+/**
+ * Append one entry to $ARTIFACTS_DIR/_classifier/calibration.jsonl. Atomic per-line via
+ * appendFile. Creates the directory if missing.
+ */
+export async function appendCalibrationEntry(artifactsDir, entry) {
+    const path = `${artifactsDir}/_classifier/calibration.jsonl`;
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(entry) + '\n', 'utf8');
+}
+//# sourceMappingURL=classifier.js.map

package/dist/models/index.d.ts

@@ -0,0 +1,3 @@
+export { ModelRegistry, ModelRemovedError, UnknownAliasError, DEFAULT_REGISTRY, type ModelEntry, type ResolutionContext, type ResolutionResult, type ResolutionEvent, } from './registry.js';
+export { decideFromRawOutput, decideFromInvocationFailure, validateClassifierOutput, defaultRulesetDecision, appendCalibrationEntry, ALL_REVIEWERS, type ReviewerName, type ClassifierOutput, type ClassifierDecision, type FellOpenReason, type CalibrationLogEntry, type DiffSummary, } from './classifier.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/models/index.js

@@ -0,0 +1,3 @@
+export { ModelRegistry, ModelRemovedError, UnknownAliasError, DEFAULT_REGISTRY, } from './registry.js';
+export { decideFromRawOutput, decideFromInvocationFailure, validateClassifierOutput, defaultRulesetDecision, appendCalibrationEntry, ALL_REVIEWERS, } from './classifier.js';
+//# sourceMappingURL=index.js.map

package/dist/models/registry.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Model alias registry per RFC-0010 §11. Maps short aliases (haiku, sonnet, opus, opus[1m])
+ * to physical model IDs and tracks deprecation lifecycle (deprecatedAt / removedAt /
+ * replacementAlias). Resolution is performed once at pipeline-load and pinned per run
+ * (RFC §11.1) so model swaps cannot occur underneath an in-flight pipeline.
+ */
+export interface ModelEntry {
+    /** Short alias used in pipeline YAML (e.g., 'haiku'). */
+    alias: string;
+    /** Physical model ID dispatched to the harness (e.g., 'claude-haiku-4-5-20251001'). */
+    modelId: string;
+    /** ISO 8601 date when the vendor announced deprecation; null if active. */
+    deprecatedAt: string | null;
+    /** ISO 8601 date when the vendor will (or did) remove the model; null if not scheduled. */
+    removedAt: string | null;
+    /** Alias to migrate to when this entry is deprecated; required when deprecatedAt is set. */
+    replacementAlias: string | null;
+    /** Documentation hint, surfaced by cli-model-bump. */
+    use?: string;
+}
+export interface ResolutionContext {
+    /** Source of `now` for deprecation comparisons; defaults to system clock. */
+    now?: () => Date;
+}
+export type ResolutionEvent = {
+    type: 'ok';
+    alias: string;
+    modelId: string;
+} | {
+    type: 'ModelDeprecated';
+    alias: string;
+    modelId: string;
+    removedAt: string | null;
+    replacementAlias: string | null;
+} | {
+    type: 'ModelDeprecationGracePeriod';
+    alias: string;
+    removedAt: string;
+};
+export interface ResolutionResult {
+    modelId: string;
+    events: ResolutionEvent[];
+}
+export declare class ModelRemovedError extends Error {
+    readonly alias: string;
+    readonly modelId: string;
+    readonly removedAt: string;
+    constructor(alias: string, modelId: string, removedAt: string);
+}
+export declare class UnknownAliasError extends Error {
+    readonly alias: string;
+    constructor(alias: string);
+}
+/**
+ * Default registry shipped with the orchestrator. Maintainers update deprecatedAt /
+ * removedAt / replacementAlias from public vendor announcements (see operator-runbook).
+ */
+export declare const DEFAULT_REGISTRY: readonly ModelEntry[];
+export declare class ModelRegistry {
+    private readonly entries;
+    constructor(entries?: readonly ModelEntry[]);
+    list(): ModelEntry[];
+    get(alias: string): ModelEntry | undefined;
+    /**
+     * Resolve an alias to a physical model ID at pipeline-load. Throws ModelRemovedError
+     * if the model has been removed; emits ModelDeprecated event otherwise (informational).
+     * Within `GRACE_PERIOD_DAYS` of the removal date, additionally emits
+     * ModelDeprecationGracePeriod for escalated operator notification.
+     */
+    resolve(alias: string, ctx?: ResolutionContext): ResolutionResult;
+    /**
+     * Bulk-resolve a set of stage aliases. Emits one ResolutionResult per (stage, alias).
+     * Used at pipeline-load to pin model resolution for the whole pipeline run.
+     */
+    resolveAll(stageAliases: ReadonlyArray<{
+        stage: string;
+        alias: string;
+    }>, ctx?: ResolutionContext): Map<string, ResolutionResult>;
+    /**
+     * Operator-facing dry-run helper: for each currently deprecated alias, report what
+     * would happen if a pipeline started today. Used by cli-model-bump --dry-run.
+     */
+    bumpPlan(stageAliases: ReadonlyArray<{
+        stage: string;
+        alias: string;
+    }>, ctx?: ResolutionContext): Array<{
+        stage: string;
+        alias: string;
+        currentModelId: string;
+        deprecatedAt: string | null;
+        removedAt: string | null;
+        replacementAlias: string | null;
+        replacementModelId: string | null;
+        inGracePeriod: boolean;
+    }>;
+}
+//# sourceMappingURL=registry.d.ts.map