@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/harness/version-probe.js

@@ -0,0 +1,123 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const PROBE_TIMEOUT_MS = 5000;
+/**
+ * Run a harness's version probe and compare against its declared semver range.
+ * Per RFC §13.8: parse failures fall through to "available" (warning only) so undocumented
+ * vendor changes to --version output don't break every pipeline.
+ */
+export async function probeVersion(requires) {
+    let stdout;
+    try {
+        const result = await execFileAsync(requires.binary, requires.versionProbe.args, {
+            timeout: PROBE_TIMEOUT_MS,
+        });
+        stdout = result.stdout;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            return {
+                available: false,
+                reason: 'binary-missing',
+                detail: `${requires.binary} not found on PATH`,
+            };
+        }
+        return {
+            available: false,
+            reason: 'probe-failed',
+            detail: `${requires.binary} ${requires.versionProbe.args.join(' ')} failed: ${err.message}`,
+        };
+    }
+    let installedVersion;
+    try {
+        installedVersion = requires.versionProbe.parse(stdout).trim();
+    }
+    catch (err) {
+        return {
+            available: true,
+            reason: 'probe-failed',
+            detail: `could not parse ${requires.binary} version output: ${err.message}`,
+        };
+    }
+    if (!installedVersion) {
+        return {
+            available: true,
+            reason: 'probe-failed',
+            detail: `parser returned empty version from ${requires.binary} output`,
+        };
+    }
+    if (!matchesRange(installedVersion, requires.versionRange)) {
+        return {
+            available: false,
+            reason: 'version-out-of-range',
+            detail: `${requires.binary} ${installedVersion} installed, adapter requires ${requires.versionRange}`,
+            installedVersion,
+        };
+    }
+    return { available: true, installedVersion };
+}
+/**
+ * Minimal semver-range matcher supporting `>=X.Y.Z` and `>=X.Y.Z <A.B.C`.
+ * v1 ships only the cases the RFC's default policy uses (open-ended upper bound by
+ * default; explicit upper bound only when a known-incompatible upstream version exists).
+ */
+export function matchesRange(version, range) {
+    const v = parseSemver(version);
+    if (!v)
+        return false;
+    const constraints = range
+        .split(/\s+/)
+        .map((c) => c.trim())
+        .filter((c) => c.length > 0);
+    for (const constraint of constraints) {
+        const m = constraint.match(/^(>=|>|<=|<|=)(\d+)\.(\d+)\.(\d+)$/);
+        if (!m)
+            return false;
+        const op = m[1];
+        const target = [
+            Number.parseInt(m[2], 10),
+            Number.parseInt(m[3], 10),
+            Number.parseInt(m[4], 10),
+        ];
+        const cmp = compareSemver(v, target);
+        switch (op) {
+            case '>=':
+                if (cmp < 0)
+                    return false;
+                break;
+            case '>':
+                if (cmp <= 0)
+                    return false;
+                break;
+            case '<=':
+                if (cmp > 0)
+                    return false;
+                break;
+            case '<':
+                if (cmp >= 0)
+                    return false;
+                break;
+            case '=':
+                if (cmp !== 0)
+                    return false;
+                break;
+        }
+    }
+    return true;
+}
+function parseSemver(s) {
+    const m = s.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return null;
+    return [Number.parseInt(m[1], 10), Number.parseInt(m[2], 10), Number.parseInt(m[3], 10)];
+}
+function compareSemver(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return 0;
+}
+//# sourceMappingURL=version-probe.js.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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';
@@ -20,8 +20,27 @@ export { createStructuredConsoleLogger, createStructuredBufferLogger, } from './
 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, } from './admission-score.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';
@@ -55,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';
@@ -75,6 +94,13 @@ 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';

package/dist/index.js

@@ -1,5 +1,5 @@
 // ── 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';
@@ -34,8 +34,27 @@ export { computePriority, rankWorkItems, } from './priority.js';
 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
@@ -77,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
@@ -97,6 +116,20 @@ 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';

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