@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/entities/entity-impact.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityInspectorDetail = getEntityInspectorDetail;
+exports.listEntityLineageForInspector = listEntityLineageForInspector;
+exports.getEntityImpact = getEntityImpact;
+exports.getEntityIngestRun = getEntityIngestRun;
+const db_manager_js_1 = require("../db-manager.js");
+const source_locator_js_1 = require("./source-locator.js");
+const lineage_store_js_1 = require("./lineage-store.js");
+function mapEntityNode(row) {
+    return {
+        id: String(row.id),
+        kind: row.kind,
+        preferred_label: String(row.preferred_label),
+        status: row.status,
+        scope_kind: typeof row.scope_kind === 'string' ? row.scope_kind : null,
+        scope_id: typeof row.scope_id === 'string' ? row.scope_id : null,
+        merged_into: typeof row.merged_into === 'string' ? row.merged_into : null,
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+    };
+}
+async function getEntityInspectorDetail(entityId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter.prepare(`SELECT * FROM entity_nodes WHERE id = ?`).get(entityId);
+    if (!row) {
+        throw new Error(`Entity not found: ${entityId}`);
+    }
+    const lineageCount = adapter
+        .prepare(`
+        SELECT COUNT(*) AS total
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+      `)
+        .get(entityId);
+    return {
+        entity: mapEntityNode(row),
+        history_incomplete: lineageCount.total === 0,
+    };
+}
+async function listEntityLineageForInspector(entityId, limit = 50) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const safeLimit = Math.max(1, Math.min(limit, 500));
+    const rows = adapter
+        .prepare(`
+        SELECT
+          l.*,
+          o.source_connector,
+          o.source_raw_record_id,
+          o.source_locator,
+          o.surface_form
+        FROM entity_lineage_links l
+        JOIN entity_observations o ON o.id = l.entity_observation_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY l.created_at ASC
+        LIMIT ?
+      `)
+        .all(entityId, safeLimit);
+    return {
+        rows: rows.map((row) => ({
+            id: String(row.id),
+            canonical_entity_id: String(row.canonical_entity_id),
+            entity_observation_id: String(row.entity_observation_id),
+            source_entity_id: typeof row.source_entity_id === 'string' ? row.source_entity_id : null,
+            contribution_kind: row.contribution_kind,
+            run_id: typeof row.run_id === 'string' ? row.run_id : null,
+            candidate_id: typeof row.candidate_id === 'string' ? row.candidate_id : null,
+            review_action_id: typeof row.review_action_id === 'string' ? row.review_action_id : null,
+            status: row.status,
+            capture_mode: row.capture_mode,
+            confidence: Number(row.confidence),
+            created_at: Number(row.created_at),
+            superseded_at: typeof row.superseded_at === 'number' ? row.superseded_at : null,
+            source_connector: String(row.source_connector),
+            source_raw_record_id: String(row.source_raw_record_id),
+            source_locator: typeof row.source_locator === 'string' ? row.source_locator : null,
+            source_locator_kind: (0, source_locator_js_1.detectSourceLocatorKind)(typeof row.source_locator === 'string' ? row.source_locator : null),
+            surface_form: String(row.surface_form),
+        })),
+        history_incomplete: rows.length === 0,
+    };
+}
+async function getEntityImpact(entityId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const relatedMemories = adapter
+        .prepare(`
+        SELECT DISTINCT d.id, d.topic, d.summary, d.created_at
+        FROM entity_lineage_links l
+        JOIN decision_entity_sources des ON des.entity_observation_id = l.entity_observation_id
+        JOIN decisions d ON d.id = des.decision_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY d.created_at DESC
+      `)
+        .all(entityId);
+    const ingestRuns = adapter
+        .prepare(`
+        SELECT DISTINCT ir.*
+        FROM entity_lineage_links l
+        JOIN entity_ingest_runs ir ON ir.id = l.run_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY ir.created_at DESC
+      `)
+        .all(entityId);
+    const auditRuns = adapter
+        .prepare(`
+        SELECT DISTINCT ar.id, ar.classification, ar.status, ar.created_at, ar.completed_at
+        FROM entity_lineage_links l
+        JOIN entity_ingest_runs ir ON ir.id = l.run_id
+        JOIN entity_audit_runs ar ON ar.id = ir.audit_run_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY ar.created_at DESC
+        LIMIT 10
+      `)
+        .all(entityId);
+    return {
+        related_memories: relatedMemories.map((row) => ({
+            id: row.id,
+            topic: row.topic,
+            summary: row.summary ?? row.topic,
+            created_at: row.created_at,
+        })),
+        ingest_runs: ingestRuns.map(lineage_store_js_1.parseEntityIngestRunRow),
+        audit_runs: auditRuns,
+    };
+}
+async function getEntityIngestRun(runId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter.prepare(`SELECT * FROM entity_ingest_runs WHERE id = ?`).get(runId);
+    return row ? (0, lineage_store_js_1.parseEntityIngestRunRow)(row) : null;
+}
+//# sourceMappingURL=entity-impact.js.map

