@ai-sdlc/orchestrator 0.9.0 → 0.13.0

package/dist/variant/drift-extension.js

@@ -0,0 +1,164 @@
+/**
+ * RFC-0017 Phase 3 — Eτ_tessellation_drift extension for variant-scoped scans.
+ *
+ * Composes with RFC-0009 Phase 4.2 / AISDLC-317 (`orchestrator/src/tessellation-drift.ts`)
+ * to extend drift detection with variant-scoped design intent scans per RFC-0017 §6.2:
+ *
+ *   "when a variant is added/removed/modified, the Eτ_tessellation_drift detector
+ *   MUST scan substrate code for variant-specific identifiers (parallel to per-soul
+ *   scan). Substrate code referring to specific variant IDs is a drift signal."
+ *
+ * Emits `Decision: variant-design-intent-drift` events catalog-routed per
+ * RFC-0035 Stage A/B/C (non-blocking per G0 contract).
+ *
+ * **Composition model:**
+ * This extension runs AFTER the base `detectTessellationDrift` (soul-scope detector).
+ * It adds a variant-scoped Rule #1a: scan substrate files for variant-slug leakage,
+ * parallel to how the base detector scans for soul-slug leakage. The rationale is
+ * identical: variant IDs in shared substrate code are a drift signal — they indicate
+ * variant-specific logic has leaked into non-variant-scoped files, which complicates
+ * future variant removal and creates implicit coupling.
+ *
+ * @see spec/rfcs/RFC-0017-in-soul-variant-pattern.md §6.2 Behavioral changes
+ * @see orchestrator/src/tessellation-drift.ts — base RFC-0009 Phase 4.2 detector
+ * @see spec/rfcs/RFC-0035-decision-catalog-operator-routing.md G0
+ */
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function isValidSlug(slug) {
+    return /^[a-z0-9-]+$/.test(slug) && slug.length >= 1 && slug.length <= 64;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Scan a single substrate file for variant-slug leakage.
+ *
+ * Detection strategy: textual regex scan (parallel to the base detector's
+ * Rule #1 soul-slug scan). Two patterns:
+ *
+ *   1. `'<variant-slug>'` or `"<variant-slug>"` — bare string literal.
+ *   2. `if (variant === '<variant-slug>')` etc. — variant-discriminating branch.
+ */
+function scanSubstrateFileForVariants(file, soulSlug, variantSlugs) {
+    const findings = [];
+    if (file.contents.length === 0 || variantSlugs.length === 0)
+        return findings;
+    const lines = file.contents.split('\n');
+    for (const variantSlug of variantSlugs) {
+        if (!isValidSlug(variantSlug))
+            continue;
+        const esc = escapeRegex(variantSlug);
+        // Pattern 1: bare string literal (single or double quote, exact match)
+        const literalRe = new RegExp(`(['"])${esc}\\1`);
+        // Pattern 2: variant-discriminating conditional
+        // Permissive on identifier name: variant, variantId, variant_id, etc.
+        const condRe = new RegExp(`(?:variant[A-Za-z_]*)\\s*===\\s*(['"])${esc}\\1`);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const condMatch = line.match(condRe);
+            if (condMatch) {
+                findings.push({
+                    filePath: file.path,
+                    soulSlug,
+                    variantSlug,
+                    line: i + 1,
+                    pattern: 'variant-conditional',
+                    excerpt: line.trim().slice(0, 200),
+                });
+                continue; // don't double-report as a bare literal
+            }
+            if (literalRe.test(line)) {
+                findings.push({
+                    filePath: file.path,
+                    soulSlug,
+                    variantSlug,
+                    line: i + 1,
+                    pattern: 'string-literal',
+                    excerpt: line.trim().slice(0, 200),
+                });
+            }
+        }
+    }
+    return findings;
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Detect variant-scoped design intent drift in shared substrate files.
+ *
+ * Composes with `detectTessellationDrift` (RFC-0009 Phase 4.2) by adding a
+ * variant-scope parallel to its Rule #1 (soul-slug scan). Substrate code that
+ * mentions specific variant slugs is a drift signal — variant-specific logic
+ * should be isolated behind variant-aware routing, not hardcoded in shared code.
+ *
+ * Emits `Decision: variant-design-intent-drift` (catalog-routed, G0 non-blocking).
+ *
+ * When `config.enabled !== true` the detector short-circuits immediately and
+ * returns `{ events: [], optedOut: true }` — honoring the RFC-0009 §10
+ * "adopter opt-in initially" convention.
+ *
+ * @param input  Detection inputs.
+ * @param config Detector configuration.
+ * @param emit   Optional callback called once per emitted event. Errors propagate.
+ */
+export async function detectVariantDrift(input, config = {}, emit) {
+    // Master opt-out
+    if (config.enabled !== true) {
+        return { events: [], optedOut: true };
+    }
+    const catalogStage = config.catalogStage ?? 'A';
+    const now = new Date().toISOString();
+    const allFindings = [];
+    // Scan each soul's variants against the substrate files
+    if (input.substrateFiles && input.substrateFiles.length > 0) {
+        for (const [soulSlug, variants] of Object.entries(input.variantsBySoul)) {
+            if (!isValidSlug(soulSlug))
+                continue;
+            const variantSlugs = variants.map((v) => v.id).filter(isValidSlug);
+            if (variantSlugs.length === 0)
+                continue;
+            for (const file of input.substrateFiles) {
+                const findings = scanSubstrateFileForVariants(file, soulSlug, variantSlugs);
+                allFindings.push(...findings);
+            }
+        }
+    }
+    const events = [];
+    if (allFindings.length > 0) {
+        // Aggregate involved souls and variants
+        const involvedSoulsSet = new Set(allFindings.map((f) => f.soulSlug));
+        const involvedVariants = {};
+        for (const finding of allFindings) {
+            if (!involvedVariants[finding.soulSlug]) {
+                involvedVariants[finding.soulSlug] = [];
+            }
+            if (!involvedVariants[finding.soulSlug].includes(finding.variantSlug)) {
+                involvedVariants[finding.soulSlug].push(finding.variantSlug);
+            }
+        }
+        // Sort for determinism
+        for (const soul of Object.keys(involvedVariants)) {
+            involvedVariants[soul].sort();
+        }
+        const totalVariants = Object.values(involvedVariants).flat().length;
+        const ev = {
+            type: 'VariantDesignIntentDriftDetected',
+            timestamp: now,
+            tessellatedDid: input.tessellatedDid,
+            involvedSouls: [...involvedSoulsSet].sort(),
+            involvedVariants,
+            severity: 'warning',
+            message: `Variant design intent drift: ${allFindings.length} variant-slug leakage hit(s) ` +
+                `across ${totalVariants} variant(s) in ${involvedSoulsSet.size} soul(s) detected ` +
+                `in shared substrate. Decision: variant-design-intent-drift (RFC-0035 Stage ${catalogStage}, non-blocking).`,
+            decisionKind: 'variant-design-intent-drift',
+            routing: { blocking: false, catalogStage },
+            details: { findings: allFindings },
+        };
+        events.push(ev);
+        if (emit) {
+            await emit(ev);
+        }
+    }
+    return { events, optedOut: false };
+}
+//# sourceMappingURL=drift-extension.js.map

package/dist/variant/engineering-review.d.ts

@@ -0,0 +1,185 @@
+/**
+ * RFC-0017 Phase 3 — OQ-7 Engineering review routing.
+ *
+ * Per OQ-7 resolution (2026-05-18):
+ *
+ *   "Design owns + Engineering review routed through Decision Catalog.
+ *    Engineering's review becomes a tracked `Decision: variant-substrate-cost-review`
+ *    in the catalog. Substrate-cost block → `Decision: variant-substrate-cost-block`
+ *    → Design/Engineering routing per RFC-0029 actor model."
+ *
+ * This module implements:
+ *
+ *   1. **Variant declaration trigger** — when a new variant is declared, emit
+ *      `Decision: variant-substrate-cost-review` (catalog-routed, Engineering
+ *      Authority reviewer, non-blocking per G0).
+ *
+ *   2. **Substrate-cost block** — when Engineering flags a substrate cost concern,
+ *      emit `Decision: variant-substrate-cost-block` → routes to Design+Engineering
+ *      via RFC-0029 actor model (operator resolves multi-pillar decision).
+ *
+ *   3. **Reviewer-subagent gate (AISDLC-298)** — given a set of PR-staged variant
+ *      declarations and the Decision Catalog state, flag as `critical` any variant
+ *      declaration that lacks a corresponding Engineering review Decision record.
+ *      Composes with the AISDLC-298 code-reviewer / test-reviewer gate.
+ *
+ * All Decisions route through RFC-0035 G0 (non-blocking pipeline contract).
+ *
+ * @see spec/rfcs/RFC-0017-in-soul-variant-pattern.md OQ-7
+ * @see spec/rfcs/RFC-0035-decision-catalog-operator-routing.md G0 + §6.2
+ * @see spec/rfcs/RFC-0029-product-pillar-architectural-vision.md actor model
+ */
+/**
+ * Decision summary keys for Engineering review routing (OQ-7 resolution).
+ */
+export type EngineeringReviewDecisionKind = 'variant-substrate-cost-review' | 'variant-substrate-cost-block';
+/**
+ * Minimal representation of a variant declaration triggering Engineering review.
+ * Callers populate from the Soul DID's `spec.variants[]` entries being added
+ * or modified in a PR diff.
+ */
+export interface VariantDeclarationForReview {
+    /** Soul identifier (kebab-case). */
+    soulId: string;
+    /** Variant identifier (kebab-case). */
+    variantId: string;
+    /**
+     * Design overrides declared on this variant. Used by Engineering to assess
+     * substrate cost (e.g., new layout engine needed for a novel `densityProfile`).
+     */
+    designOverrides?: {
+        colorPaletteOverlay?: string;
+        densityProfile?: string;
+        typographyScale?: string;
+        motionProfile?: string;
+        radiusProfile?: string;
+        [vendorPrefixedKey: string]: string | undefined;
+    };
+    /** Optional substrate cost assessment from Engineering (when provided). */
+    substrateCostAssessment?: {
+        /** True when Engineering flags a substrate cost concern. */
+        blocked: boolean;
+        /** Engineering's rationale for the block (required when blocked: true). */
+        rationale?: string;
+        /** Estimated additional substrate cost (free-form — e.g., "2 new layout engine variants"). */
+        estimatedCost?: string;
+    };
+}
+/**
+ * RFC-0035 Decision Catalog routing metadata for Engineering review events.
+ * Always non-blocking per G0.
+ */
+export interface EngineeringReviewRouting {
+    /** Always false — G0 non-blocking contract. */
+    blocking: false;
+    /** RFC-0029 pillar assignment for this Decision. */
+    assignedPillar: 'engineering' | 'design-engineering-operator';
+    /** RFC-0035 actor routing rubric outcome. */
+    actorRationale: string;
+}
+/**
+ * Engineering review Decision event for a single variant declaration.
+ */
+export interface VariantSubstrateCostReviewEvent {
+    kind: 'variant-substrate-cost-review';
+    soulId: string;
+    variantId: string;
+    /** RFC-3339 UTC timestamp. */
+    timestamp: string;
+    routing: EngineeringReviewRouting;
+    message: string;
+    designOverrides?: VariantDeclarationForReview['designOverrides'];
+}
+/**
+ * Substrate-cost block Decision event — routes to Design+Engineering operator.
+ */
+export interface VariantSubstrateCostBlockEvent {
+    kind: 'variant-substrate-cost-block';
+    soulId: string;
+    variantId: string;
+    timestamp: string;
+    routing: EngineeringReviewRouting;
+    /** Engineering's blocking rationale. */
+    rationale: string;
+    estimatedCost?: string;
+    message: string;
+}
+export type EngineeringReviewEvent = VariantSubstrateCostReviewEvent | VariantSubstrateCostBlockEvent;
+/**
+ * Reviewer-subagent gate flag per AISDLC-298.
+ *
+ * When a PR contains variant declarations that lack a corresponding
+ * `variant-substrate-cost-review` Decision record in the catalog,
+ * the reviewer-subagent gate flags them as `critical`.
+ */
+export interface MissingEngineeringReviewFlag {
+    severity: 'critical';
+    soulId: string;
+    variantId: string;
+    message: string;
+}
+/**
+ * Input for the reviewer-subagent gate check (AC #7).
+ */
+export interface ReviewerGateCheckInput {
+    /** Variant declarations staged in the PR being reviewed. */
+    stagedVariants: Array<{
+        soulId: string;
+        variantId: string;
+    }>;
+    /**
+     * Decision Catalog summaries present for this workspace.
+     * Each entry is a (soulId, variantId) pair for which a
+     * `variant-substrate-cost-review` Decision exists.
+     *
+     * Callers populate this from the Decision Catalog event log
+     * projected state — specifically the set of `variant-substrate-cost-review`
+     * events whose lifecycle is `open` or `answered`.
+     */
+    existingReviewDecisions: Array<{
+        soulId: string;
+        variantId: string;
+    }>;
+}
+/**
+ * Result of the reviewer-subagent gate check.
+ */
+export interface ReviewerGateCheckResult {
+    /** Flags for variant declarations missing Engineering review Decisions. */
+    flags: MissingEngineeringReviewFlag[];
+    /** True when at least one critical flag was emitted (reviewer blocks). */
+    hasCriticalFlags: boolean;
+}
+/**
+ * Emit Engineering review Decisions for a set of new/modified variant declarations.
+ *
+ * For each declaration:
+ *   - Always emits `variant-substrate-cost-review` (non-blocking catalog log).
+ *   - If `substrateCostAssessment.blocked === true`, additionally emits
+ *     `variant-substrate-cost-block` (multi-pillar Design+Engineering routing).
+ *
+ * Per RFC-0035 G0: all emitted events have `blocking: false`. The pipeline
+ * continues regardless of Engineering's assessment — operator resolves via catalog.
+ *
+ * @param declarations - Variant declarations to trigger review for.
+ * @param now          - Injectable wall-clock for tests.
+ * @param emitDecision - Optional callback for each emitted event. Errors propagate.
+ */
+export declare function triggerEngineeringReview(declarations: VariantDeclarationForReview[], now?: Date, emitDecision?: (event: EngineeringReviewEvent) => void): EngineeringReviewEvent[];
+/**
+ * Check whether PR-staged variant declarations have corresponding Engineering
+ * review Decisions in the catalog (AISDLC-298 reviewer-subagent gate, AC #7).
+ *
+ * Returns a `critical` flag for every staged variant that lacks a
+ * `variant-substrate-cost-review` Decision record.
+ *
+ * **Composition with AISDLC-298:**
+ * The `code-reviewer` and `test-reviewer` subagents invoke this check for every
+ * PR diff containing variant declarations. A `hasCriticalFlags: true` result
+ * BLOCKS the reviewer from approving — variant declarations without Engineering
+ * review are treated as equivalent to "scope-creep candidate" per AISDLC-308.
+ *
+ * @param input - Staged variants + existing review Decisions from the catalog.
+ */
+export declare function checkReviewerGate(input: ReviewerGateCheckInput): ReviewerGateCheckResult;
+//# sourceMappingURL=engineering-review.d.ts.map

package/dist/variant/engineering-review.js

@@ -0,0 +1,142 @@
+/**
+ * RFC-0017 Phase 3 — OQ-7 Engineering review routing.
+ *
+ * Per OQ-7 resolution (2026-05-18):
+ *
+ *   "Design owns + Engineering review routed through Decision Catalog.
+ *    Engineering's review becomes a tracked `Decision: variant-substrate-cost-review`
+ *    in the catalog. Substrate-cost block → `Decision: variant-substrate-cost-block`
+ *    → Design/Engineering routing per RFC-0029 actor model."
+ *
+ * This module implements:
+ *
+ *   1. **Variant declaration trigger** — when a new variant is declared, emit
+ *      `Decision: variant-substrate-cost-review` (catalog-routed, Engineering
+ *      Authority reviewer, non-blocking per G0).
+ *
+ *   2. **Substrate-cost block** — when Engineering flags a substrate cost concern,
+ *      emit `Decision: variant-substrate-cost-block` → routes to Design+Engineering
+ *      via RFC-0029 actor model (operator resolves multi-pillar decision).
+ *
+ *   3. **Reviewer-subagent gate (AISDLC-298)** — given a set of PR-staged variant
+ *      declarations and the Decision Catalog state, flag as `critical` any variant
+ *      declaration that lacks a corresponding Engineering review Decision record.
+ *      Composes with the AISDLC-298 code-reviewer / test-reviewer gate.
+ *
+ * All Decisions route through RFC-0035 G0 (non-blocking pipeline contract).
+ *
+ * @see spec/rfcs/RFC-0017-in-soul-variant-pattern.md OQ-7
+ * @see spec/rfcs/RFC-0035-decision-catalog-operator-routing.md G0 + §6.2
+ * @see spec/rfcs/RFC-0029-product-pillar-architectural-vision.md actor model
+ */
+// ── Event factories ───────────────────────────────────────────────────────────
+function makeCostReviewEvent(declaration, now) {
+    return {
+        kind: 'variant-substrate-cost-review',
+        soulId: declaration.soulId,
+        variantId: declaration.variantId,
+        timestamp: now,
+        routing: {
+            blocking: false,
+            assignedPillar: 'engineering',
+            actorRationale: 'OQ-7 resolution: Design owns variant declaration; Engineering reviews substrate cost ' +
+                'via Decision Catalog (single-pillar Engineering decision — RFC-0029 Principle 1 + ' +
+                'RFC-0035 §6.2 single-pillar → pillar owner routing).',
+        },
+        message: `Variant '${declaration.variantId}' on soul '${declaration.soulId}' declared. ` +
+            `Decision: variant-substrate-cost-review → Engineering Authority review via catalog ` +
+            `(RFC-0017 OQ-7; RFC-0035 G0 non-blocking).`,
+        designOverrides: declaration.designOverrides,
+    };
+}
+function makeCostBlockEvent(declaration, assessment, now) {
+    return {
+        kind: 'variant-substrate-cost-block',
+        soulId: declaration.soulId,
+        variantId: declaration.variantId,
+        timestamp: now,
+        routing: {
+            blocking: false,
+            assignedPillar: 'design-engineering-operator',
+            actorRationale: 'OQ-7 resolution: Substrate-cost block → multi-pillar decision (Design + Engineering). ' +
+                'RFC-0029 actor model: cross-pillar decisions route to operator. ' +
+                'RFC-0035 §6.2: multi-pillar → operator with escalation note.',
+        },
+        rationale: assessment.rationale ?? 'Engineering flagged substrate cost concern.',
+        estimatedCost: assessment.estimatedCost,
+        message: `Engineering substrate-cost block on variant '${declaration.variantId}' (soul '${declaration.soulId}'). ` +
+            `Decision: variant-substrate-cost-block → Design+Engineering routing per RFC-0029 actor model ` +
+            `(RFC-0035 G0 — pipeline continues; operator resolves multi-pillar decision).`,
+    };
+}
+// ── Main trigger function ─────────────────────────────────────────────────────
+/**
+ * Emit Engineering review Decisions for a set of new/modified variant declarations.
+ *
+ * For each declaration:
+ *   - Always emits `variant-substrate-cost-review` (non-blocking catalog log).
+ *   - If `substrateCostAssessment.blocked === true`, additionally emits
+ *     `variant-substrate-cost-block` (multi-pillar Design+Engineering routing).
+ *
+ * Per RFC-0035 G0: all emitted events have `blocking: false`. The pipeline
+ * continues regardless of Engineering's assessment — operator resolves via catalog.
+ *
+ * @param declarations - Variant declarations to trigger review for.
+ * @param now          - Injectable wall-clock for tests.
+ * @param emitDecision - Optional callback for each emitted event. Errors propagate.
+ */
+export function triggerEngineeringReview(declarations, now = new Date(), emitDecision) {
+    const nowStr = now.toISOString();
+    const events = [];
+    for (const declaration of declarations) {
+        // Always emit cost-review Decision (OQ-7 primary routing)
+        const reviewEvent = makeCostReviewEvent(declaration, nowStr);
+        events.push(reviewEvent);
+        if (emitDecision)
+            emitDecision(reviewEvent);
+        // Conditionally emit substrate-cost-block (OQ-7 block path)
+        const assessment = declaration.substrateCostAssessment;
+        if (assessment?.blocked === true) {
+            const blockEvent = makeCostBlockEvent(declaration, assessment, nowStr);
+            events.push(blockEvent);
+            if (emitDecision)
+                emitDecision(blockEvent);
+        }
+    }
+    return events;
+}
+// ── Reviewer-subagent gate (AISDLC-298 composition) ─────────────────────────
+/**
+ * Check whether PR-staged variant declarations have corresponding Engineering
+ * review Decisions in the catalog (AISDLC-298 reviewer-subagent gate, AC #7).
+ *
+ * Returns a `critical` flag for every staged variant that lacks a
+ * `variant-substrate-cost-review` Decision record.
+ *
+ * **Composition with AISDLC-298:**
+ * The `code-reviewer` and `test-reviewer` subagents invoke this check for every
+ * PR diff containing variant declarations. A `hasCriticalFlags: true` result
+ * BLOCKS the reviewer from approving — variant declarations without Engineering
+ * review are treated as equivalent to "scope-creep candidate" per AISDLC-308.
+ *
+ * @param input - Staged variants + existing review Decisions from the catalog.
+ */
+export function checkReviewerGate(input) {
+    const flags = [];
+    for (const staged of input.stagedVariants) {
+        const hasReview = input.existingReviewDecisions.some((d) => d.soulId === staged.soulId && d.variantId === staged.variantId);
+        if (!hasReview) {
+            flags.push({
+                severity: 'critical',
+                soulId: staged.soulId,
+                variantId: staged.variantId,
+                message: `Variant '${staged.variantId}' on soul '${staged.soulId}' was declared in this PR ` +
+                    `without a corresponding 'variant-substrate-cost-review' Decision in the catalog. ` +
+                    `Per RFC-0017 OQ-7 + AISDLC-298: Engineering review via Decision Catalog is required ` +
+                    `for all variant declarations. File the Decision before merging.`,
+            });
+        }
+    }
+    return { flags, hasCriticalFlags: flags.length > 0 };
+}
+//# sourceMappingURL=engineering-review.js.map

package/dist/variant/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * RFC-0017 In-Soul Variant Pattern — module barrel.
+ *
+ * Re-exports the public surfaces for all five phases:
+ *
+ *   Phase 1 (AISDLC-435):
+ *   - Variant inheritance validator + event types
+ *
+ *   Phase 3 (AISDLC-436):
+ *   - Deprecation lifecycle engine (OQ-3)
+ *   - Eτ_tessellation_drift variant-scoped extension (AC #4)
+ *   - Engineering review routing (OQ-7, AC #5, #6, #7)
+ *
+ *   Phase 4 (AISDLC-437):
+ *   - InternalAdopter three-product reference impl
+ *
+ *   Phase 5 (AISDLC-438):
+ *   - OQ-8 cardinality activation Decision wiring
+ */
+export { INHERITED_LOCKED_FIELDS, DEFAULT_SOFT_WARN_AT, DEFAULT_HARD_LIMIT, validateVariantDeclarations, hasBlockingViolations, } from './inheritance-validator.js';
+export type { InheritedLockedField, VariantEventKind, VariantInheritanceViolation, VariantCountSoftWarning, VariantCountHardLimitExceeded, NestedVariantRejected, VariantEvent, VariantDeclarationInput, VariantLimitsConfig, ValidateVariantDeclarationsOptions, } from './inheritance-validator.js';
+export { DEFAULT_DEPRECATION_WINDOW_DAYS, DEFAULT_APPROACHING_WINDOW_DAYS, resolveDeprecationState, evaluateDeprecationLifecycle, } from './deprecation-lifecycle.js';
+export type { VariantDeprecationState, VariantDeprecationDecisionKind, VariantLifecycleConfig, DeprecatedVariantDeclaration, VariantDeprecationEvent, VariantMigrationTask, VariantDeprecationResult, } from './deprecation-lifecycle.js';
+export { detectVariantDrift } from './drift-extension.js';
+export type { VariantDriftFinding, VariantDesignIntentDriftEvent, VariantDriftExtensionConfig, VariantDriftExtensionInput, VariantDriftExtensionResult, } from './drift-extension.js';
+export { triggerEngineeringReview, checkReviewerGate } from './engineering-review.js';
+export type { EngineeringReviewDecisionKind, VariantDeclarationForReview, EngineeringReviewRouting, VariantSubstrateCostReviewEvent, VariantSubstrateCostBlockEvent, EngineeringReviewEvent, MissingEngineeringReviewFlag, ReviewerGateCheckInput, ReviewerGateCheckResult, } from './engineering-review.js';
+export { trackCardinalityActivationRequest, shouldPromoteToOperatorReview, DEFAULT_CARDINALITY_ACTIVATION_THRESHOLD, } from './cardinality-activation.js';
+export type { CardinalityActivationRequest, CardinalityActivationResult, } from './cardinality-activation.js';
+export { INTERNAL_ADOPTER_SUBSTRATE, INTERNAL_ADOPTER_PRODUCTS, productA, productB, productC, buildVariantsBySoul, buildVariantScores, computeSoulAggregateBaseline, } from './internal-adopter/index.js';
+export type { InternalAdopterSubstrate, InternalAdopterProduct } from './internal-adopter/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/variant/index.js

@@ -0,0 +1,32 @@
+/**
+ * RFC-0017 In-Soul Variant Pattern — module barrel.
+ *
+ * Re-exports the public surfaces for all five phases:
+ *
+ *   Phase 1 (AISDLC-435):
+ *   - Variant inheritance validator + event types
+ *
+ *   Phase 3 (AISDLC-436):
+ *   - Deprecation lifecycle engine (OQ-3)
+ *   - Eτ_tessellation_drift variant-scoped extension (AC #4)
+ *   - Engineering review routing (OQ-7, AC #5, #6, #7)
+ *
+ *   Phase 4 (AISDLC-437):
+ *   - InternalAdopter three-product reference impl
+ *
+ *   Phase 5 (AISDLC-438):
+ *   - OQ-8 cardinality activation Decision wiring
+ */
+// Phase 1 — Inheritance validator
+export { INHERITED_LOCKED_FIELDS, DEFAULT_SOFT_WARN_AT, DEFAULT_HARD_LIMIT, validateVariantDeclarations, hasBlockingViolations, } from './inheritance-validator.js';
+// Phase 3 — Deprecation lifecycle (OQ-3)
+export { DEFAULT_DEPRECATION_WINDOW_DAYS, DEFAULT_APPROACHING_WINDOW_DAYS, resolveDeprecationState, evaluateDeprecationLifecycle, } from './deprecation-lifecycle.js';
+// Phase 3 — Eτ_tessellation_drift variant-scoped extension (AC #4)
+export { detectVariantDrift } from './drift-extension.js';
+// Phase 3 — Engineering review routing (OQ-7, AC #5-#7)
+export { triggerEngineeringReview, checkReviewerGate } from './engineering-review.js';
+// Phase 5 — OQ-8 cardinality activation Decision wiring (AISDLC-438)
+export { trackCardinalityActivationRequest, shouldPromoteToOperatorReview, DEFAULT_CARDINALITY_ACTIVATION_THRESHOLD, } from './cardinality-activation.js';
+// Phase 4 — InternalAdopter three-product reference impl (AISDLC-437)
+export { INTERNAL_ADOPTER_SUBSTRATE, INTERNAL_ADOPTER_PRODUCTS, productA, productB, productC, buildVariantsBySoul, buildVariantScores, computeSoulAggregateBaseline, } from './internal-adopter/index.js';
+//# sourceMappingURL=index.js.map