@ai-sdlc/orchestrator 0.10.0 → 0.14.0

package/dist/substrate/identity-class.js

@@ -0,0 +1,201 @@
+/**
+ * Canonical `identityClass` taxonomy for Substrate Contract fields.
+ *
+ * Phase 1 of RFC-0028 §7.1 v0.2 resolution. Defines the framework-level
+ * taxonomy `core | evolving` together with bucket assignments, a novel-field
+ * default helper (conservative `core`), and the type-level tightening-only
+ * primitives used by Substrate Contract authors.
+ *
+ * Harmonizes with the already-shipped `'core' | 'evolving'` discriminant in
+ * `orchestrator/src/sa-scoring/layer1-deterministic.ts` — see
+ * {@link auditLayer1DeterministicClassifications} for the cross-check and
+ * {@link IdentityClassDiscrepancy} for the discrepancy shape filed against the
+ * Decision Catalog.
+ *
+ * @see spec/rfcs/RFC-0028-engineering-axis-substrate-enforcement.md §6, §7.1
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+/** Runtime-enumerable list of every taxonomy bucket. */
+export const IDENTITY_CLASSES = ['core', 'evolving'];
+// ── Bucket assignments (canonical taxonomy, RFC-0028 §7.1) ───────────
+/**
+ * Substrate Contract field names that are CANONICAL `core` per RFC-0028 §7.1.
+ *
+ * Child Soul DIDs CANNOT loosen any value declared on these fields. A pivot
+ * rescoring fires whenever any of these fields change.
+ */
+export const CORE_BUCKET = {
+    /** Categorical compliance locks — `boolean` locks typed as `true` literal when locked. */
+    categoricalComplianceLocks: [
+        'requiresTenantPhysicalIsolation',
+        'requiresVulnerableAudienceLockout',
+    ],
+    /** Compliance regime declarations — categorical, tightening-only. */
+    complianceRegimeDeclarations: ['HIPAA', 'PCI-DSS', 'SOC2', 'FedRAMP', 'GDPR'],
+    /** Director / orchestrator agent identifier — changing the director IS a Soul-level event. */
+    directorIdentifiers: ['director', 'orchestratorAgentId'],
+    /** §6 tightening-only `complianceFloor: inherit` lock. */
+    complianceFloorLock: ['complianceFloor'],
+};
+/**
+ * Substrate Contract field names that are CANONICAL `evolving` per RFC-0028 §7.1.
+ *
+ * Free movement within tightening-only bounds (a `cadence` may shorten but
+ * not lengthen past the parent; a similarity threshold may tighten but not
+ * loosen). Admission-queue rescoring only — no Soul pivot.
+ */
+export const EVOLVING_BUCKET = {
+    /** Operational cadence — observer cooldown / cadence minimum interval. */
+    operationalCadence: ['observerCooldownMs', 'cadenceMinIntervalDays'],
+    /** Scoring tuning weights — bid diversity weight, recency half-life. */
+    scoringTuningWeights: ['bidDiversityWeight', 'recencyHalfLife'],
+    /** Similarity thresholds — `clustering.similarityThreshold`. */
+    similarityThresholds: ['clustering.similarityThreshold'],
+    /** Quota quantities — `tenantQuotaShare`. */
+    quotaQuantities: ['tenantQuotaShare'],
+};
+/**
+ * Reverse-lookup table: field name → canonical `IdentityClass`.
+ * Built from {@link CORE_BUCKET} + {@link EVOLVING_BUCKET}. Fields not listed
+ * here are NOVEL and resolve via {@link defaultIdentityClassForNovelField}.
+ */
+export const CANONICAL_FIELD_CLASSIFICATIONS = Object.freeze({
+    ...Object.fromEntries(Object.values(CORE_BUCKET)
+        .flat()
+        .map((name) => [name, 'core'])),
+    ...Object.fromEntries(Object.values(EVOLVING_BUCKET)
+        .flat()
+        .map((name) => [name, 'evolving'])),
+});
+/**
+ * Resolve the canonical `IdentityClass` for a Substrate Contract field.
+ *
+ * - Listed in {@link CANONICAL_FIELD_CLASSIFICATIONS} → returns that bucket.
+ * - Otherwise NOVEL → returns `'core'` (per RFC-0028 §7.1 v0.2 conservative
+ *   default; promotion to `evolving` needs an RFC amendment with Design +
+ *   Engineering sign-off — burden-of-proof is "argue why operational").
+ *
+ * When defaulting fires AND a `warn` hook is supplied, the hook is invoked
+ * synchronously so contract authors get a visible signal that a field has
+ * not yet been classified canonically.
+ */
+export function defaultIdentityClassForNovelField(fieldName, options = {}) {
+    // Use Object.prototype.hasOwnProperty.call to prevent prototype-pollution
+    // lookups — without this guard a field named `toString` or `constructor`
+    // would resolve to inherited Object prototype values (a function typed as
+    // IdentityClass) instead of defaulting to 'core'.
+    const canonical = Object.prototype.hasOwnProperty.call(CANONICAL_FIELD_CLASSIFICATIONS, fieldName)
+        ? CANONICAL_FIELD_CLASSIFICATIONS[fieldName]
+        : undefined;
+    if (canonical !== undefined)
+        return canonical;
+    const defaulted = 'core';
+    options.warn?.(fieldName, defaulted);
+    return defaulted;
+}
+/** Run-time assertion that a {@link BoundedNumericCap} tightening is valid. */
+export function assertTightenedCap(cap) {
+    if (cap.kind === 'tightened' && cap.max > cap.previousMax) {
+        throw new IdentityClassError(`Tightening-only violation: max=${cap.max} > previousMax=${cap.previousMax}`);
+    }
+}
+/**
+ * Audit the shipped `orchestrator/src/sa-scoring/layer1-deterministic.ts`
+ * (and its compiler `did-compiler.ts`) identityClass classifications against
+ * the canonical RFC-0028 §7.1 taxonomy.
+ *
+ * RFC-0028 §7.1 canonical taxonomy classifies *Substrate Contract* fields.
+ * `layer1-deterministic.ts` applies the same `'core' | 'evolving'`
+ * discriminant to *DID scoring entries* (scope-gate terms, constraint rules,
+ * anti-patterns, measurable signals). The discriminant is reused across two
+ * layers; the taxonomy was only formally defined for the substrate layer.
+ *
+ * The defensible cross-layer discrepancy is the **default fallback**: the
+ * shipped `ic()` helper in `did-compiler.ts` returns `'evolving'` for fields
+ * with no explicit classification, but the canonical taxonomy says novel
+ * fields default to `'core'`. This is filed as a Decision rather than
+ * inline-resolved because the DID-scoring domain may legitimately prefer
+ * a different default than the substrate-contract domain — operator
+ * routing required.
+ *
+ * Returns the list of discrepancies (may be empty). Callers are responsible
+ * for piping each into `cli-decisions add --scope ... --option ...`.
+ */
+export function auditLayer1DeterministicClassifications(options = {}) {
+    const readFile = options.readFile ?? ((p) => readFileSync(p, 'utf8'));
+    // Resolve sibling paths relative to THIS module's location, not cwd —
+    // tests run from the package dir, dogfood callers run from the repo root;
+    // both must find the shipped source files.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const saScoringDir = join(here, '..', 'sa-scoring');
+    const filesToAudit = [
+        {
+            file: 'orchestrator/src/sa-scoring/did-compiler.ts',
+            absolutePath: join(saScoringDir, 'did-compiler.ts'),
+        },
+        {
+            file: 'orchestrator/src/sa-scoring/layer1-deterministic.ts',
+            absolutePath: join(saScoringDir, 'layer1-deterministic.ts'),
+        },
+    ];
+    const discrepancies = [];
+    for (const { file, absolutePath } of filesToAudit) {
+        let source;
+        try {
+            source = readFile(absolutePath);
+        }
+        catch {
+            // File missing from the working tree — skip, do not throw. The audit
+            // is best-effort; absent source is itself surfaced via the empty result
+            // and the test suite ensures the canonical path exists.
+            continue;
+        }
+        const lines = source.split('\n');
+        lines.forEach((line, idx) => {
+            const lineNumber = idx + 1;
+            // Pattern 1: `?? 'evolving'` or `?? "evolving"` — explicit default
+            // fallback to evolving. Canonical taxonomy says novel fields default
+            // to core, so any such fallback IS a discrepancy.
+            const defaultMatch = /\?\?\s*['"](evolving|core)['"]/.exec(line);
+            if (defaultMatch) {
+                const observed = defaultMatch[1];
+                if (observed !== 'core') {
+                    discrepancies.push({
+                        file,
+                        symbol: `line ${lineNumber} default fallback`,
+                        field: 'identityClass (novel default)',
+                        observed,
+                        canonical: 'core',
+                        rationale: `${file}:${lineNumber} defaults missing identityClass to '${observed}' via \`?? '${observed}'\`. ` +
+                            `Canonical RFC-0028 §7.1 taxonomy specifies novel fields default to 'core' (conservative; ` +
+                            `promotion to evolving requires RFC amendment). The DID-scoring domain may legitimately ` +
+                            `defend a different default — operator decision required to (a) align to canonical 'core', ` +
+                            `(b) carve a documented cross-layer exemption, or (c) revise the canonical taxonomy.`,
+                    });
+                }
+            }
+            // Pattern 2 (explicit `identityClass: 'evolving'` literal flagging)
+            // was REMOVED — it produced false positives for legitimate
+            // canonical-evolving fields (`observerCooldownMs`,
+            // `cadenceMinIntervalDays`, `clustering.similarityThreshold`,
+            // `tenantQuotaShare`) which correctly assign `identityClass:
+            // 'evolving'`. Cross-referencing the receiving field name from a
+            // raw text scan is too error-prone for an audit signal that flows
+            // into the Decision Catalog. Pattern 1 (`?? 'evolving'`
+            // default-fallback) is field-agnostic-safe and is the sole
+            // discrepancy class this scanner emits.
+        });
+    }
+    return discrepancies;
+}
+// ── Errors ───────────────────────────────────────────────────────────
+/** Thrown by {@link assertTightenedCap} when a child loosens a numeric cap. */
+export class IdentityClassError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IdentityClassError';
+    }
+}
+//# sourceMappingURL=identity-class.js.map