package/dist/entities/entity-linked-decision-counts.d.ts

@@ -0,0 +1,2 @@
+export function loadLinkedDecisionCounts(adapter: any, entityIds: any): Map<any, any>;
+//# sourceMappingURL=entity-linked-decision-counts.d.ts.map

package/dist/entities/entity-linked-decision-counts.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLinkedDecisionCounts = loadLinkedDecisionCounts;
+function loadLinkedDecisionCounts(adapter, entityIds) {
+    const uniqueIds = Array.from(new Set(entityIds.filter((entityId) => typeof entityId === 'string' && entityId.length > 0)));
+    if (uniqueIds.length === 0) {
+        return new Map();
+    }
+    const placeholders = uniqueIds.map(() => '?').join(', ');
+    const rows = adapter
+        .prepare(`
+        SELECT
+          l.canonical_entity_id AS entity_id,
+          COUNT(DISTINCT des.decision_id) AS linked_decision_count
+        FROM entity_lineage_links l
+        INNER JOIN decision_entity_sources des
+          ON des.entity_observation_id = l.entity_observation_id
+        WHERE l.status = 'active'
+          AND l.canonical_entity_id IN (${placeholders})
+        GROUP BY l.canonical_entity_id
+      `)
+        .all(...uniqueIds);
+    const counts = new Map(uniqueIds.map((entityId) => [entityId, 0]));
+    for (const row of rows) {
+        counts.set(row.entity_id, Number(row.linked_decision_count) || 0);
+    }
+    return counts;
+}
+//# sourceMappingURL=entity-linked-decision-counts.js.map

package/dist/entities/entity-list.d.ts

@@ -0,0 +1,23 @@
+import type { EntityNode } from './types.js';
+export interface ListCanonicalEntitiesInput {
+    limit: number;
+    cursor?: string | null;
+    include_noisy?: boolean;
+}
+export interface CanonicalEntityListRow {
+    id: string;
+    kind: EntityNode['kind'];
+    preferred_label: string;
+    scope_kind: EntityNode['scope_kind'];
+    scope_id: string | null;
+    created_at: number;
+    linked_decision_count: number;
+}
+export interface ListCanonicalEntitiesResult {
+    entities: CanonicalEntityListRow[];
+    next_cursor: string | null;
+    total_count: number;
+    visible_count: number;
+}
+export declare function listCanonicalEntities(input: ListCanonicalEntitiesInput): Promise<ListCanonicalEntitiesResult>;
+//# sourceMappingURL=entity-list.d.ts.map

