@jungjaehoon/mama-core 1.4.1 → 1.5.0

package/dist/entities/normalization.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectScript = detectScript;
+exports.normalizeEntityLabel = normalizeEntityLabel;
+exports.extractStructuredIdentifiers = extractStructuredIdentifiers;
+const errors_js_1 = require("./errors.js");
+const LATIN_RE = /\p{Script=Latin}/u;
+const HANGUL_RE = /\p{Script=Hangul}/u;
+const HIRAGANA_RE = /\p{Script=Hiragana}/u;
+const KATAKANA_RE = /\p{Script=Katakana}/u;
+const HAN_RE = /\p{Script=Han}/u;
+function collapseWhitespace(input) {
+    return input.normalize('NFKC').trim().replace(/\s+/gu, ' ');
+}
+function detectScript(input) {
+    const hasLatin = LATIN_RE.test(input);
+    const hasHangul = HANGUL_RE.test(input);
+    const hasJapanese = HIRAGANA_RE.test(input) || KATAKANA_RE.test(input) || HAN_RE.test(input);
+    const activeScripts = [hasLatin, hasHangul, hasJapanese].filter(Boolean).length;
+    if (activeScripts > 1) {
+        return 'Mixed';
+    }
+    if (hasHangul) {
+        return 'Hang';
+    }
+    if (hasJapanese) {
+        return 'Jpan';
+    }
+    if (hasLatin) {
+        return 'Latn';
+    }
+    return 'Unknown';
+}
+function normalizeEntityLabel(input) {
+    if (typeof input !== 'string' || input.trim().length === 0) {
+        throw new errors_js_1.InvalidEntityLabelError({
+            input,
+            reason: typeof input === 'string' ? 'empty_string' : 'non_string_input',
+        });
+    }
+    const original = input;
+    const collapsed = collapseWhitespace(input);
+    const script = detectScript(collapsed);
+    const normalized = script === 'Latn' ? collapsed.toLowerCase() : collapsed;
+    return {
+        original,
+        normalized,
+        script,
+    };
+}
+function extractStructuredIdentifiers(input) {
+    const emails = Array.from(new Set((input.match(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/giu) ?? []).map((v) => v.toLowerCase())));
+    const handles = Array.from(new Set((input.match(/(?<!\w)@([a-z0-9_][a-z0-9_.-]*)/giu) ?? []).map((v) => v.slice(1).toLowerCase())));
+    const domains = Array.from(new Set((input.match(/\b(?:[a-z0-9-]+\.)+[a-z]{2,}\b/giu) ?? [])
+        .map((v) => v.toLowerCase())
+        .filter((v) => !emails.some((email) => email.endsWith(`@${v}`)))));
+    return {
+        emails,
+        handles,
+        domains,
+    };
+}
+//# sourceMappingURL=normalization.js.map

package/dist/entities/policy-store.d.ts

@@ -0,0 +1,17 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { createDefaultEntityPolicyBootstrap, type EntityPolicyApprovalInput, type EntityPolicyBootstrapDocument, type EntityPolicyKind, type EntityPolicyProposalInput, type EntityPolicyProposalRow, type EntityPolicyRow, type EntityRole, type EntityRoleBinding, type EntityRoleBindingInput } from './policy-types.js';
+type PolicyStoreAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export declare function ensureEntityPolicyBootstrap(args: {
+    bootstrapPath: string;
+    now?: () => number;
+}): Promise<void>;
+export declare function listEntityPolicies(adapter?: PolicyStoreAdapter): EntityPolicyRow[];
+export declare function getEntityPolicy(policyKey: string, adapter?: PolicyStoreAdapter): EntityPolicyRow | null;
+export declare function listEntityRoleBindings(adapter?: PolicyStoreAdapter): EntityRoleBinding[];
+export declare function upsertEntityRoleBinding(input: EntityRoleBindingInput, adapter?: PolicyStoreAdapter): void;
+export declare function resolveEntityRoleForActor(actorId: string, adapter?: PolicyStoreAdapter): EntityRole;
+export declare function createEntityPolicyProposal(input: EntityPolicyProposalInput, adapter?: PolicyStoreAdapter): string;
+export declare function getEntityPolicyProposal(proposalId: string, adapter?: PolicyStoreAdapter): EntityPolicyProposalRow | null;
+export declare function approveEntityPolicyProposal(input: EntityPolicyApprovalInput, adapter?: PolicyStoreAdapter): EntityPolicyProposalRow;
+export { createDefaultEntityPolicyBootstrap, type EntityPolicyApprovalInput, type EntityPolicyBootstrapDocument, type EntityPolicyKind, type EntityPolicyProposalInput, type EntityPolicyProposalRow, type EntityPolicyRow, type EntityRole, type EntityRoleBinding, type EntityRoleBindingInput, };
+//# sourceMappingURL=policy-store.d.ts.map