package/dist/tessellation/cross-soul-provenance-rule.d.ts

@@ -0,0 +1,133 @@
+/**
+ * RFC-0009 §13 Rule #3 — CrossSoulProvenanceRule.
+ *
+ * Implements `TessellationRule` for the Tessellation§13RuleRegistry so Rule #3
+ * is dispatchable via `registry.register(rule)` (AISDLC-489, AISDLC-467 AC#3
+ * follow-up).
+ *
+ * Wraps the existing cross-soul provenance audit logic from
+ * `tessellation-drift.ts` as a first-class `TessellationRule` instance.
+ * The detection semantics are preserved unchanged:
+ *
+ *   **Detection A** — `cross-boundary-no-amendment`: provenance's `targetedSouls`
+ *   spans >=2 souls present in the tessellation without a recorded cross-
+ *   tessellation amendment.
+ *
+ *   **Detection B** — `substrate-divergent-outcomes`: `substrateScoped: true`
+ *   provenance where the max-min spread of `outcomeBySoul` values meets or
+ *   exceeds `divergenceThreshold`.
+ *
+ * ### Provenance input via RuleScanTarget
+ *
+ * `RuleScanTarget.provenance` carries `unknown[]` for forward-compatibility.
+ * `CrossSoulProvenanceRule` narrows each entry to `CrossSoulProvenanceEntry`
+ * (the shape understood by the rule) using a runtime type-guard. Entries that
+ * do not match the expected shape are silently skipped — this preserves
+ * backward-compat when callers pass mixed provenance arrays.
+ *
+ * Callers should pass `ProvenanceAuditEntry[]` from `tessellation-drift.ts`
+ * as `target.provenance` — `CrossSoulProvenanceEntry` is structurally
+ * compatible with `ProvenanceAuditEntry` (same fields, re-typed to avoid
+ * a cross-module import cycle).
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §7.2 Rule #3 + §8.3
+ * @see orchestrator/src/tessellation-drift.ts (original Rule #3 logic)
+ */
+import type { TessellationRule, DriftEvent, DriftSeverity, RuleScanTarget } from './rule-registry.js';
+/**
+ * Minimal provenance record shape required by CrossSoulProvenanceRule.
+ *
+ * Structurally compatible with `ProvenanceRecord` from `@ai-sdlc/reference`
+ * (the fields used by the rule). Defined here to avoid a cross-module import
+ * cycle between the registry package and the tessellation-drift package.
+ */
+interface MinimalProvenanceRecord {
+    promptHash?: string;
+    timestamp: string;
+    targetedSouls?: string[];
+    substrateScoped?: boolean;
+}
+/**
+ * One provenance record paired with the optional cross-soul amendment ref +
+ * the optional downstream soul-outcome readings.
+ *
+ * Structurally compatible with `ProvenanceAuditEntry` from `tessellation-drift.ts`.
+ */
+export interface CrossSoulProvenanceEntry {
+    record: MinimalProvenanceRecord;
+    amendmentRecorded?: boolean;
+    outcomeBySoul?: Record<string, number>;
+}
+/**
+ * A single cross-soul provenance finding (mirrors `CrossSoulProvenanceFinding`
+ * from `tessellation-drift.ts`).
+ */
+export interface CrossSoulProvenanceFinding {
+    kind: 'cross-boundary-no-amendment' | 'substrate-divergent-outcomes';
+    workItemRef: string;
+    crossedSouls: string[];
+    outcomeBySoul?: Record<string, number>;
+    note: string;
+}
+/**
+ * Structured details payload for cross-soul-provenance drift events.
+ */
+export interface CrossSoulProvenanceDetails {
+    rule: 'cross-soul-provenance';
+    findings: CrossSoulProvenanceFinding[];
+}
+/**
+ * Configuration for `CrossSoulProvenanceRule`.
+ */
+export interface CrossSoulProvenanceConfig {
+    /**
+     * Spread threshold for substrate-divergent-outcomes detection.
+     * Defaults to 0.3 (30-point spread on a 0..1 outcome scale).
+     */
+    divergenceThreshold?: number;
+    /**
+     * Severity override. Default `'warning'` (matches the original
+     * `TessellationDriftDetectedEvent severity: 'warning'` in `tessellation-drift.ts`).
+     */
+    severity?: DriftSeverity;
+}
+export declare const DEFAULT_DIVERGENCE_THRESHOLD = 0.3;
+/**
+ * CrossSoulProvenanceRule — RFC-0009 §13 Rule #3.
+ *
+ * Audits provenance records for cross-soul boundary violations and
+ * substrate-divergent outcomes. Emits a `DriftEvent` when:
+ *
+ * - A work item targets >=2 tessellation souls without a recorded amendment, OR
+ * - A substrate-scoped work item shows divergent soul-distinct outcomes.
+ *
+ * Provenance entries arrive via `target.provenance` (typed `unknown[]` in
+ * `RuleScanTarget`). The rule narrows each entry via `isCrossSoulProvenanceEntry`
+ * and skips entries that don't match.
+ *
+ * Soul slugs for boundary validation arrive via `target.soulSlugs` (forward-
+ * compat field on `RuleScanTarget`). When absent, all `targetedSouls` in the
+ * provenance records are treated as valid tessellation members (permissive mode).
+ *
+ * ### Registration
+ *
+ * ```ts
+ * const registry = createTessellation13Registry();
+ * registry.register(new CrossSoulProvenanceRule());
+ * // With config:
+ * registry.register(new CrossSoulProvenanceRule({ divergenceThreshold: 0.5 }));
+ * ```
+ */
+export declare class CrossSoulProvenanceRule implements TessellationRule {
+    readonly name = "cross-soul-provenance";
+    readonly description = "Audits provenance records for cross-soul boundary violations and substrate-divergent soul outcomes (RFC-0009 \u00A77.2 Rule #3)";
+    readonly severity: DriftSeverity;
+    private readonly divergenceThreshold;
+    /**
+     * @param config  Optional configuration overrides.
+     */
+    constructor(config?: CrossSoulProvenanceConfig);
+    scan(target: RuleScanTarget): DriftEvent[];
+}
+export {};
+//# sourceMappingURL=cross-soul-provenance-rule.d.ts.map

