@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/edges/store.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTwinEdgeRow = mapTwinEdgeRow;
+exports.getTwinEdge = getTwinEdge;
+exports.listTwinEdgesForRefs = listTwinEdgesForRefs;
+exports.insertTwinEdge = insertTwinEdge;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+const types_js_1 = require("./types.js");
+const EDGE_TYPE_SET = new Set(types_js_1.TWIN_EDGE_TYPES);
+const REF_KIND_SET = new Set(types_js_1.TWIN_REF_KINDS);
+const SOURCE_SET = new Set(types_js_1.TWIN_EDGE_SOURCES);
+const HUMAN_ACTOR_ROLES = new Set(['commander', 'configurator_elevated']);
+const HUMAN_REASON_CLASSIFICATIONS = new Set([
+    'factual_correction',
+    'agent_inference_wrong',
+    'privacy_redaction',
+    'duplicate_merge',
+    'state_override',
+    'other',
+]);
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)('sha256').update(input, 'utf8').digest('hex');
+}
+function sha256Buffer(input) {
+    return (0, node_crypto_1.createHash)('sha256').update(input, 'utf8').digest();
+}
+function generatedEdgeId() {
+    return `edge_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+}
+function nullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function requireNonEmptyString(value, field) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`twin_edges.${field} must be a non-empty string`);
+    }
+    return value;
+}
+function normalizeEdgeType(value) {
+    if (typeof value === 'string' && EDGE_TYPE_SET.has(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported twin edge type: ${String(value)}`);
+}
+function normalizeSource(value) {
+    if (typeof value === 'string' && SOURCE_SET.has(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported twin edge source: ${String(value)}`);
+}
+function normalizeRef(ref, field) {
+    if (!ref || typeof ref !== 'object') {
+        throw new Error(`${field} must be a TwinRef`);
+    }
+    if (!REF_KIND_SET.has(ref.kind)) {
+        throw new Error(`${field}.kind is unsupported: ${String(ref.kind)}`);
+    }
+    return {
+        kind: ref.kind,
+        id: requireNonEmptyString(ref.id, `${field}.id`),
+    };
+}
+function assertSubjectKindAllowed(ref) {
+    if (ref.kind === 'raw') {
+        throw new Error('twin_edges.subject_ref.kind cannot be raw');
+    }
+}
+function normalizeConfidence(value) {
+    if (value === undefined || value === null) {
+        return 1;
+    }
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1) {
+        return value;
+    }
+    throw new Error(`twin_edges.confidence must be between 0 and 1: ${String(value)}`);
+}
+function hasDeterministicRule(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.deterministic_rule === 'string' &&
+        value.deterministic_rule.length > 0);
+}
+function validateSourceMetadata(input, source) {
+    if (source === 'agent') {
+        requireNonEmptyString(input.agent_id, 'agent_id');
+        requireNonEmptyString(input.model_run_id, 'model_run_id');
+        requireNonEmptyString(input.envelope_hash, 'envelope_hash');
+        return;
+    }
+    if (source === 'human') {
+        requireNonEmptyString(input.human_actor_id, 'human_actor_id');
+        const role = requireNonEmptyString(input.human_actor_role, 'human_actor_role');
+        if (!HUMAN_ACTOR_ROLES.has(role)) {
+            throw new Error(`Unsupported twin_edges.human_actor_role: ${role}`);
+        }
+        if (input.authority_scope_json === undefined || input.authority_scope_json === null) {
+            throw new Error('twin_edges.authority_scope_json is required for human edges');
+        }
+        const classification = requireNonEmptyString(input.reason_classification, 'reason_classification');
+        if (!HUMAN_REASON_CLASSIFICATIONS.has(classification)) {
+            throw new Error(`Unsupported twin_edges.reason_classification: ${classification}`);
+        }
+        return;
+    }
+    if (!nullableString(input.reason_text) && !hasDeterministicRule(input.relation_attrs)) {
+        throw new Error('twin_edges.reason_text or relation_attrs.deterministic_rule is required for code edges');
+    }
+}
+function jsonField(value, field) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    try {
+        if (typeof value === 'string') {
+            return (0, canonicalize_js_1.canonicalizeJSON)(JSON.parse(value));
+        }
+        return (0, canonicalize_js_1.canonicalizeJSON)(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid twin_edges.${field}: ${message}`);
+    }
+}
+function parseJsonField(value, field, edgeId) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const text = String(value);
+    if (text.length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid twin_edges.${field} for ${edgeId}: ${message}`);
+    }
+}
+function toBuffer(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    throw new Error('twin_edges.content_hash must be a 32-byte Buffer');
+}
+function exists(adapter, table, column, id) {
+    const row = adapter
+        .prepare(`SELECT 1 AS ok FROM ${table} WHERE ${column} = ? LIMIT 1`)
+        .get(id);
+    return Boolean(row?.ok);
+}
+function validateRefExists(adapter, ref, field) {
+    if (ref.kind === 'report') {
+        throw new Error(`${field} ${ref.kind}:${ref.id} is not supported by twin_edges yet`);
+    }
+    const found = (ref.kind === 'memory' && exists(adapter, 'decisions', 'id', ref.id)) ||
+        (ref.kind === 'case' && exists(adapter, 'case_truth', 'case_id', ref.id)) ||
+        (ref.kind === 'entity' && exists(adapter, 'entity_nodes', 'id', ref.id)) ||
+        (ref.kind === 'edge' && exists(adapter, 'twin_edges', 'edge_id', ref.id)) ||
+        (ref.kind === 'raw' && exists(adapter, 'connector_event_index', 'event_index_id', ref.id));
+    if (!found) {
+        throw new Error(`${field} not found: ${ref.kind}:${ref.id}`);
+    }
+}
+function contentHashInput(input) {
+    return (0, canonicalize_js_1.canonicalizeJSON)(input);
+}
+function deriveEdgeIdempotencyKey(requestIdempotencyKey, contentHash) {
+    return `reqedge_${sha256Hex((0, canonicalize_js_1.canonicalizeJSON)({
+        request_idempotency_key: requestIdempotencyKey,
+        content_hash: contentHash.toString('hex'),
+    })).slice(0, 40)}`;
+}
+function selectByIdempotency(adapter, modelRunId, edgeIdempotencyKey) {
+    if (!edgeIdempotencyKey) {
+        return null;
+    }
+    if (!modelRunId) {
+        const row = adapter
+            .prepare(`
+          SELECT *
+          FROM twin_edges
+          WHERE model_run_id IS NULL
+            AND edge_idempotency_key = ?
+          ORDER BY created_at ASC, edge_id ASC
+          LIMIT 1
+        `)
+            .get(edgeIdempotencyKey);
+        return row ? mapTwinEdgeRow(row) : null;
+    }
+    const row = adapter
+        .prepare(`
+        SELECT *
+        FROM twin_edges
+        WHERE model_run_id = ?
+          AND edge_idempotency_key = ?
+        LIMIT 1
+      `)
+        .get(modelRunId, edgeIdempotencyKey);
+    return row ? mapTwinEdgeRow(row) : null;
+}
+function mapTwinEdgeRow(row) {
+    const edgeId = String(row.edge_id);
+    return {
+        edge_id: edgeId,
+        edge_type: normalizeEdgeType(row.edge_type),
+        subject_ref: {
+            kind: String(row.subject_kind),
+            id: String(row.subject_id),
+        },
+        object_ref: {
+            kind: String(row.object_kind),
+            id: String(row.object_id),
+        },
+        relation_attrs_json: nullableString(row.relation_attrs_json),
+        relation_attrs: parseJsonField(row.relation_attrs_json, 'relation_attrs_json', edgeId),
+        confidence: Number(row.confidence),
+        source: normalizeSource(row.source),
+        agent_id: nullableString(row.agent_id),
+        model_run_id: nullableString(row.model_run_id),
+        envelope_hash: nullableString(row.envelope_hash),
+        human_actor_id: nullableString(row.human_actor_id),
+        human_actor_role: nullableString(row.human_actor_role),
+        authority_scope_json: nullableString(row.authority_scope_json),
+        authority_scope: parseJsonField(row.authority_scope_json, 'authority_scope_json', edgeId),
+        reason_classification: nullableString(row.reason_classification),
+        reason_text: nullableString(row.reason_text),
+        evidence_refs_json: nullableString(row.evidence_refs_json),
+        evidence_refs: parseJsonField(row.evidence_refs_json, 'evidence_refs_json', edgeId),
+        request_idempotency_key: nullableString(row.request_idempotency_key),
+        edge_idempotency_key: nullableString(row.edge_idempotency_key),
+        content_hash: toBuffer(row.content_hash),
+        created_at: Number(row.created_at),
+    };
+}
+function getTwinEdge(adapter, edgeId) {
+    const row = adapter.prepare('SELECT * FROM twin_edges WHERE edge_id = ?').get(edgeId);
+    return row ? mapTwinEdgeRow(row) : null;
+}
+function listTwinEdgesForRefs(adapter, refs) {
+    const normalizedRefs = refs.map((ref, index) => normalizeRef(ref, `refs[${index}]`));
+    if (normalizedRefs.length === 0) {
+        return [];
+    }
+    const clauses = [];
+    const params = [];
+    for (const ref of normalizedRefs) {
+        clauses.push('(subject_kind = ? AND subject_id = ?)');
+        params.push(ref.kind, ref.id);
+        clauses.push('(object_kind = ? AND object_id = ?)');
+        params.push(ref.kind, ref.id);
+    }
+    const rows = adapter
+        .prepare(`
+        SELECT *
+        FROM twin_edges
+        WHERE ${clauses.join(' OR ')}
+        ORDER BY created_at ASC, edge_id ASC
+      `)
+        .all(...params);
+    return rows.map(mapTwinEdgeRow);
+}
+function insertTwinEdge(adapter, input) {
+    const edgeType = normalizeEdgeType(input.edge_type);
+    const subjectRef = normalizeRef(input.subject_ref, 'subject_ref');
+    const objectRef = normalizeRef(input.object_ref, 'object_ref');
+    assertSubjectKindAllowed(subjectRef);
+    const source = normalizeSource(input.source);
+    const confidence = normalizeConfidence(input.confidence);
+    validateSourceMetadata(input, source);
+    validateRefExists(adapter, subjectRef, 'subject_ref');
+    validateRefExists(adapter, objectRef, 'object_ref');
+    const relationAttrsJson = jsonField(input.relation_attrs, 'relation_attrs_json');
+    const evidenceRefsJson = jsonField(input.evidence_refs, 'evidence_refs_json');
+    const authorityScopeJson = jsonField(input.authority_scope_json, 'authority_scope_json');
+    const agentId = nullableString(input.agent_id);
+    const reasonText = nullableString(input.reason_text);
+    const envelopeHash = nullableString(input.envelope_hash);
+    const humanActorId = nullableString(input.human_actor_id);
+    const humanActorRole = nullableString(input.human_actor_role);
+    const reasonClassification = nullableString(input.reason_classification);
+    const requestIdempotencyKey = nullableString(input.request_idempotency_key);
+    const modelRunId = nullableString(input.model_run_id);
+    const contentHash = sha256Buffer(contentHashInput({
+        edge_type: edgeType,
+        subject_ref: subjectRef,
+        object_ref: objectRef,
+        relation_attrs_json: relationAttrsJson,
+        confidence,
+        source,
+        agent_id: agentId,
+        model_run_id: modelRunId,
+        envelope_hash: envelopeHash,
+        human_actor_id: humanActorId,
+        human_actor_role: humanActorRole,
+        authority_scope_json: authorityScopeJson,
+        reason_classification: reasonClassification,
+        reason_text: reasonText,
+        evidence_refs_json: evidenceRefsJson,
+    }));
+    const edgeIdempotencyKey = nullableString(input.edge_idempotency_key) ??
+        (requestIdempotencyKey ? deriveEdgeIdempotencyKey(requestIdempotencyKey, contentHash) : null);
+    const existing = selectByIdempotency(adapter, modelRunId, edgeIdempotencyKey);
+    if (existing) {
+        return existing;
+    }
+    const edgeId = nullableString(input.edge_id) ?? generatedEdgeId();
+    const createdAt = Date.now();
+    try {
+        return adapter.transaction(() => {
+            adapter
+                .prepare(`
+            INSERT INTO twin_edges (
+              edge_id, edge_type, subject_kind, subject_id, object_kind, object_id,
+              relation_attrs_json, confidence, source, agent_id, model_run_id, envelope_hash,
+              human_actor_id, human_actor_role, authority_scope_json, reason_classification,
+              reason_text, evidence_refs_json, request_idempotency_key, edge_idempotency_key,
+              content_hash, created_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `)
+                .run(edgeId, edgeType, subjectRef.kind, subjectRef.id, objectRef.kind, objectRef.id, relationAttrsJson, confidence, source, agentId, modelRunId, envelopeHash, humanActorId, humanActorRole, authorityScopeJson, reasonClassification, reasonText, evidenceRefsJson, requestIdempotencyKey, edgeIdempotencyKey, contentHash, createdAt);
+            const inserted = getTwinEdge(adapter, edgeId);
+            if (!inserted) {
+                throw new Error(`Failed to load inserted twin edge: ${edgeId}`);
+            }
+            return inserted;
+        });
+    }
+    catch (error) {
+        const duplicate = selectByIdempotency(adapter, modelRunId, edgeIdempotencyKey);
+        if (duplicate) {
+            return duplicate;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/edges/types.d.ts

@@ -0,0 +1,86 @@
+import type { Buffer } from 'node:buffer';
+export declare const TWIN_REF_KINDS: readonly ["memory", "case", "entity", "report", "edge", "raw"];
+export type TwinRefKind = (typeof TWIN_REF_KINDS)[number];
+export declare const TWIN_EDGE_SOURCES: readonly ["agent", "human", "code"];
+export type TwinEdgeSource = (typeof TWIN_EDGE_SOURCES)[number];
+export declare const TWIN_EDGE_TYPES: readonly ["supersedes", "builds_on", "debates", "synthesizes", "mentions", "derived_from", "case_member", "alias_of", "next_action_for", "blocks"];
+export type TwinEdgeType = (typeof TWIN_EDGE_TYPES)[number];
+export type TwinRef = {
+    [Kind in TwinRefKind]: {
+        kind: Kind;
+        id: string;
+    };
+}[TwinRefKind];
+export type TwinEdgeSubjectRef = Exclude<TwinRef, {
+    kind: 'raw';
+}>;
+export interface TwinScopeRef {
+    kind: 'global' | 'user' | 'channel' | 'project';
+    id: string;
+}
+export interface TwinProjectRef {
+    kind: string;
+    id: string;
+}
+export interface TwinVisibility {
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    projectRefs?: TwinProjectRef[];
+    tenantId?: string | null;
+    asOfMs?: number | null;
+}
+export interface InsertTwinEdgeInput {
+    edge_id?: string;
+    edge_type: TwinEdgeType;
+    subject_ref: TwinEdgeSubjectRef;
+    object_ref: TwinRef;
+    relation_attrs?: unknown;
+    confidence?: number;
+    source: TwinEdgeSource;
+    agent_id?: string;
+    model_run_id?: string;
+    envelope_hash?: string;
+    request_idempotency_key?: string;
+    edge_idempotency_key?: string;
+    human_actor_id?: string;
+    human_actor_role?: 'commander' | 'configurator_elevated';
+    authority_scope_json?: unknown;
+    reason_classification?: 'factual_correction' | 'agent_inference_wrong' | 'privacy_redaction' | 'duplicate_merge' | 'state_override' | 'other';
+    reason_text?: string;
+    evidence_refs?: unknown;
+}
+export interface TwinEdgeRecord {
+    edge_id: string;
+    edge_type: TwinEdgeType;
+    subject_ref: TwinRef;
+    object_ref: TwinRef;
+    relation_attrs_json: string | null;
+    relation_attrs: unknown | null;
+    confidence: number;
+    source: TwinEdgeSource;
+    agent_id: string | null;
+    model_run_id: string | null;
+    envelope_hash: string | null;
+    human_actor_id: string | null;
+    human_actor_role: string | null;
+    authority_scope_json: string | null;
+    authority_scope: unknown | null;
+    reason_classification: string | null;
+    reason_text: string | null;
+    evidence_refs_json: string | null;
+    evidence_refs: unknown | null;
+    request_idempotency_key: string | null;
+    edge_idempotency_key: string | null;
+    content_hash: Buffer;
+    created_at: number;
+}
+export interface ListVisibleTwinEdgesOptions {
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    projectRefs?: TwinProjectRef[];
+    tenantId?: string | null;
+    edgeTypes?: TwinEdgeType[];
+    asOfMs?: number | null;
+    limit?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/edges/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TWIN_EDGE_TYPES = exports.TWIN_EDGE_SOURCES = exports.TWIN_REF_KINDS = void 0;
+exports.TWIN_REF_KINDS = ['memory', 'case', 'entity', 'report', 'edge', 'raw'];
+exports.TWIN_EDGE_SOURCES = ['agent', 'human', 'code'];
+exports.TWIN_EDGE_TYPES = [
+    'supersedes',
+    'builds_on',
+    'debates',
+    'synthesizes',
+    'mentions',
+    'derived_from',
+    'case_member',
+    'alias_of',
+    'next_action_for',
+    'blocks',
+];
+//# sourceMappingURL=types.js.map

package/dist/embedding-server/mobile/daemon.d.ts

@@ -83,6 +83,7 @@ export declare class ClaudeDaemon extends EventEmitter {
     private _pid;
     private _isRunning;
     private buffer;
+    private cliSessionId;
     /**
      * Create a new ClaudeDaemon instance
      * @param projectDir - Working directory for Claude Code

package/dist/embedding-server/mobile/daemon.js

@@ -17,6 +17,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeDaemon = exports.ANSI_REGEX = void 0;
 const events_1 = require("events");
+const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
 /**
  * ANSI escape code regex pattern
@@ -38,6 +39,7 @@ class ClaudeDaemon extends events_1.EventEmitter {
     _pid;
     _isRunning;
     buffer;
+    cliSessionId;
     /**
      * Create a new ClaudeDaemon instance
      * @param projectDir - Working directory for Claude Code
@@ -51,6 +53,7 @@ class ClaudeDaemon extends events_1.EventEmitter {
         this._pid = null;
         this._isRunning = false;
         this.buffer = '';
+        this.cliSessionId = (0, crypto_1.randomUUID)();
     }
     /**
      * Check if the daemon is currently running
@@ -76,13 +79,20 @@ class ClaudeDaemon extends events_1.EventEmitter {
         return new Promise((resolve, reject) => {
             let settled = false;
             try {
-                // Use stream-json mode for bidirectional JSON communication
+                // Requires a modern Claude CLI build with stream-json support
+                // for --print/--verbose/--session-id/--setting-sources.
                 const args = [
+                    '--print',
+                    '--verbose',
                     '--dangerously-skip-permissions',
                     '--input-format',
                     'stream-json',
                     '--output-format',
                     'stream-json',
+                    '--session-id',
+                    this.cliSessionId,
+                    '--setting-sources',
+                    'project,local',
                 ];
                 // Spawn Claude Code CLI
                 this.process = (0, child_process_1.spawn)('claude', args, {

package/dist/embeddings.js

@@ -32,10 +32,20 @@ Object.defineProperty(exports, "getEmbeddingDim", { enumerable: true, get: funct
 Object.defineProperty(exports, "getQuantized", { enumerable: true, get: function () { return config_loader_js_1.getQuantized; } });
 // Shared cache directory (not in node_modules)
 const DEFAULT_CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers');
+const TIER3_ENV_VALUES = new Set(['1', 'true', 'yes']);
 // Singleton pattern for model loading
 let embeddingPipeline = null;
 let currentModelName = null;
 let modelLoadFailed = false; // Cache load failures to avoid repeated slow retries
+function isForceTier3Enabled() {
+    return TIER3_ENV_VALUES.has(String(process.env.MAMA_FORCE_TIER_3 || '').toLowerCase());
+}
+function assertEmbeddingsEnabled() {
+    if (isForceTier3Enabled()) {
+        throw new Error('Embedding generation disabled because MAMA_FORCE_TIER_3=true. ' +
+            'Tier 3 test mode must use lexical/no-vector fallback instead of loading the embedding model.');
+    }
+}
 /**
  * Load embedding model (configurable)
  *
@@ -45,6 +55,7 @@ let modelLoadFailed = false; // Cache load failures to avoid repeated slow retri
  * @returns Embedding pipeline
  */
 async function loadModel() {
+    assertEmbeddingsEnabled();
     const modelName = (0, config_loader_js_1.getModelName)();
     // Check if model has changed (Story M1.4 AC #3)
     if (embeddingPipeline && currentModelName && currentModelName !== modelName) {
@@ -104,6 +115,7 @@ async function generateEmbedding(text) {
     if (!text || text.trim().length === 0) {
         throw new Error('Text cannot be empty');
     }
+    assertEmbeddingsEnabled();
     // Task 2: Check cache first (AC #3)
     const cached = embedding_cache_js_1.embeddingCache.get(text);
     if (cached) {
@@ -189,6 +201,7 @@ async function generateEnhancedEmbedding(decision) {
  * @returns Array of embeddings
  */
 async function generateBatchEmbeddings(texts) {
+    assertEmbeddingsEnabled();
     if (!Array.isArray(texts) || texts.length === 0) {
         throw new Error('Texts must be a non-empty array');
     }

package/dist/entities/audit-metrics.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Entity audit metric helpers.
+ *
+ * Pure functions — no DB, no embeddings. The audit queue assembles the
+ * snapshot from live tables and fixtures, then hands it to these helpers
+ * for deterministic metric calculation + baseline classification.
+ */
+export declare const FALSE_MERGE_HARD_CEILING = 0.02;
+export type EntityAuditClassification = 'improved' | 'stable' | 'regressed' | 'inconclusive';
+export interface AuditCandidateSnapshot {
+    id: string;
+    status: 'pending' | 'auto_merged' | 'approved' | 'rejected' | 'deferred';
+    score_total: number;
+    left_canonical_id: string | null;
+    right_canonical_id: string | null;
+    left_kind: string | null;
+    right_kind: string | null;
+}
+export interface AuditGoldPair {
+    canonical_id: string;
+    left_obs_id: string;
+    right_obs_id: string;
+}
+export interface AuditCandidateGoldLink {
+    candidate_id: string;
+    matched_pair_key: string;
+    score_total: number;
+}
+export interface AuditSnapshot {
+    candidates: AuditCandidateSnapshot[];
+    gold_pairs: AuditGoldPair[];
+    candidate_gold_matches: AuditCandidateGoldLink[];
+    gold_canonical_projection_counts: Record<string, number>;
+}
+export interface AuditMetricSummary {
+    false_merge_rate: number;
+    false_merge_numerator: number;
+    false_merge_denominator: number;
+    cross_language_candidate_recall_at_10: number;
+    cross_language_recall_numerator: number;
+    cross_language_recall_denominator: number;
+    ontology_violation_count: number;
+    projection_fragmentation_rate: number;
+}
+export interface AuditRunClassificationInput {
+    current: AuditMetricSummary;
+    baseline: AuditMetricSummary | null;
+}
+export declare function computeFalseMergeRate(candidates: AuditCandidateSnapshot[]): {
+    rate: number;
+    numerator: number;
+    denominator: number;
+};
+export declare function computeCrossLanguageRecallAtK(goldPairs: AuditGoldPair[], matches: AuditCandidateGoldLink[], k: number): {
+    recall: number;
+    numerator: number;
+    denominator: number;
+};
+export declare function computeCrossLanguageRecallAt5(goldPairs: AuditGoldPair[], matches: AuditCandidateGoldLink[]): {
+    recall: number;
+    numerator: number;
+    denominator: number;
+};
+export declare function computeCrossLanguageRecallAt10(goldPairs: AuditGoldPair[], matches: AuditCandidateGoldLink[]): {
+    recall: number;
+    numerator: number;
+    denominator: number;
+};
+export declare function computeOntologyViolationCount(candidates: AuditCandidateSnapshot[]): number;
+export declare function computeProjectionFragmentationRate(counts: Record<string, number>): number;
+export declare function computeAuditMetrics(snapshot: AuditSnapshot): AuditMetricSummary;
+export declare function classifyAuditRun(input: AuditRunClassificationInput): EntityAuditClassification;
+//# sourceMappingURL=audit-metrics.d.ts.map