@ai-sdlc/orchestrator 0.9.0 → 0.13.0

package/dist/tessellation-admission.d.ts

@@ -0,0 +1,162 @@
+/**
+ * RFC-0009 Phase 2.1 — Tessellation routing for admission composite.
+ *
+ * Implements the soul-scope routing algorithm from RFC-0009 §6:
+ *
+ *   resolveAffectedSouls(w) = set of Soul DIDs the work item affects,
+ *     computed from the dependency graph snapshot (RFC-0014).
+ *
+ *   If tessellation absent on the resolved DID:
+ *     Behavior unchanged from RFC-0008. Single-DID semantics preserved.
+ *
+ *   Else if |resolveAffectedSouls(w)| == 0:
+ *     // Pure substrate work touching no soul-importing module
+ *     Sα(w) = min over ALL souls { Sα(w, soul) }    (§6 degenerate case)
+ *
+ *   Else if |resolveAffectedSouls(w)| == 1:
+ *     Sα(w) = Sα(w, targetSoul)                     // soul's own DSB
+ *
+ *   Else:
+ *     Sα(w) = crossSoulScoringRule(w, affectedSouls) // default `min`
+ *
+ * The same resolution applies to Eρ₄ (Design System Readiness) per §6:
+ *   "The same soul-resolution applies to Eρ₄ which reads against the
+ *    targeted soul's DSB rather than the platform-aggregate DSB."
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §6 + §10
+ */
+import type { Tessellation } from '@ai-sdlc/reference';
+/**
+ * A minimal representation of one dep-graph snapshot record's soul scope.
+ *
+ * Derived from the RFC-0014 snapshot (SnapshotRecord) via the pipeline-cli
+ * reader layer. Callers populate this from `snapshot.*.jsonl` records before
+ * calling `resolveAffectedSouls`.
+ *
+ * When `targetedSoulIds` is absent or empty, the work item is treated as
+ * substrate-only — affecting the full `min`-over-all-souls degenerate case.
+ */
+export interface DepGraphSoulEntry {
+    /**
+     * Canonical task ID (case-insensitive match used internally). E.g. "AISDLC-313".
+     */
+    id: string;
+    /**
+     * Soul slugs (soulId values from the Tessellation manifest) that this
+     * work item explicitly targets. Empty or absent = substrate-only change.
+     *
+     * Populated by the pipeline-cli layer reading the dep-graph snapshot; the
+     * soulId values must match `tessellation.souls[].soulId` for the lookup to
+     * produce useful results.
+     */
+    targetedSoulIds?: string[];
+}
+/**
+ * Per-soul scoring data used by the tessellated admission composite.
+ * One entry per active soul in the tessellation.
+ */
+export interface SoulScores {
+    /**
+     * Soul-specific soul-alignment score in [0, 1].
+     * Scored against this soul's DSB and product vertex (§6 + §5.1.1).
+     */
+    soulAlignment: number;
+    /**
+     * Soul-specific Eρ₄ Design System Readiness in [0, 1].
+     * Reads from the soul's own DSB at `.ai-sdlc/souls/<slug>/design-system-binding.yaml`
+     * rather than the platform-aggregate DSB (§6 last para).
+     */
+    er4: number;
+}
+/**
+ * All tessellation-related inputs needed by the admission composite
+ * for RFC-0009 Phase 2.1 soul-scope routing.
+ *
+ * Callers build this once per pipeline tick and pass it to
+ * `computeAdmissionComposite` via `AdmissionCompositeOptions.tessellationContext`.
+ */
+export interface TessellationContext {
+    /**
+     * The Tessellated DID's `tessellation` field (from `DesignIntentDocumentSpec`).
+     * Carries the soul manifest + `crossSoulScoringRule` + `substrateInvariants`.
+     */
+    tessellation: Tessellation;
+    /**
+     * Pre-computed per-soul scores, keyed by `soulId` (matching
+     * `tessellation.souls[].soulId`). Must cover at least every active soul.
+     *
+     * In a full Phase 2 implementation these are computed by reading each
+     * soul's DSB at `.ai-sdlc/souls/<slug>/design-system-binding.yaml` and
+     * scoring Sα against the soul's product vertex.
+     */
+    soulScores: Record<string, SoulScores>;
+    /**
+     * Dep-graph soul scope entries — one per work item in the active backlog.
+     * Read from the latest RFC-0014 snapshot via `pipeline-cli`'s snapshot
+     * reader before calling the admission composite.
+     *
+     * When `undefined` or empty, every work item is treated as substrate-only.
+     */
+    depGraphEntries?: DepGraphSoulEntry[];
+}
+/**
+ * Resolve the set of soul IDs affected by a work item.
+ *
+ * Algorithm (RFC-0009 §6 + OQ-2 sub-decision):
+ * 1. Find the work item's dep-graph entry by case-insensitive ID match.
+ * 2. Filter its `targetedSoulIds` against souls present in the tessellation.
+ * 3. Return the validated intersection.
+ * 4. If no entry is found, or `targetedSoulIds` is empty/absent → return `[]`
+ *    (substrate-only; triggers the `min`-over-all-souls degenerate case in §6).
+ *
+ * @param workItemId  - The work item's canonical ID (e.g. "AISDLC-313").
+ * @param depGraphEntries - Soul scope entries from the RFC-0014 snapshot.
+ * @param tessellation - The tessellation manifest to validate soul IDs against.
+ * @returns Array of valid affected soul IDs (empty = substrate-only).
+ */
+export declare function resolveAffectedSouls(workItemId: string, depGraphEntries: DepGraphSoulEntry[] | undefined, tessellation: Tessellation): string[];
+/**
+ * Apply `crossSoulScoringRule` over a per-soul score map.
+ *
+ * Currently implements `min` (default per OQ-2 resolution) and `max`/`mean`
+ * escape valves. `weighted-traffic` and `weighted-revenue` require an external
+ * data source and are documented as advanced — they fall through to `min` when
+ * no weights are available (safe degenerate).
+ *
+ * @param soulIds   - The soul IDs to aggregate over.
+ * @param scores    - Per-soul score map (keyed by soulId).
+ * @param rule      - The aggregation rule from the Tessellated DID.
+ * @param fallback  - Default score when no soul scores are available (0.5).
+ */
+export declare function applyCrossSoulRule(soulIds: string[], scores: Record<string, number>, rule: Tessellation['crossSoulScoringRule'], fallback?: number): number;
+/**
+ * Result of tessellation-based soul-alignment resolution.
+ * Exposes routing path for auditability.
+ */
+export interface TessellatedSaResult {
+    /** The resolved Sα value in [0, 1]. */
+    soulAlignment: number;
+    /** The resolved Eρ₄ value in [0, 1]. */
+    er4: number;
+    /**
+     * Routing path taken (matches RFC-0009 §6 case labels).
+     *
+     * - `'non-tessellated'`   — tessellation absent; single-DID path preserved.
+     * - `'substrate-only'`    — 0 affected souls; `min`-over-ALL-souls degenerate.
+     * - `'single-soul'`       — 1 affected soul; scored against that soul's DSB.
+     * - `'multi-soul'`        — N>1 affected souls; crossSoulScoringRule applied.
+     */
+    routingPath: 'non-tessellated' | 'substrate-only' | 'single-soul' | 'multi-soul';
+    /** Soul IDs used in the aggregation (empty for `non-tessellated`). */
+    affectedSoulIds: string[];
+}
+/**
+ * Compute tessellated Sα + Eρ₄ for a work item, implementing RFC-0009 §6.
+ *
+ * @param workItemId         - The canonical work item ID.
+ * @param fallbackSa         - SA score to use when tessellation is absent (single-DID path).
+ * @param fallbackEr4        - Eρ₄ score to use when tessellation is absent.
+ * @param tessellationCtx    - Tessellation context, or undefined for non-tessellated DID.
+ */
+export declare function computeTessellatedScores(workItemId: string, fallbackSa: number, fallbackEr4: number, tessellationCtx: TessellationContext | undefined): TessellatedSaResult;
+//# sourceMappingURL=tessellation-admission.d.ts.map