package/dist/tessellation/cross-soul-provenance-rule.js

@@ -0,0 +1,171 @@
+/**
+ * RFC-0009 §13 Rule #3 — CrossSoulProvenanceRule.
+ *
+ * Implements `TessellationRule` for the Tessellation§13RuleRegistry so Rule #3
+ * is dispatchable via `registry.register(rule)` (AISDLC-489, AISDLC-467 AC#3
+ * follow-up).
+ *
+ * Wraps the existing cross-soul provenance audit logic from
+ * `tessellation-drift.ts` as a first-class `TessellationRule` instance.
+ * The detection semantics are preserved unchanged:
+ *
+ *   **Detection A** — `cross-boundary-no-amendment`: provenance's `targetedSouls`
+ *   spans >=2 souls present in the tessellation without a recorded cross-
+ *   tessellation amendment.
+ *
+ *   **Detection B** — `substrate-divergent-outcomes`: `substrateScoped: true`
+ *   provenance where the max-min spread of `outcomeBySoul` values meets or
+ *   exceeds `divergenceThreshold`.
+ *
+ * ### Provenance input via RuleScanTarget
+ *
+ * `RuleScanTarget.provenance` carries `unknown[]` for forward-compatibility.
+ * `CrossSoulProvenanceRule` narrows each entry to `CrossSoulProvenanceEntry`
+ * (the shape understood by the rule) using a runtime type-guard. Entries that
+ * do not match the expected shape are silently skipped — this preserves
+ * backward-compat when callers pass mixed provenance arrays.
+ *
+ * Callers should pass `ProvenanceAuditEntry[]` from `tessellation-drift.ts`
+ * as `target.provenance` — `CrossSoulProvenanceEntry` is structurally
+ * compatible with `ProvenanceAuditEntry` (same fields, re-typed to avoid
+ * a cross-module import cycle).
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §7.2 Rule #3 + §8.3
+ * @see orchestrator/src/tessellation-drift.ts (original Rule #3 logic)
+ */
+export const DEFAULT_DIVERGENCE_THRESHOLD = 0.3;
+// ── Internal helpers ───────────────────────────────────────────────────
+/**
+ * Derive a short stable work-item reference from a provenance record's
+ * `promptHash`. Mirrors `deriveWorkItemRef` in `tessellation-drift.ts`.
+ */
+function deriveWorkItemRef(record) {
+    if (record.promptHash && record.promptHash.length > 0) {
+        return record.promptHash.slice(0, 16);
+    }
+    return record.timestamp;
+}
+/** Compute the max-min spread of an outcome map. Returns 0 for <2 souls. */
+function outcomeSpread(outcomeBySoul) {
+    const values = Object.values(outcomeBySoul).filter((v) => typeof v === 'number');
+    if (values.length < 2)
+        return 0;
+    return Math.max(...values) - Math.min(...values);
+}
+/**
+ * Type-guard for a `CrossSoulProvenanceEntry`.
+ *
+ * Accepts any object that has a `record` field with a `timestamp` string —
+ * the minimum shape required for the rule to operate safely. Extra fields
+ * are tolerated (structural subtyping).
+ */
+function isCrossSoulProvenanceEntry(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const obj = v;
+    if (typeof obj['record'] !== 'object' || obj['record'] === null)
+        return false;
+    const rec = obj['record'];
+    return typeof rec['timestamp'] === 'string';
+}
+// ── Rule implementation ────────────────────────────────────────────────
+/**
+ * CrossSoulProvenanceRule — RFC-0009 §13 Rule #3.
+ *
+ * Audits provenance records for cross-soul boundary violations and
+ * substrate-divergent outcomes. Emits a `DriftEvent` when:
+ *
+ * - A work item targets >=2 tessellation souls without a recorded amendment, OR
+ * - A substrate-scoped work item shows divergent soul-distinct outcomes.
+ *
+ * Provenance entries arrive via `target.provenance` (typed `unknown[]` in
+ * `RuleScanTarget`). The rule narrows each entry via `isCrossSoulProvenanceEntry`
+ * and skips entries that don't match.
+ *
+ * Soul slugs for boundary validation arrive via `target.soulSlugs` (forward-
+ * compat field on `RuleScanTarget`). When absent, all `targetedSouls` in the
+ * provenance records are treated as valid tessellation members (permissive mode).
+ *
+ * ### Registration
+ *
+ * ```ts
+ * const registry = createTessellation13Registry();
+ * registry.register(new CrossSoulProvenanceRule());
+ * // With config:
+ * registry.register(new CrossSoulProvenanceRule({ divergenceThreshold: 0.5 }));
+ * ```
+ */
+export class CrossSoulProvenanceRule {
+    name = 'cross-soul-provenance';
+    description = 'Audits provenance records for cross-soul boundary violations and substrate-divergent soul outcomes (RFC-0009 §7.2 Rule #3)';
+    severity;
+    divergenceThreshold;
+    /**
+     * @param config  Optional configuration overrides.
+     */
+    constructor(config = {}) {
+        this.severity = config.severity ?? 'warning';
+        this.divergenceThreshold = config.divergenceThreshold ?? DEFAULT_DIVERGENCE_THRESHOLD;
+    }
+    scan(target) {
+        const { tessellatedDid, provenance } = target;
+        // No-op when no provenance entries.
+        if (!provenance || provenance.length === 0)
+            return [];
+        const now = new Date().toISOString();
+        // Soul slug set for boundary-filtering. Accept from `target.soulSlugs`
+        // (forward-compat field). When absent, treat all souls as valid (permissive).
+        const soulSlugsRaw = target.soulSlugs;
+        const soulSlugSet = soulSlugsRaw ? new Set(soulSlugsRaw) : null;
+        const findings = [];
+        for (const entry of provenance) {
+            // Skip entries that don't match the expected shape.
+            if (!isCrossSoulProvenanceEntry(entry))
+                continue;
+            const { record, amendmentRecorded, outcomeBySoul } = entry;
+            // Filter targetedSouls to souls in the tessellation (when soulSlugSet is known).
+            const raw = record.targetedSouls ?? [];
+            const valid = soulSlugSet ? raw.filter((s) => soulSlugSet.has(s)) : raw;
+            // Detection A: cross-boundary without amendment.
+            if (valid.length >= 2 && amendmentRecorded !== true) {
+                findings.push({
+                    kind: 'cross-boundary-no-amendment',
+                    workItemRef: deriveWorkItemRef(record),
+                    crossedSouls: [...valid].sort(),
+                    note: `work item targeted ${valid.length} souls without a recorded cross-tessellation amendment`,
+                });
+            }
+            // Detection B: substrate-scoped with divergent outcomes.
+            if (record.substrateScoped === true &&
+                outcomeBySoul &&
+                Object.keys(outcomeBySoul).length >= 2) {
+                const spread = outcomeSpread(outcomeBySoul);
+                if (spread >= this.divergenceThreshold) {
+                    findings.push({
+                        kind: 'substrate-divergent-outcomes',
+                        workItemRef: deriveWorkItemRef(record),
+                        crossedSouls: Object.keys(outcomeBySoul).sort(),
+                        outcomeBySoul: { ...outcomeBySoul },
+                        note: `substrate provenance shows soul-distinct outcome spread ${spread.toFixed(3)} ≥ threshold ${this.divergenceThreshold}`,
+                    });
+                }
+            }
+        }
+        if (findings.length === 0)
+            return [];
+        const involved = new Set(findings.flatMap((f) => f.crossedSouls));
+        return [
+            {
+                rule: this.name,
+                timestamp: now,
+                message: `Cross-soul provenance: ${findings.length} finding(s) across ${involved.size} soul(s) (tessellation: ${tessellatedDid})`,
+                severity: this.severity,
+                details: {
+                    rule: 'cross-soul-provenance',
+                    findings,
+                },
+            },
+        ];
+    }
+}
+//# sourceMappingURL=cross-soul-provenance-rule.js.map