package/dist/entities/policy-store.js

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultEntityPolicyBootstrap = void 0;
+exports.ensureEntityPolicyBootstrap = ensureEntityPolicyBootstrap;
+exports.listEntityPolicies = listEntityPolicies;
+exports.getEntityPolicy = getEntityPolicy;
+exports.listEntityRoleBindings = listEntityRoleBindings;
+exports.upsertEntityRoleBinding = upsertEntityRoleBinding;
+exports.resolveEntityRoleForActor = resolveEntityRoleForActor;
+exports.createEntityPolicyProposal = createEntityPolicyProposal;
+exports.getEntityPolicyProposal = getEntityPolicyProposal;
+exports.approveEntityPolicyProposal = approveEntityPolicyProposal;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const db_manager_js_1 = require("../db-manager.js");
+const policy_types_js_1 = require("./policy-types.js");
+Object.defineProperty(exports, "createDefaultEntityPolicyBootstrap", { enumerable: true, get: function () { return policy_types_js_1.createDefaultEntityPolicyBootstrap; } });
+function now() {
+    return Date.now();
+}
+function parseJsonObject(raw, label) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${label} must be a JSON object`);
+    }
+    return parsed;
+}
+function parsePolicyRow(row) {
+    const policyKind = String(row.policy_kind);
+    if (!(0, policy_types_js_1.isEntityPolicyKind)(policyKind)) {
+        throw new Error(`Invalid entity policy row: policy_kind=${policyKind}`);
+    }
+    const valueJson = String(row.value_json);
+    return {
+        policy_key: String(row.policy_key),
+        policy_kind: policyKind,
+        value_json: valueJson,
+        value: parseJsonObject(valueJson, 'entity_policy.value_json'),
+        version: Number(row.version),
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+    };
+}
+function parseRoleBindingRow(row) {
+    const role = String(row.role);
+    if (!(0, policy_types_js_1.isEntityRole)(role)) {
+        throw new Error(`Invalid entity role binding row: role=${role}`);
+    }
+    return {
+        actor_id: String(row.actor_id),
+        role,
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+    };
+}
+function parseProposalRow(row) {
+    const policyKind = String(row.policy_kind);
+    if (!(0, policy_types_js_1.isEntityPolicyKind)(policyKind)) {
+        throw new Error(`Invalid entity policy proposal row: policy_kind=${policyKind}`);
+    }
+    const status = String(row.status);
+    if (!(0, policy_types_js_1.isEntityPolicyProposalStatus)(status)) {
+        throw new Error(`Invalid entity policy proposal row: status=${status}`);
+    }
+    const proposedValueJson = String(row.proposed_value_json);
+    return {
+        proposal_id: String(row.proposal_id),
+        policy_key: String(row.policy_key),
+        policy_kind: policyKind,
+        proposed_value_json: proposedValueJson,
+        proposed_value: parseJsonObject(proposedValueJson, 'entity_policy_proposals.proposed_value_json'),
+        proposer_actor: String(row.proposer_actor),
+        approver_actor: typeof row.approver_actor === 'string' ? row.approver_actor : null,
+        reason: String(row.reason),
+        status,
+        created_at: Number(row.created_at),
+        approved_at: typeof row.approved_at === 'number' ? row.approved_at : null,
+    };
+}
+function readBootstrapDocument(bootstrapPath) {
+    const raw = node_fs_1.default.readFileSync(bootstrapPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error('Entity policy bootstrap must be a JSON object');
+    }
+    if (typeof parsed.version !== 'number') {
+        throw new Error('Entity policy bootstrap must include numeric version');
+    }
+    if (!Array.isArray(parsed.policies)) {
+        throw new Error('Entity policy bootstrap must include policies[]');
+    }
+    if (!Array.isArray(parsed.role_bindings)) {
+        throw new Error('Entity policy bootstrap must include role_bindings[]');
+    }
+    for (const policy of parsed.policies) {
+        if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+            throw new Error('Entity policy bootstrap policies must be objects');
+        }
+        if (typeof policy.policy_key !== 'string' ||
+            typeof policy.policy_kind !== 'string' ||
+            !(0, policy_types_js_1.isEntityPolicyKind)(policy.policy_kind) ||
+            !policy.value ||
+            typeof policy.value !== 'object' ||
+            Array.isArray(policy.value)) {
+            throw new Error('Entity policy bootstrap policy rows are invalid');
+        }
+    }
+    for (const binding of parsed.role_bindings) {
+        if (!binding || typeof binding !== 'object' || Array.isArray(binding)) {
+            throw new Error('Entity policy bootstrap role_bindings must be objects');
+        }
+        if (typeof binding.actor_id !== 'string' ||
+            typeof binding.role !== 'string' ||
+            !(0, policy_types_js_1.isEntityRole)(binding.role)) {
+            throw new Error('Entity policy bootstrap role binding rows are invalid');
+        }
+    }
+    return parsed;
+}
+function countRows(tableName, adapter) {
+    const row = adapter.prepare(`SELECT COUNT(*) AS total FROM ${tableName}`).get();
+    return Number(row.total ?? 0);
+}
+async function ensureEntityPolicyBootstrap(args) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const document = readBootstrapDocument(args.bootstrapPath);
+    const timestamp = args.now?.() ?? now();
+    adapter.transaction(() => {
+        const policyCount = countRows('entity_policy', adapter);
+        const roleBindingCount = countRows('entity_role_bindings', adapter);
+        if ((policyCount === 0) !== (roleBindingCount === 0)) {
+            throw new Error('Entity policy bootstrap tables are out of sync: entity_policy and entity_role_bindings must be seeded together.');
+        }
+        if (policyCount === 0 && roleBindingCount === 0) {
+            for (const policy of document.policies) {
+                adapter
+                    .prepare(`
+              INSERT INTO entity_policy (
+                policy_key, policy_kind, value_json, version, created_at, updated_at
+              ) VALUES (?, ?, ?, 1, ?, ?)
+            `)
+                    .run(policy.policy_key, policy.policy_kind, JSON.stringify(policy.value), timestamp, timestamp);
+            }
+            for (const binding of document.role_bindings) {
+                adapter
+                    .prepare(`
+              INSERT INTO entity_role_bindings (
+                actor_id, role, created_at, updated_at
+              ) VALUES (?, ?, ?, ?)
+            `)
+                    .run(binding.actor_id, binding.role, timestamp, timestamp);
+            }
+        }
+    });
+}
+function listEntityPolicies(adapter = (0, db_manager_js_1.getAdapter)()) {
+    const rows = adapter
+        .prepare('SELECT * FROM entity_policy ORDER BY policy_key ASC')
+        .all();
+    return rows.map(parsePolicyRow);
+}
+function getEntityPolicy(policyKey, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const row = adapter
+        .prepare('SELECT * FROM entity_policy WHERE policy_key = ? LIMIT 1')
+        .get(policyKey);
+    return row ? parsePolicyRow(row) : null;
+}
+function listEntityRoleBindings(adapter = (0, db_manager_js_1.getAdapter)()) {
+    const rows = adapter
+        .prepare('SELECT * FROM entity_role_bindings ORDER BY actor_id ASC')
+        .all();
+    return rows.map(parseRoleBindingRow);
+}
+function upsertEntityRoleBinding(input, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const timestamp = now();
+    adapter
+        .prepare(`
+        INSERT INTO entity_role_bindings (
+          actor_id, role, created_at, updated_at
+        ) VALUES (?, ?, ?, ?)
+        ON CONFLICT(actor_id) DO UPDATE SET
+          role = excluded.role,
+          updated_at = excluded.updated_at
+      `)
+        .run(input.actor_id, input.role, timestamp, timestamp);
+}
+function resolveEntityRoleForActor(actorId, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const row = adapter
+        .prepare('SELECT role FROM entity_role_bindings WHERE actor_id = ? LIMIT 1')
+        .get(actorId);
+    return row?.role && (0, policy_types_js_1.isEntityRole)(row.role) ? row.role : 'viewer';
+}
+function createEntityPolicyProposal(input, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const proposalId = input.proposal_id ?? `epol_${(0, node_crypto_1.randomUUID)()}`;
+    const createdAt = input.created_at ?? now();
+    adapter
+        .prepare(`
+        INSERT INTO entity_policy_proposals (
+          proposal_id, policy_key, policy_kind, proposed_value_json, proposer_actor,
+          approver_actor, reason, status, created_at, approved_at
+        ) VALUES (?, ?, ?, ?, ?, NULL, ?, 'pending', ?, NULL)
+      `)
+        .run(proposalId, input.policy_key, input.policy_kind, JSON.stringify(input.proposed_value), input.proposer_actor, input.reason, createdAt);
+    return proposalId;
+}
+function getEntityPolicyProposal(proposalId, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const row = adapter
+        .prepare('SELECT * FROM entity_policy_proposals WHERE proposal_id = ? LIMIT 1')
+        .get(proposalId);
+    return row ? parseProposalRow(row) : null;
+}
+function approveEntityPolicyProposal(input, adapter = (0, db_manager_js_1.getAdapter)()) {
+    const approvedAt = input.approved_at ?? now();
+    return adapter.transaction(() => {
+        const proposal = getEntityPolicyProposal(input.proposal_id, adapter);
+        if (!proposal) {
+            throw new Error(`Entity policy proposal not found: ${input.proposal_id}`);
+        }
+        if (proposal.status !== 'pending') {
+            throw new Error(`Entity policy proposal is not pending: ${input.proposal_id}`);
+        }
+        if (proposal.proposer_actor === input.approver_actor) {
+            throw new Error('Entity policy proposal requires a different approver');
+        }
+        const approverRole = resolveEntityRoleForActor(input.approver_actor, adapter);
+        if (approverRole !== 'admin') {
+            throw new Error('Entity policy proposal approval requires an admin approver');
+        }
+        const existingPolicy = getEntityPolicy(proposal.policy_key, adapter);
+        const version = existingPolicy ? existingPolicy.version + 1 : 1;
+        adapter
+            .prepare(`
+          INSERT INTO entity_policy (
+            policy_key, policy_kind, value_json, version, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(policy_key) DO UPDATE SET
+            policy_kind = excluded.policy_kind,
+            value_json = excluded.value_json,
+            version = excluded.version,
+            updated_at = excluded.updated_at
+        `)
+            .run(proposal.policy_key, proposal.policy_kind, proposal.proposed_value_json, version, approvedAt, approvedAt);
+        adapter
+            .prepare(`
+          UPDATE entity_policy_proposals
+          SET approver_actor = ?,
+              status = 'approved',
+              approved_at = ?
+          WHERE proposal_id = ?
+        `)
+            .run(input.approver_actor, approvedAt, input.proposal_id);
+        const approved = getEntityPolicyProposal(input.proposal_id, adapter);
+        if (!approved) {
+            throw new Error(`Failed to reload approved entity policy proposal: ${input.proposal_id}`);
+        }
+        return approved;
+    });
+}
+//# sourceMappingURL=policy-store.js.map

package/dist/entities/policy-types.d.ts

@@ -0,0 +1,72 @@
+export declare const ENTITY_POLICY_ROLES: readonly ["viewer", "operator", "admin"];
+export type EntityRole = (typeof ENTITY_POLICY_ROLES)[number];
+export declare const ENTITY_POLICY_KINDS: readonly ["entity_kind", "merge_guardrails", "review_thresholds", "connector_policy"];
+export type EntityPolicyKind = (typeof ENTITY_POLICY_KINDS)[number];
+export declare const ENTITY_POLICY_PROPOSAL_STATUSES: readonly ["pending", "approved", "rejected"];
+export type EntityPolicyProposalStatus = (typeof ENTITY_POLICY_PROPOSAL_STATUSES)[number];
+export interface EntityPolicyRow {
+    policy_key: string;
+    policy_kind: EntityPolicyKind;
+    value_json: string;
+    value: Record<string, unknown>;
+    version: number;
+    created_at: number;
+    updated_at: number;
+}
+export interface EntityRoleBinding {
+    actor_id: string;
+    role: EntityRole;
+    created_at: number;
+    updated_at: number;
+}
+export interface EntityRoleBindingInput {
+    actor_id: string;
+    role: EntityRole;
+}
+export interface EntityPolicyProposalRow {
+    proposal_id: string;
+    policy_key: string;
+    policy_kind: EntityPolicyKind;
+    proposed_value_json: string;
+    proposed_value: Record<string, unknown>;
+    proposer_actor: string;
+    approver_actor: string | null;
+    reason: string;
+    status: EntityPolicyProposalStatus;
+    created_at: number;
+    approved_at: number | null;
+}
+export interface EntityPolicyProposalInput {
+    policy_key: string;
+    policy_kind: EntityPolicyKind;
+    proposed_value: Record<string, unknown>;
+    proposer_actor: string;
+    reason: string;
+    proposal_id?: string;
+    created_at?: number;
+}
+export interface EntityPolicyApprovalInput {
+    proposal_id: string;
+    approver_actor: string;
+    approved_at?: number;
+}
+export interface EntityPolicyBootstrapPolicy {
+    policy_key: string;
+    policy_kind: EntityPolicyKind;
+    value: Record<string, unknown>;
+}
+export interface EntityPolicyBootstrapRoleBinding {
+    actor_id: string;
+    role: EntityRole;
+}
+export interface EntityPolicyBootstrapDocument {
+    version: number;
+    policies: EntityPolicyBootstrapPolicy[];
+    role_bindings: EntityPolicyBootstrapRoleBinding[];
+}
+export declare const ENTITY_ROLE_ORDER: Record<EntityRole, number>;
+export declare function isEntityRole(value: string): value is EntityRole;
+export declare function isEntityPolicyKind(value: string): value is EntityPolicyKind;
+export declare function isEntityPolicyProposalStatus(value: string): value is EntityPolicyProposalStatus;
+export declare function createDefaultEntityPolicyBootstrap(adminActor?: string): EntityPolicyBootstrapDocument;
+//# sourceMappingURL=policy-types.d.ts.map

package/dist/entities/policy-types.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_ROLE_ORDER = exports.ENTITY_POLICY_PROPOSAL_STATUSES = exports.ENTITY_POLICY_KINDS = exports.ENTITY_POLICY_ROLES = void 0;
+exports.isEntityRole = isEntityRole;
+exports.isEntityPolicyKind = isEntityPolicyKind;
+exports.isEntityPolicyProposalStatus = isEntityPolicyProposalStatus;
+exports.createDefaultEntityPolicyBootstrap = createDefaultEntityPolicyBootstrap;
+exports.ENTITY_POLICY_ROLES = ['viewer', 'operator', 'admin'];
+exports.ENTITY_POLICY_KINDS = [
+    'entity_kind',
+    'merge_guardrails',
+    'review_thresholds',
+    'connector_policy',
+];
+exports.ENTITY_POLICY_PROPOSAL_STATUSES = ['pending', 'approved', 'rejected'];
+exports.ENTITY_ROLE_ORDER = {
+    viewer: 0,
+    operator: 1,
+    admin: 2,
+};
+function isEntityRole(value) {
+    return exports.ENTITY_POLICY_ROLES.includes(value);
+}
+function isEntityPolicyKind(value) {
+    return exports.ENTITY_POLICY_KINDS.includes(value);
+}
+function isEntityPolicyProposalStatus(value) {
+    return exports.ENTITY_POLICY_PROPOSAL_STATUSES.includes(value);
+}
+function createDefaultEntityPolicyBootstrap(adminActor = 'local:viewer') {
+    return {
+        version: 1,
+        policies: [
+            {
+                policy_key: 'merge_guardrails.default',
+                policy_kind: 'merge_guardrails',
+                value: {
+                    max_false_merge_rate: 0.02,
+                    require_review_for_cross_scope: true,
+                },
+            },
+            {
+                policy_key: 'review_thresholds.default',
+                policy_kind: 'review_thresholds',
+                value: {
+                    approve_score_min: 0.92,
+                    defer_score_min: 0.78,
+                },
+            },
+        ],
+        role_bindings: [
+            {
+                actor_id: adminActor,
+                role: 'admin',
+            },
+        ],
+    };
+}
+//# sourceMappingURL=policy-types.js.map

package/dist/entities/projection.d.ts

@@ -0,0 +1,8 @@
+import type { EntityAlias, EntityNode, EntityTimelineEvent } from './types.js';
+import type { MemoryRecord } from '../memory/types.js';
+interface ProjectionOptions {
+    nodeLookup?: Record<string, EntityNode>;
+}
+export declare function projectEntityToRecallSummary(node: EntityNode, aliases: EntityAlias[], latestEvent: EntityTimelineEvent | null, options?: ProjectionOptions): MemoryRecord;
+export {};
+//# sourceMappingURL=projection.d.ts.map

package/dist/entities/projection.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectEntityToRecallSummary = projectEntityToRecallSummary;
+const errors_js_1 = require("./errors.js");
+function formatTimelineEventForRecall(latestEvent) {
+    if (!latestEvent) {
+        return null;
+    }
+    const parts = [];
+    const eventType = latestEvent.event_type.trim();
+    const summary = latestEvent.summary.trim();
+    const details = latestEvent.details?.trim() ?? '';
+    if (eventType.length > 0) {
+        parts.push(eventType);
+    }
+    if (summary.length > 0) {
+        parts.push(summary);
+    }
+    if (details.length > 0 && details !== summary) {
+        try {
+            const parsed = JSON.parse(details);
+            if (parsed && typeof parsed === 'object') {
+                parts.push(JSON.stringify(parsed));
+            }
+            else {
+                parts.push(details);
+            }
+        }
+        catch {
+            parts.push(details);
+        }
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+function assertNoCircularMerge(node, options) {
+    if (!options?.nodeLookup) {
+        return;
+    }
+    const seen = new Set();
+    let current = options.nodeLookup[node.id] ?? node;
+    while (current?.merged_into) {
+        if (seen.has(current.id)) {
+            throw new errors_js_1.EntityLabelMissingError({
+                entity_id: node.id,
+                reason: 'circular_merged_into_chain',
+            });
+        }
+        seen.add(current.id);
+        current = options.nodeLookup[current.merged_into];
+    }
+}
+function projectEntityToRecallSummary(node, aliases, latestEvent, options) {
+    if (!node.preferred_label.trim()) {
+        throw new errors_js_1.EntityLabelMissingError({
+            entity_id: node.id,
+            reason: 'missing_preferred_label',
+        });
+    }
+    assertNoCircularMerge(node, options);
+    const aliasText = aliases.map((alias) => alias.label).join(', ');
+    const detailParts = [formatTimelineEventForRecall(latestEvent), aliasText].filter((value) => Boolean(value));
+    const scopeKind = node.scope_kind ?? 'global';
+    const scopeId = node.scope_kind === null ? 'global' : (node.scope_id ?? 'global');
+    return {
+        id: node.id,
+        topic: `entity/${node.id}`,
+        kind: 'fact',
+        summary: node.preferred_label,
+        details: detailParts.join('\n'),
+        confidence: 0.9,
+        status: 'active',
+        scopes: [{ kind: scopeKind, id: scopeId }],
+        source: {
+            package: 'mama-core',
+            source_type: 'entity_canonical',
+            project_id: node.scope_id ?? undefined,
+        },
+        created_at: node.created_at,
+        updated_at: node.updated_at,
+    };
+}
+//# sourceMappingURL=projection.js.map

package/dist/entities/provenance-query.d.ts

@@ -0,0 +1,33 @@
+import { type SourceLocatorKind } from './source-locator.js';
+import type { MemoryRecord } from '../memory/types.js';
+export interface ProvenanceObservationSummary {
+    id: string;
+    observation_type: string;
+    entity_kind_hint: string | null;
+    surface_form: string;
+    normalized_form: string;
+    lang: string | null;
+    script: string | null;
+    context_summary: string | null;
+    scope_kind: string;
+    scope_id: string | null;
+    extractor_version: string;
+    embedding_model_version: string | null;
+    source_connector: string;
+    source_locator: string | null;
+    source_locator_kind: SourceLocatorKind;
+    source_raw_record_id: string;
+    created_at: number;
+}
+export interface MemoryProvenanceResult {
+    status: 'legacy' | 'manual' | 'dropped' | 'resolved';
+    memory: MemoryRecord;
+    observations: ProvenanceObservationSummary[];
+    audit: {
+        event_type: 'provenance.empty_batch' | 'provenance.link_write_failed';
+        reason: string | null;
+        created_at: number;
+    } | null;
+}
+export declare function queryProvenanceForMemory(memoryId: string): Promise<MemoryProvenanceResult>;
+//# sourceMappingURL=provenance-query.d.ts.map