package/dist/tessellation-admission.js

@@ -0,0 +1,146 @@
+/**
+ * RFC-0009 Phase 2.1 — Tessellation routing for admission composite.
+ *
+ * Implements the soul-scope routing algorithm from RFC-0009 §6:
+ *
+ *   resolveAffectedSouls(w) = set of Soul DIDs the work item affects,
+ *     computed from the dependency graph snapshot (RFC-0014).
+ *
+ *   If tessellation absent on the resolved DID:
+ *     Behavior unchanged from RFC-0008. Single-DID semantics preserved.
+ *
+ *   Else if |resolveAffectedSouls(w)| == 0:
+ *     // Pure substrate work touching no soul-importing module
+ *     Sα(w) = min over ALL souls { Sα(w, soul) }    (§6 degenerate case)
+ *
+ *   Else if |resolveAffectedSouls(w)| == 1:
+ *     Sα(w) = Sα(w, targetSoul)                     // soul's own DSB
+ *
+ *   Else:
+ *     Sα(w) = crossSoulScoringRule(w, affectedSouls) // default `min`
+ *
+ * The same resolution applies to Eρ₄ (Design System Readiness) per §6:
+ *   "The same soul-resolution applies to Eρ₄ which reads against the
+ *    targeted soul's DSB rather than the platform-aggregate DSB."
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §6 + §10
+ */
+// ── Core functions ─────────────────────────────────────────────────────
+/**
+ * Resolve the set of soul IDs affected by a work item.
+ *
+ * Algorithm (RFC-0009 §6 + OQ-2 sub-decision):
+ * 1. Find the work item's dep-graph entry by case-insensitive ID match.
+ * 2. Filter its `targetedSoulIds` against souls present in the tessellation.
+ * 3. Return the validated intersection.
+ * 4. If no entry is found, or `targetedSoulIds` is empty/absent → return `[]`
+ *    (substrate-only; triggers the `min`-over-all-souls degenerate case in §6).
+ *
+ * @param workItemId  - The work item's canonical ID (e.g. "AISDLC-313").
+ * @param depGraphEntries - Soul scope entries from the RFC-0014 snapshot.
+ * @param tessellation - The tessellation manifest to validate soul IDs against.
+ * @returns Array of valid affected soul IDs (empty = substrate-only).
+ */
+export function resolveAffectedSouls(workItemId, depGraphEntries, tessellation) {
+    if (!depGraphEntries || depGraphEntries.length === 0)
+        return [];
+    const normalizedId = workItemId.toLowerCase();
+    const entry = depGraphEntries.find((e) => e.id.toLowerCase() === normalizedId);
+    if (!entry || !entry.targetedSoulIds || entry.targetedSoulIds.length === 0)
+        return [];
+    // Validate each declared soul ID against the tessellation manifest.
+    const validSoulIds = new Set(tessellation.souls.map((s) => s.soulId));
+    return entry.targetedSoulIds.filter((id) => validSoulIds.has(id));
+}
+/**
+ * Apply `crossSoulScoringRule` over a per-soul score map.
+ *
+ * Currently implements `min` (default per OQ-2 resolution) and `max`/`mean`
+ * escape valves. `weighted-traffic` and `weighted-revenue` require an external
+ * data source and are documented as advanced — they fall through to `min` when
+ * no weights are available (safe degenerate).
+ *
+ * @param soulIds   - The soul IDs to aggregate over.
+ * @param scores    - Per-soul score map (keyed by soulId).
+ * @param rule      - The aggregation rule from the Tessellated DID.
+ * @param fallback  - Default score when no soul scores are available (0.5).
+ */
+export function applyCrossSoulRule(soulIds, scores, rule, fallback = 0.5) {
+    const values = soulIds.map((id) => scores[id]).filter((v) => v !== undefined);
+    if (values.length === 0)
+        return fallback;
+    switch (rule ?? 'min') {
+        case 'min':
+            return Math.min(...values);
+        case 'max':
+            return Math.max(...values);
+        case 'mean':
+            return values.reduce((sum, v) => sum + v, 0) / values.length;
+        case 'weighted-traffic':
+        case 'weighted-revenue':
+            // Advanced variants require an external data source (per RFC-0009 §5.2 note).
+            // Degenerate to `min` when no weight data available — safe, conservative.
+            return Math.min(...values);
+    }
+}
+/**
+ * Compute tessellated Sα + Eρ₄ for a work item, implementing RFC-0009 §6.
+ *
+ * @param workItemId         - The canonical work item ID.
+ * @param fallbackSa         - SA score to use when tessellation is absent (single-DID path).
+ * @param fallbackEr4        - Eρ₄ score to use when tessellation is absent.
+ * @param tessellationCtx    - Tessellation context, or undefined for non-tessellated DID.
+ */
+export function computeTessellatedScores(workItemId, fallbackSa, fallbackEr4, tessellationCtx) {
+    // ── Non-tessellated path (RFC-0008 legacy) ─────────────────────
+    if (!tessellationCtx) {
+        return {
+            soulAlignment: fallbackSa,
+            er4: fallbackEr4,
+            routingPath: 'non-tessellated',
+            affectedSoulIds: [],
+        };
+    }
+    const { tessellation, soulScores, depGraphEntries } = tessellationCtx;
+    const affectedSoulIds = resolveAffectedSouls(workItemId, depGraphEntries, tessellation);
+    // Build per-soul score maps for Sα and Eρ₄.
+    const soulSaMap = {};
+    const soulEr4Map = {};
+    for (const soul of tessellation.souls) {
+        const scores = soulScores[soul.soulId];
+        if (scores) {
+            soulSaMap[soul.soulId] = scores.soulAlignment;
+            soulEr4Map[soul.soulId] = scores.er4;
+        }
+    }
+    const rule = tessellation.crossSoulScoringRule ?? 'min';
+    const allSoulIds = tessellation.souls.map((s) => s.soulId);
+    // ── Substrate-only path (§6 degenerate) ───────────────────────
+    if (affectedSoulIds.length === 0) {
+        return {
+            soulAlignment: applyCrossSoulRule(allSoulIds, soulSaMap, rule, fallbackSa),
+            er4: applyCrossSoulRule(allSoulIds, soulEr4Map, rule, fallbackEr4),
+            routingPath: 'substrate-only',
+            affectedSoulIds: [],
+        };
+    }
+    // ── Single-soul path ───────────────────────────────────────────
+    if (affectedSoulIds.length === 1) {
+        const soulId = affectedSoulIds[0];
+        const scores = soulScores[soulId];
+        return {
+            soulAlignment: scores?.soulAlignment ?? fallbackSa,
+            er4: scores?.er4 ?? fallbackEr4,
+            routingPath: 'single-soul',
+            affectedSoulIds,
+        };
+    }
+    // ── Multi-soul path (crossSoulScoringRule over affected souls) ─
+    return {
+        soulAlignment: applyCrossSoulRule(affectedSoulIds, soulSaMap, rule, fallbackSa),
+        er4: applyCrossSoulRule(affectedSoulIds, soulEr4Map, rule, fallbackEr4),
+        routingPath: 'multi-soul',
+        affectedSoulIds,
+    };
+}
+//# sourceMappingURL=tessellation-admission.js.map