package/dist/tessellation/inter-soul-embedding-distance-rule.d.ts

@@ -0,0 +1,61 @@
+/**
+ * RFC-0009 §13 Rule #2 — InterSoulEmbeddingDistanceRule (interface stub).
+ *
+ * Implements `TessellationRule` for the Tessellation§13RuleRegistry so Rule #2
+ * is registerable via `registry.register(rule)` (AISDLC-489, AISDLC-467 AC#3
+ * follow-up).
+ *
+ * Rule #2 (embedding distance between Soul DIDs over time) is **explicitly
+ * deferred to RFC-0019** (Embedding Provider Adapter). This class ships as a
+ * registered interface stub — it satisfies `TessellationRule`, is registerable,
+ * and returns an empty `DriftEvent[]` on every `scan()` call until RFC-0019
+ * provides an `embedDocument(text)` callable from the orchestrator.
+ *
+ * ### Rationale for stub registration
+ *
+ * Registering the stub now (rather than leaving Rule #2 entirely absent) means:
+ * - `registry.getRegisteredRules()` includes `'inter-soul-embedding-distance'`
+ *   in the standard 3-rule enumeration, making the §13 rule set queryable/
+ *   observable by operator tooling (TUI, Slack digests) without an RFC-0019 gap.
+ * - The RFC-0019 implementation lands by replacing this stub class with the
+ *   real embedding-distance implementation — NO registration-site changes needed.
+ *
+ * ### Upgrading to the real rule
+ *
+ * Per RFC-0019: replace this stub with the real embedding-distance rule once
+ * `embedDocument(text): Promise<number[]>` is callable from the orchestrator.
+ * The name `'inter-soul-embedding-distance'` is the stable canonical rule name;
+ * do NOT change it when swapping in the real implementation.
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §7.2 Rule #2
+ * @see spec/rfcs/RFC-0019-embedding-provider-adapter.md (implementation target)
+ */
+import type { TessellationRule, DriftEvent, DriftSeverity, RuleScanTarget } from './rule-registry.js';
+/**
+ * InterSoulEmbeddingDistanceRule — RFC-0009 §13 Rule #2 (deferred stub).
+ *
+ * Detects embedding distance drift between Soul DIDs over time. Implementation
+ * is deferred to RFC-0019; this stub fulfils the `TessellationRule` interface
+ * and can be registered in the Tessellation§13RuleRegistry.
+ *
+ * `scan()` always returns `[]` until the RFC-0019 embedding provider is wired.
+ *
+ * ### Registration
+ *
+ * ```ts
+ * const registry = createTessellation13Registry();
+ * registry.register(new InterSoulEmbeddingDistanceRule());
+ * ```
+ */
+export declare class InterSoulEmbeddingDistanceRule implements TessellationRule {
+    readonly name = "inter-soul-embedding-distance";
+    readonly description = "Detects embedding distance drift between Soul DIDs over time (RFC-0009 \u00A77.2 Rule #2, deferred to RFC-0019 \u2014 stub returns empty until embedding provider is available)";
+    readonly severity: DriftSeverity;
+    /**
+     * @param severity  Default `'medium'` (reserved for the real implementation;
+     *                  configurable now so adopters can set it before RFC-0019 ships).
+     */
+    constructor(severity?: DriftSeverity);
+    scan(_target: RuleScanTarget): DriftEvent[];
+}
+//# sourceMappingURL=inter-soul-embedding-distance-rule.d.ts.map

