@jungjaehoon/mama-core 1.5.0 → 1.6.0

package/dist/edges/ref-validation.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { ListVisibleTwinEdgesOptions, TwinEdgeRecord, TwinRef, TwinScopeRef, TwinVisibility } from './types.js';
+type TwinRefVisibilityAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export declare function assertTwinRefsVisible(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], visibility?: TwinVisibility): void;
+export declare function assertTwinRefsVisibleToScopes(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], scopes?: TwinScopeRef[]): void;
+export declare function listVisibleTwinEdgesForRefs(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], options?: ListVisibleTwinEdgesOptions): TwinEdgeRecord[];
+export {};
+//# sourceMappingURL=ref-validation.d.ts.map

package/dist/edges/ref-validation.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertTwinRefsVisible = assertTwinRefsVisible;
+exports.assertTwinRefsVisibleToScopes = assertTwinRefsVisibleToScopes;
+exports.listVisibleTwinEdgesForRefs = listVisibleTwinEdgesForRefs;
+const store_js_1 = require("./store.js");
+const TABLE_COLUMN_PRAGMAS = {
+    decisions: 'PRAGMA table_info(decisions)',
+    case_truth: 'PRAGMA table_info(case_truth)',
+};
+const tableColumnCache = new WeakMap();
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function hasScopes(scopes) {
+    return Array.isArray(scopes) && scopes.length > 0;
+}
+function hasConnectors(connectors) {
+    return Array.isArray(connectors) && connectors.length > 0;
+}
+function hasProjectRefs(projectRefs) {
+    return Array.isArray(projectRefs) && projectRefs.length > 0;
+}
+function visibilityFromScopes(scopes) {
+    return { scopes: scopes ? [...scopes] : undefined };
+}
+function asOfMs(visibility) {
+    return typeof visibility.asOfMs === 'number' ? visibility.asOfMs : null;
+}
+function isAtOrBeforeAsOf(value, visibility) {
+    const asOf = asOfMs(visibility);
+    return asOf === null || (typeof value === 'number' && value <= asOf);
+}
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function tableColumns(adapter, table) {
+    const pragma = TABLE_COLUMN_PRAGMAS[table];
+    if (!pragma) {
+        throw new Error(`Unsupported table for column introspection: ${table}`);
+    }
+    let adapterCache = tableColumnCache.get(adapter);
+    if (!adapterCache) {
+        adapterCache = new Map();
+        tableColumnCache.set(adapter, adapterCache);
+    }
+    const cached = adapterCache.get(table);
+    if (cached) {
+        return cached;
+    }
+    const rows = adapter.prepare(pragma).all();
+    const columns = new Set(rows.map((row) => row.name));
+    adapterCache.set(table, columns);
+    return columns;
+}
+function isMemoryVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare(`
+        SELECT created_at, event_datetime
+        FROM decisions
+        WHERE id = ?
+        LIMIT 1
+      `)
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(row.event_datetime ?? row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const scopeClauses = scopes.map(() => '(ms.kind = ? AND ms.external_id = ?)').join(' OR ');
+    const params = scopes.flatMap((scope) => [scope.kind, scope.id]);
+    const bindingRow = adapter
+        .prepare(`
+        SELECT 1 AS ok
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id = ?
+          AND (${scopeClauses})
+        LIMIT 1
+      `)
+        .get(id, ...params);
+    if (bindingRow?.ok) {
+        return true;
+    }
+    const columns = tableColumns(adapter, 'decisions');
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        const row = adapter
+            .prepare(`
+          SELECT 1 AS ok
+          FROM decisions
+          WHERE id = ?
+            AND (${scopes.map(() => '(memory_scope_kind = ? AND memory_scope_id = ?)').join(' OR ')})
+          LIMIT 1
+        `)
+            .get(id, ...params);
+        return Boolean(row?.ok);
+    }
+    return false;
+}
+function parseCaseScopeRefs(scopeRefs) {
+    if (typeof scopeRefs !== 'string' || scopeRefs.length === 0) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(scopeRefs);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((item) => item !== null &&
+            typeof item === 'object' &&
+            typeof item.kind === 'string' &&
+            typeof item.id === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+function isCaseVisible(adapter, id, visibility) {
+    const row = adapter.prepare('SELECT * FROM case_truth WHERE case_id = ? LIMIT 1').get(id);
+    if (!row) {
+        return false;
+    }
+    const timestamp = parseTimestamp(row.last_activity_at) ?? parseTimestamp(row.updated_at);
+    if (!isAtOrBeforeAsOf(timestamp, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const requested = new Set(scopes.map(scopeKey));
+    const scopeRefs = parseCaseScopeRefs(row.scope_refs);
+    if (scopeRefs.some((scope) => requested.has(scopeKey(scope)))) {
+        return true;
+    }
+    const columns = tableColumns(adapter, 'case_truth');
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        return scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+    }
+    return false;
+}
+function isRawVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT * FROM connector_event_index WHERE event_index_id = ? LIMIT 1')
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    if (hasConnectors(visibility.connectors) &&
+        !visibility.connectors.includes(String(row.source_connector))) {
+        return false;
+    }
+    if (hasProjectRefs(visibility.projectRefs) &&
+        !visibility.projectRefs.some((project) => project.id === row.project_id)) {
+        return false;
+    }
+    if (typeof visibility.tenantId === 'string' &&
+        visibility.tenantId.length > 0 &&
+        row.tenant_id !== visibility.tenantId) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(Number(row.event_datetime ?? row.source_timestamp_ms), visibility)) {
+        return false;
+    }
+    if (!hasScopes(visibility.scopes)) {
+        return true;
+    }
+    return visibility.scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+}
+function isEntityVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT scope_kind, scope_id, created_at FROM entity_nodes WHERE id = ? AND status = ? LIMIT 1')
+        .get(id, 'active');
+    if (!row) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    return scopes.some((scope) => row.scope_kind === scope.kind && row.scope_id === scope.id);
+}
+function isTwinRefVisible(adapter, ref, visibility, visitedEdges, edgeCache) {
+    if (ref.kind === 'entity') {
+        return isEntityVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'report') {
+        return !hasScopes(visibility.scopes);
+    }
+    if (ref.kind === 'memory') {
+        return isMemoryVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'case') {
+        return isCaseVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'raw') {
+        return isRawVisible(adapter, ref.id, visibility);
+    }
+    if (visitedEdges.has(ref.id)) {
+        return false;
+    }
+    let edge = edgeCache.get(ref.id);
+    if (edge === undefined) {
+        edge = (0, store_js_1.getTwinEdge)(adapter, ref.id);
+        edgeCache.set(ref.id, edge);
+    }
+    if (!edge) {
+        return false;
+    }
+    if (!isAtOrBeforeAsOf(edge.created_at, visibility)) {
+        return false;
+    }
+    const pathWithCurrent = new Set(visitedEdges);
+    pathWithCurrent.add(ref.id);
+    return (isTwinRefVisible(adapter, edge.subject_ref, visibility, new Set(pathWithCurrent), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, visibility, new Set(pathWithCurrent), edgeCache));
+}
+function assertTwinRefsVisible(adapter, refs, visibility = {}) {
+    const edgeCache = new Map();
+    for (const ref of refs) {
+        if (!isTwinRefVisible(adapter, ref, visibility, new Set(), edgeCache)) {
+            throw new Error(`Twin ref is not visible to requested visibility: ${ref.kind}:${ref.id}`);
+        }
+    }
+}
+function assertTwinRefsVisibleToScopes(adapter, refs, scopes) {
+    assertTwinRefsVisible(adapter, refs, visibilityFromScopes(scopes));
+}
+function listVisibleTwinEdgesForRefs(adapter, refs, options = {}) {
+    const edgeCache = new Map();
+    const edgeTypes = normalizeEdgeTypes(options.edgeTypes);
+    const edges = (0, store_js_1.listTwinEdgesForRefs)(adapter, refs).filter((edge) => (edgeTypes.size === 0 || edgeTypes.has(edge.edge_type)) &&
+        (typeof options.asOfMs !== 'number' || edge.created_at <= options.asOfMs) &&
+        isTwinRefVisible(adapter, edge.subject_ref, options, new Set(), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, options, new Set(), edgeCache));
+    const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+        ? Math.max(0, Math.floor(options.limit))
+        : edges.length;
+    return edges.slice(0, limit);
+}
+function normalizeEdgeTypes(edgeTypes) {
+    if (!Array.isArray(edgeTypes) || edgeTypes.length === 0) {
+        return new Set();
+    }
+    return new Set(edgeTypes);
+}
+//# sourceMappingURL=ref-validation.js.map

package/dist/edges/store.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { type InsertTwinEdgeInput, type TwinEdgeRecord, type TwinRef } from './types.js';
+type TwinEdgeReadAdapter = Pick<DatabaseAdapter, 'prepare'>;
+type TwinEdgeAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export declare function mapTwinEdgeRow(row: Record<string, unknown>): TwinEdgeRecord;
+export declare function getTwinEdge(adapter: TwinEdgeReadAdapter, edgeId: string): TwinEdgeRecord | null;
+export declare function listTwinEdgesForRefs(adapter: TwinEdgeReadAdapter, refs: readonly TwinRef[]): TwinEdgeRecord[];
+export declare function insertTwinEdge(adapter: TwinEdgeAdapter, input: InsertTwinEdgeInput): TwinEdgeRecord;
+export {};
+//# sourceMappingURL=store.d.ts.map

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