package/dist/tessellation-drift.d.ts

@@ -0,0 +1,246 @@
+/**
+ * RFC-0009 Phase 4.2 — Eτ_tessellation_drift detector (orchestrator-side).
+ *
+ * Detects design-coherence drift across tessellated souls per RFC-0009 §7.2
+ * (OQ-6 resolution: detection is orchestrator-side, not adapter-side).
+ *
+ * Three detection rules are specified in §7.2:
+ *
+ *   Rule #1 — AST scan for soul-name string literals in shared substrate
+ *             SHIPS HERE. Static scan over the substrate file set looking for
+ *             soul-slug string literals and `if (soul === '<slug>')` patterns
+ *             in modules that are NOT scoped to a single soul.
+ *
+ *   Rule #2 — Embedding distance between Soul DIDs over time
+ *             EXPLICITLY DEFERRED to RFC-0019 (Embedding Provider Adapter).
+ *             Not implemented here; would land in a separate detector once
+ *             `embedDocument(text)` is callable from the orchestrator.
+ *
+ *   Rule #3 — Cross-soul provenance audits
+ *             SHIPS HERE. Walks the supplied provenance records (RFC-0009 §8.3
+ *             ProvenanceRecord with `targetedSouls`, `substrateScoped`,
+ *             `tessellatedSoulRef`, all landed by AISDLC-315) and flags work
+ *             whose `targetedSouls` set crosses tessellation boundaries
+ *             without an amendment record; flags substrate work whose
+ *             downstream provenance shows soul-distinct outcomes diverge.
+ *
+ * Both shipped rules are gated on adopter opt-in via `enabled` (default
+ * `false`) per RFC-0009 §10 Phase 4 promotion convention ("All sub-dimension
+ * activations are gated on adopter opt-in initially").
+ *
+ * Detected drift events emit to `events.jsonl` (the RFC-0015 substrate) via
+ * the supplied `emit` callback. Callers wire this to
+ * `orchestrator/src/artifacts.appendEvent(artifactsDir, event)`.
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §7.2 + §10
+ */
+import type { ProvenanceRecord } from '@ai-sdlc/reference';
+import type { Tessellation } from '@ai-sdlc/reference';
+/**
+ * Discriminated rule identifier for an emitted drift event.
+ *
+ * - `'ast-scan'`           — Rule #1 (soul-name leakage in substrate).
+ * - `'cross-soul-provenance'` — Rule #3 (provenance crosses soul boundaries
+ *                                       without amendment, OR substrate
+ *                                       provenance shows divergent soul-
+ *                                       distinct outcomes).
+ *
+ * Rule #2 (`'embedding-distance'`) is reserved for the RFC-0019 follow-on
+ * detector and is intentionally NOT a member of this union — exporting it
+ * here would invite premature consumers. AISDLC-340 will add it.
+ */
+export type TessellationDriftRule = 'ast-scan' | 'cross-soul-provenance';
+/**
+ * The minimal common shape of every drift event written to events.jsonl.
+ *
+ * Discriminated by `rule` so consumers (operators grepping events.jsonl,
+ * cli-status, TUI analytics) can attribute to the originating detector
+ * without re-parsing free-form messages.
+ */
+export interface TessellationDriftDetectedEvent {
+    type: 'TessellationDriftDetected';
+    rule: TessellationDriftRule;
+    /** RFC-3339 UTC timestamp at detection time. */
+    timestamp: string;
+    /**
+     * Parent Tessellated DID URI (e.g., `did:platform-x:platform`) the drift
+     * was detected against. Sourced from the `tessellation` field's owning
+     * DID; callers pass it through so events.jsonl traces back to the DID.
+     */
+    tessellatedDid: string;
+    /**
+     * Soul IDs implicated in the drift (for `ast-scan`: souls whose slugs
+     * appeared in shared substrate; for `cross-soul-provenance`: souls
+     * crossed). Empty if no specific souls are implicated.
+     */
+    involvedSouls: string[];
+    /** Human-readable severity label. Currently a single tier; reserved for future expansion. */
+    severity: 'warning';
+    /** Free-form one-line summary; safe for operator surfaces (TUI, Slack). */
+    message: string;
+    /**
+     * Rule-specific structured payload. Per-rule discriminator is `rule`
+     * above; consumers narrow on that before reading `details`.
+     */
+    details: AstScanDetails | CrossSoulProvenanceDetails;
+}
+/** Details emitted by Rule #1 (AST scan). */
+export interface AstScanDetails {
+    rule: 'ast-scan';
+    /** Each finding represents one literal/conditional hit in substrate code. */
+    findings: AstScanFinding[];
+}
+/** A single AST-scan finding. */
+export interface AstScanFinding {
+    /** Path of the substrate file that contained the soul-leaking literal. */
+    filePath: string;
+    /** Soul slug whose name leaked into shared substrate. */
+    soulSlug: string;
+    /** 1-based line number in `filePath`. */
+    line: number;
+    /**
+     * Discriminator for which pattern triggered the finding:
+     * - `'string-literal'`     — bare `'<slug>'` (or `"<slug>"`) appeared in substrate
+     * - `'soul-conditional'`   — `if (soul === '<slug>')` / `=== "<slug>"` branched on soul
+     */
+    pattern: 'string-literal' | 'soul-conditional';
+    /** The raw matching substring (trimmed) for operator inspection. */
+    excerpt: string;
+}
+/** Details emitted by Rule #3 (cross-soul provenance audit). */
+export interface CrossSoulProvenanceDetails {
+    rule: 'cross-soul-provenance';
+    /** Each finding represents one provenance record (or substrate-vs-soul divergence) flagged. */
+    findings: CrossSoulProvenanceFinding[];
+}
+/** A single cross-soul provenance finding. */
+export interface CrossSoulProvenanceFinding {
+    /**
+     * Discriminator:
+     * - `'cross-boundary-no-amendment'` — provenance's `targetedSouls` spans
+     *   >=2 souls and no recorded amendment was supplied for the work.
+     * - `'substrate-divergent-outcomes'` — `substrateScoped: true` provenance
+     *   where downstream soul-distinct outcomes diverge sharply (the caller-
+     *   supplied `outcomeBySoul` map shows ≥`divergenceThreshold` spread).
+     */
+    kind: 'cross-boundary-no-amendment' | 'substrate-divergent-outcomes';
+    /**
+     * Stable per-work-item identifier extracted from `promptHash` so operators
+     * can grep events.jsonl by work item without exposing soul data.
+     */
+    workItemRef: string;
+    /** Soul IDs crossed (for cross-boundary) or implicated (for substrate-divergent). */
+    crossedSouls: string[];
+    /**
+     * Soul-distinct outcome readings for substrate-divergent findings, keyed
+     * by soulId. Absent for cross-boundary findings.
+     */
+    outcomeBySoul?: Record<string, number>;
+    /** Free-form description; safe for operator surfaces. */
+    note: string;
+}
+/**
+ * A single substrate file's contents for Rule #1 to scan.
+ *
+ * Callers materialize this from the dependency graph + filesystem before
+ * invoking the detector. Only files NOT scoped to a single soul should be
+ * passed in (files under `.ai-sdlc/souls/<slug>/` or other soul-scoped
+ * trees are by-definition allowed to mention their own soul slug).
+ */
+export interface SubstrateFile {
+    /** Workspace-relative path (use forward slashes; informational only). */
+    path: string;
+    /** Full file contents as UTF-8. */
+    contents: string;
+}
+/**
+ * One provenance record paired with the optional cross-soul amendment ref +
+ * the optional downstream soul-outcome readings.
+ *
+ * `amendmentRecorded` is true when the work item carried an explicit
+ * cross-tessellation amendment (operator-acknowledged the cross-soul span).
+ * `outcomeBySoul` is the optional downstream calibration cell readout per
+ * soul, supplied for substrate-scoped provenance so Rule #3 can detect
+ * sharp divergence in soul-distinct outcomes.
+ */
+export interface ProvenanceAuditEntry {
+    /** The provenance record itself (RFC-0009 §8.3 extended shape). */
+    record: ProvenanceRecord;
+    /** True iff the operator recorded a cross-tessellation amendment for this work item. */
+    amendmentRecorded?: boolean;
+    /**
+     * Soul-distinct outcome readout, keyed by soulId. Only meaningful when
+     * `record.substrateScoped === true`. Values are caller-supplied outcome
+     * scores in [0, 1]; the detector flags when the spread exceeds
+     * `divergenceThreshold`.
+     */
+    outcomeBySoul?: Record<string, number>;
+}
+/**
+ * Detector configuration. All fields optional with safe defaults; the only
+ * required toggle is `enabled` (default `false`, honoring RFC-0009 §10
+ * Phase 4 opt-in default).
+ */
+export interface TessellationDriftConfig {
+    /**
+     * Master opt-in switch. Per RFC-0009 §10 Phase 4 "All sub-dimension
+     * activations are gated on adopter opt-in initially". Default `false`;
+     * the detector short-circuits and emits nothing when disabled.
+     */
+    enabled?: boolean;
+    /**
+     * Per-rule kill switches. Useful for staged rollout (e.g., enable rule
+     * #1 first, observe noise levels, then enable rule #3). Defaults: both
+     * `true` (subject to `enabled` master gate).
+     */
+    rules?: {
+        astScan?: boolean;
+        crossSoulProvenance?: boolean;
+    };
+    /**
+     * Spread threshold for substrate-divergent-outcomes detection. When the
+     * max-min of `outcomeBySoul` values exceeds this number, the detector
+     * emits a `substrate-divergent-outcomes` finding. Defaults to 0.3 (a
+     * 30-point spread on a 0..1 outcome scale).
+     */
+    divergenceThreshold?: number;
+}
+export declare const DEFAULT_DIVERGENCE_THRESHOLD = 0.3;
+export interface TessellationDriftInput {
+    /** The Tessellated DID URI the scan runs against (for event provenance). */
+    tessellatedDid: string;
+    /** The tessellation manifest (souls + substrate invariants). */
+    tessellation: Tessellation;
+    /** Substrate file contents to scan with Rule #1. Empty/absent = rule #1 no-op. */
+    substrateFiles?: SubstrateFile[];
+    /** Provenance entries to scan with Rule #3. Empty/absent = rule #3 no-op. */
+    provenance?: ProvenanceAuditEntry[];
+}
+export interface TessellationDriftResult {
+    /** Every drift event emitted during this run (also forwarded to `emit`). */
+    events: TessellationDriftDetectedEvent[];
+    /** True when the detector short-circuited because `enabled === false`. */
+    optedOut: boolean;
+}
+/**
+ * Run Eτ_tessellation_drift detection against the supplied inputs.
+ *
+ * The detector is **read-only** — it does not mutate the tessellation,
+ * the provenance records, or the substrate files. It computes events and
+ * forwards each via the optional `emit` callback (callers wire this to
+ * `appendEvent(artifactsDir, ev)`).
+ *
+ * When `config.enabled !== true` the detector short-circuits immediately
+ * and returns `{ events: [], optedOut: true }`. This honors the RFC-0009
+ * §10 Phase 4 "adopter opt-in initially" convention; the detector exists
+ * in the surface but produces zero side effects until explicitly enabled.
+ *
+ * @param input  Detection inputs (tessellation + optional substrate + provenance).
+ * @param config Detector configuration (master `enabled` flag + per-rule toggles).
+ * @param emit   Optional event sink; called once per detected event. Errors
+ *               from `emit` are propagated to the caller (intentional — the
+ *               detector is sync-pure with respect to its inputs; the caller
+ *               decides how to handle event-stream failures).
+ */
+export declare function detectTessellationDrift(input: TessellationDriftInput, config?: TessellationDriftConfig, emit?: (event: TessellationDriftDetectedEvent) => Promise<void> | void): Promise<TessellationDriftResult>;
+//# sourceMappingURL=tessellation-drift.d.ts.map