package/dist/tessellation/inter-soul-embedding-distance-rule.js

@@ -0,0 +1,67 @@
+/**
+ * RFC-0009 §13 Rule #2 — InterSoulEmbeddingDistanceRule (interface stub).
+ *
+ * Implements `TessellationRule` for the Tessellation§13RuleRegistry so Rule #2
+ * is registerable via `registry.register(rule)` (AISDLC-489, AISDLC-467 AC#3
+ * follow-up).
+ *
+ * Rule #2 (embedding distance between Soul DIDs over time) is **explicitly
+ * deferred to RFC-0019** (Embedding Provider Adapter). This class ships as a
+ * registered interface stub — it satisfies `TessellationRule`, is registerable,
+ * and returns an empty `DriftEvent[]` on every `scan()` call until RFC-0019
+ * provides an `embedDocument(text)` callable from the orchestrator.
+ *
+ * ### Rationale for stub registration
+ *
+ * Registering the stub now (rather than leaving Rule #2 entirely absent) means:
+ * - `registry.getRegisteredRules()` includes `'inter-soul-embedding-distance'`
+ *   in the standard 3-rule enumeration, making the §13 rule set queryable/
+ *   observable by operator tooling (TUI, Slack digests) without an RFC-0019 gap.
+ * - The RFC-0019 implementation lands by replacing this stub class with the
+ *   real embedding-distance implementation — NO registration-site changes needed.
+ *
+ * ### Upgrading to the real rule
+ *
+ * Per RFC-0019: replace this stub with the real embedding-distance rule once
+ * `embedDocument(text): Promise<number[]>` is callable from the orchestrator.
+ * The name `'inter-soul-embedding-distance'` is the stable canonical rule name;
+ * do NOT change it when swapping in the real implementation.
+ *
+ * @see spec/rfcs/RFC-0009-tessellated-design-intent-documents.md §7.2 Rule #2
+ * @see spec/rfcs/RFC-0019-embedding-provider-adapter.md (implementation target)
+ */
+/**
+ * InterSoulEmbeddingDistanceRule — RFC-0009 §13 Rule #2 (deferred stub).
+ *
+ * Detects embedding distance drift between Soul DIDs over time. Implementation
+ * is deferred to RFC-0019; this stub fulfils the `TessellationRule` interface
+ * and can be registered in the Tessellation§13RuleRegistry.
+ *
+ * `scan()` always returns `[]` until the RFC-0019 embedding provider is wired.
+ *
+ * ### Registration
+ *
+ * ```ts
+ * const registry = createTessellation13Registry();
+ * registry.register(new InterSoulEmbeddingDistanceRule());
+ * ```
+ */
+export class InterSoulEmbeddingDistanceRule {
+    name = 'inter-soul-embedding-distance';
+    description = 'Detects embedding distance drift between Soul DIDs over time (RFC-0009 §7.2 Rule #2, deferred to RFC-0019 — stub returns empty until embedding provider is available)';
+    severity;
+    /**
+     * @param severity  Default `'medium'` (reserved for the real implementation;
+     *                  configurable now so adopters can set it before RFC-0019 ships).
+     */
+    constructor(severity = 'medium') {
+        this.severity = severity;
+    }
+    scan(_target) {
+        // Rule #2 is deferred to RFC-0019. This stub intentionally returns empty.
+        // When RFC-0019 lands, replace this body with the real embedding-distance
+        // scan logic. The rule name and interface contract are stable.
+        return [];
+    }
+}
+//# sourceMappingURL=inter-soul-embedding-distance-rule.js.map