package/dist/entities/entity-list.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCanonicalEntities = listCanonicalEntities;
+const db_manager_js_1 = require("../db-manager.js");
+const entity_linked_decision_counts_js_1 = require("./entity-linked-decision-counts.js");
+function normalizeBrowseLabel(input) {
+    return input.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+function buildBrowseCollapseKey(row) {
+    return JSON.stringify([
+        row.kind,
+        row.scope_kind,
+        row.scope_id ?? '',
+        normalizeBrowseLabel(row.preferred_label),
+    ]);
+}
+function compareCanonicalRows(left, right) {
+    if (right.created_at !== left.created_at) {
+        return right.created_at - left.created_at;
+    }
+    const labelCompare = left.preferred_label.localeCompare(right.preferred_label);
+    if (labelCompare !== 0) {
+        return labelCompare;
+    }
+    return left.id.localeCompare(right.id);
+}
+function decodeCursor(cursor) {
+    if (!cursor) {
+        return 0;
+    }
+    try {
+        const decoded = Number(Buffer.from(cursor, 'base64').toString('utf8'));
+        return Number.isFinite(decoded) && decoded >= 0 ? decoded : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function encodeCursor(offset) {
+    return Buffer.from(String(offset), 'utf8').toString('base64');
+}
+function isNoisyCanonicalEntity(row) {
+    const label = row.preferred_label.trim().toLowerCase();
+    if (row.kind === 'person') {
+        return label === 'user' || label === 'claude';
+    }
+    if (row.kind === 'project') {
+        return label === 'workspace';
+    }
+    return false;
+}
+async function listCanonicalEntities(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT id, kind, preferred_label, scope_kind, scope_id, created_at
+        FROM entity_nodes
+        WHERE status = 'active'
+          AND merged_into IS NULL
+      `)
+        .all();
+    const sorted = rows.sort(compareCanonicalRows);
+    const collapsedByKey = new Map();
+    for (const row of sorted) {
+        const key = buildBrowseCollapseKey(row);
+        const existing = collapsedByKey.get(key);
+        if (!existing) {
+            collapsedByKey.set(key, row);
+            continue;
+        }
+        if (row.created_at > existing.created_at ||
+            (row.created_at === existing.created_at && row.id.localeCompare(existing.id) < 0)) {
+            collapsedByKey.set(key, row);
+        }
+    }
+    const collapsed = Array.from(collapsedByKey.values()).sort(compareCanonicalRows);
+    const totalCount = sorted.length;
+    const visibleBase = input.include_noisy === false
+        ? collapsed.filter((row) => !isNoisyCanonicalEntity(row))
+        : collapsed;
+    const offset = decodeCursor(input.cursor);
+    const limit = Math.max(1, input.limit);
+    const page = visibleBase.slice(offset, offset + limit);
+    const linkedCounts = (0, entity_linked_decision_counts_js_1.loadLinkedDecisionCounts)(adapter, page.map((row) => row.id));
+    const entities = page.map((row) => ({
+        ...row,
+        linked_decision_count: linkedCounts.get(row.id) ?? 0,
+    }));
+    const visibleCount = visibleBase.length;
+    const nextCursor = offset + limit < visibleBase.length ? encodeCursor(offset + limit) : null;
+    return {
+        entities,
+        next_cursor: nextCursor,
+        total_count: totalCount,
+        visible_count: visibleCount,
+    };
+}
+//# sourceMappingURL=entity-list.js.map

package/dist/entities/entity-orphan-list.d.ts

@@ -0,0 +1,26 @@
+import type { EntityNode } from './types.js';
+export interface CanonicalEntityOrphanRow {
+    entity_id: string;
+    title: string;
+    kind: EntityNode['kind'];
+    scope_kind: EntityNode['scope_kind'];
+    scope_id: string | null;
+    scope_label: string;
+    created_at: number;
+    linked_decision_count: number;
+    evidence_summary: {
+        lineage_rows: number;
+        raw_evidence_rows: number;
+        last_seen_at: number | null;
+    };
+}
+interface ReadAdapter {
+    prepare(sql: string): {
+        all: (...params: unknown[]) => unknown[];
+    };
+}
+export declare function listCanonicalEntityOrphans(adapter?: ReadAdapter, options?: {
+    min_age_ms?: number | null;
+}): CanonicalEntityOrphanRow[];
+export {};
+//# sourceMappingURL=entity-orphan-list.d.ts.map

package/dist/entities/entity-orphan-list.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCanonicalEntityOrphans = listCanonicalEntityOrphans;
+const db_manager_js_1 = require("../db-manager.js");
+const entity_linked_decision_counts_js_1 = require("./entity-linked-decision-counts.js");
+function buildScopeLabel(scopeKind, scopeId) {
+    return scopeKind ? `${scopeKind}:${scopeId ?? ''}` : 'global';
+}
+function isNoisyCanonicalEntity(row) {
+    const label = row.title.trim().toLowerCase();
+    if (row.kind === 'person') {
+        return label === 'user' || label === 'claude';
+    }
+    if (row.kind === 'project') {
+        return label === 'workspace';
+    }
+    return false;
+}
+function compareOrphanRows(left, right) {
+    const leftSeen = typeof left.evidence_summary.last_seen_at === 'number' ? left.evidence_summary.last_seen_at : 0;
+    const rightSeen = typeof right.evidence_summary.last_seen_at === 'number'
+        ? right.evidence_summary.last_seen_at
+        : 0;
+    if (rightSeen !== leftSeen) {
+        return rightSeen - leftSeen;
+    }
+    return left.entity_id.localeCompare(right.entity_id);
+}
+function listCanonicalEntityOrphans(adapter = (0, db_manager_js_1.getAdapter)(), options = {}) {
+    const minAgeMs = typeof options.min_age_ms === 'number' && Number.isFinite(options.min_age_ms)
+        ? Math.max(0, options.min_age_ms)
+        : 0;
+    const minCreatedAt = Date.now() - minAgeMs;
+    const rows = adapter
+        .prepare(`
+        SELECT
+          n.id AS entity_id,
+          n.kind AS kind,
+          n.preferred_label AS title,
+          n.scope_kind AS scope_kind,
+          n.scope_id AS scope_id,
+          n.created_at AS created_at,
+          COUNT(DISTINCT l.entity_observation_id) AS lineage_rows,
+          COUNT(
+            DISTINCT CASE
+              WHEN COALESCE(o.source_raw_record_id, '') <> '' THEN l.entity_observation_id
+              ELSE NULL
+            END
+          ) AS raw_evidence_rows,
+          MAX(COALESCE(o.timestamp_observed, o.created_at)) AS last_seen_at
+        FROM entity_nodes n
+        INNER JOIN entity_lineage_links l
+          ON l.canonical_entity_id = n.id
+         AND l.status = 'active'
+        INNER JOIN entity_observations o
+          ON o.id = l.entity_observation_id
+        WHERE n.status = 'active'
+          AND n.merged_into IS NULL
+          AND n.created_at <= ?
+        GROUP BY n.id, n.kind, n.preferred_label, n.scope_kind, n.scope_id, n.created_at
+      `)
+        .all(minCreatedAt);
+    const orphanRows = rows.map((row) => ({
+        entity_id: row.entity_id,
+        title: row.title,
+        kind: row.kind,
+        scope_kind: row.scope_kind,
+        scope_id: row.scope_id,
+        scope_label: buildScopeLabel(row.scope_kind, row.scope_id),
+        created_at: Number(row.created_at),
+        linked_decision_count: 0,
+        evidence_summary: {
+            lineage_rows: Number(row.lineage_rows ?? 0),
+            raw_evidence_rows: Number(row.raw_evidence_rows ?? 0),
+            last_seen_at: row.last_seen_at === null || row.last_seen_at === undefined
+                ? null
+                : Number(row.last_seen_at),
+        },
+    }));
+    const linkedCounts = (0, entity_linked_decision_counts_js_1.loadLinkedDecisionCounts)(adapter, orphanRows.map((row) => row.entity_id));
+    return orphanRows
+        .map((row) => ({
+        ...row,
+        linked_decision_count: linkedCounts.get(row.entity_id) ?? 0,
+    }))
+        .filter((row) => row.evidence_summary.lineage_rows > 0 &&
+        row.linked_decision_count === 0 &&
+        !isNoisyCanonicalEntity(row))
+        .sort(compareOrphanRows);
+}
+//# sourceMappingURL=entity-orphan-list.js.map

package/dist/entities/entity-search.d.ts

@@ -0,0 +1,21 @@
+import type { EntityNode } from './types.js';
+export interface SearchCanonicalEntitiesInput {
+    query: string;
+    limit: number;
+    cursor?: string | null;
+}
+export interface EntitySearchRow {
+    id: string;
+    kind: EntityNode['kind'];
+    preferred_label: string;
+    scope_kind: EntityNode['scope_kind'];
+    scope_id: string | null;
+    score: number;
+    linked_decision_count: number;
+}
+export interface SearchCanonicalEntitiesResult {
+    entities: EntitySearchRow[];
+    next_cursor: string | null;
+}
+export declare function searchCanonicalEntities(input: SearchCanonicalEntitiesInput): Promise<SearchCanonicalEntitiesResult>;
+//# sourceMappingURL=entity-search.d.ts.map

package/dist/entities/entity-search.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchCanonicalEntities = searchCanonicalEntities;
+const db_manager_js_1 = require("../db-manager.js");
+const entity_linked_decision_counts_js_1 = require("./entity-linked-decision-counts.js");
+const store_js_1 = require("./store.js");
+function normalizeSearchLabel(input) {
+    return input.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+function buildSearchCollapseKey(row) {
+    return JSON.stringify([
+        row.kind,
+        row.scope_kind,
+        row.scope_id ?? '',
+        normalizeSearchLabel(row.preferred_label),
+    ]);
+}
+function escapeLikeQuery(query) {
+    return query.replace(/[\\%_]/g, '\\$&');
+}
+function decodeCursor(cursor) {
+    if (!cursor) {
+        return 0;
+    }
+    try {
+        const decoded = Number(Buffer.from(cursor, 'base64').toString('utf8'));
+        return Number.isFinite(decoded) && decoded >= 0 ? decoded : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function encodeCursor(offset) {
+    return Buffer.from(String(offset), 'utf8').toString('base64');
+}
+async function searchCanonicalEntities(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const query = input.query.trim();
+    if (!query) {
+        return { entities: [], next_cursor: null };
+    }
+    const escaped = escapeLikeQuery(query);
+    const normalizedQuery = normalizeSearchLabel(query);
+    const rows = adapter
+        .prepare(`
+        SELECT
+          n.id AS matched_id,
+          n.preferred_label,
+          n.kind,
+          n.scope_kind,
+          n.scope_id,
+          a.label AS alias_label,
+          o.surface_form AS observation_surface_form
+        FROM entity_nodes n
+        LEFT JOIN entity_aliases a ON a.entity_id = n.id
+        LEFT JOIN entity_lineage_links l ON l.canonical_entity_id = n.id AND l.status = 'active'
+        LEFT JOIN entity_observations o ON o.id = l.entity_observation_id
+        WHERE (
+          lower(n.preferred_label) LIKE '%' || lower(?) || '%' ESCAPE '\\'
+          OR lower(COALESCE(a.label, '')) LIKE '%' || lower(?) || '%' ESCAPE '\\'
+          OR lower(COALESCE(o.surface_form, '')) LIKE '%' || lower(?) || '%' ESCAPE '\\'
+        )
+      `)
+        .all(escaped, escaped, escaped);
+    const canonicalIdByMatchedId = new Map();
+    for (const matchedId of new Set(rows.map((row) => row.matched_id))) {
+        try {
+            canonicalIdByMatchedId.set(matchedId, (0, store_js_1.resolveCanonicalEntityId)(adapter, matchedId));
+        }
+        catch (error) {
+            if (error instanceof store_js_1.EntityMergeError) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    const canonicalIds = Array.from(new Set(canonicalIdByMatchedId.values()));
+    const canonicalLookup = new Map();
+    if (canonicalIds.length > 0) {
+        const fetched = adapter
+            .prepare(`
+          SELECT id, kind, preferred_label, scope_kind, scope_id
+          FROM entity_nodes
+          WHERE id IN (${canonicalIds.map(() => '?').join(', ')})
+            AND status = 'active'
+            AND merged_into IS NULL
+        `)
+            .all(...canonicalIds);
+        for (const row of fetched) {
+            canonicalLookup.set(row.id, row);
+        }
+    }
+    const canonicalRows = new Map();
+    for (const row of rows) {
+        const canonicalId = canonicalIdByMatchedId.get(row.matched_id);
+        const canonical = canonicalId ? canonicalLookup.get(canonicalId) : undefined;
+        if (!canonical) {
+            continue;
+        }
+        const score = normalizeSearchLabel(row.preferred_label).includes(normalizedQuery)
+            ? 3
+            : row.alias_label && normalizeSearchLabel(row.alias_label).includes(normalizedQuery)
+                ? 2
+                : 1;
+        const existing = canonicalRows.get(canonical.id);
+        if (!existing || score > existing.score) {
+            canonicalRows.set(canonical.id, {
+                id: canonical.id,
+                kind: canonical.kind,
+                preferred_label: canonical.preferred_label,
+                scope_kind: canonical.scope_kind,
+                scope_id: canonical.scope_id,
+                score,
+                linked_decision_count: 0,
+            });
+        }
+    }
+    const collapsedRows = new Map();
+    for (const row of canonicalRows.values()) {
+        const key = buildSearchCollapseKey(row);
+        const existing = collapsedRows.get(key);
+        if (!existing ||
+            row.score > existing.score ||
+            (row.score === existing.score && row.id.localeCompare(existing.id) < 0)) {
+            collapsedRows.set(key, row);
+        }
+    }
+    const sorted = Array.from(collapsedRows.values()).sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        const labelCompare = left.preferred_label.localeCompare(right.preferred_label);
+        if (labelCompare !== 0) {
+            return labelCompare;
+        }
+        return left.id.localeCompare(right.id);
+    });
+    const offset = decodeCursor(input.cursor);
+    const limit = Math.max(1, input.limit);
+    const page = sorted.slice(offset, offset + limit);
+    const linkedCounts = (0, entity_linked_decision_counts_js_1.loadLinkedDecisionCounts)(adapter, page.map((row) => row.id));
+    const entities = page.map((row) => ({
+        ...row,
+        linked_decision_count: linkedCounts.get(row.id) ?? 0,
+    }));
+    const next_cursor = offset + limit < sorted.length ? encodeCursor(offset + limit) : null;
+    return { entities, next_cursor };
+}
+//# sourceMappingURL=entity-search.js.map

package/dist/entities/errors.d.ts

@@ -0,0 +1,65 @@
+export interface EntityErrorEnvelope {
+    error: {
+        code: string;
+        message: string;
+        hint: string;
+        doc_url: string;
+    };
+}
+export declare abstract class EntityError extends Error {
+    abstract readonly code: string;
+    abstract readonly doc_section: string;
+    readonly context: Record<string, unknown>;
+    readonly hint: string;
+    constructor(opts: {
+        message: string;
+        context?: Record<string, unknown>;
+        hint: string;
+    });
+    toErrorEnvelope(): EntityErrorEnvelope;
+}
+export declare class InvalidEntityLabelError extends EntityError {
+    readonly code = "entity.invalid_label";
+    readonly doc_section = "#invalid-label";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class EmbeddingUnavailableError extends EntityError {
+    readonly code = "entity.embedding_unavailable";
+    readonly doc_section = "#embedding-unavailable";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class OntologyViolationError extends EntityError {
+    readonly code = "entity.ontology_violation";
+    readonly doc_section = "#ontology-violation";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class MergeTargetStaleError extends EntityError {
+    readonly code = "entity.merge_target_stale";
+    readonly doc_section = "#merge-target-stale";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class EntityLabelMissingError extends EntityError {
+    readonly code = "entity.label_missing";
+    readonly doc_section = "#label-missing";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class CandidateStaleError extends EntityError {
+    readonly code = "entity.candidate_stale";
+    readonly doc_section = "#candidate-stale";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class AuditRunInProgressError extends EntityError {
+    readonly code = "entity.audit_run_in_progress";
+    readonly doc_section = "#audit-run-in-progress";
+    constructor(context?: Record<string, unknown>);
+}
+export declare class CaseMergeChainCycleError extends EntityError {
+    readonly code = "case.merge_chain_cycle";
+    readonly doc_section = "#case-merge-chain-cycle";
+    constructor(context: {
+        case_id: string;
+        chain: string[];
+        detected_at_depth: number;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map