@jungjaehoon/mama-core 1.5.0 → 1.7.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,88 @@
+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;
+    startMs?: number | 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[];
+    startMs?: number | null;
+    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/embeddings.d.ts

@@ -11,6 +11,9 @@
  */
 import { embeddingCache } from './embedding-cache.js';
 import { loadConfig, getModelName, getEmbeddingDim, getQuantized } from './config-loader.js';
+export declare const EMBEDDING_MODEL_MAX_LENGTH = 512;
+export declare const EMBEDDING_MAX_TOKENISH_SEGMENTS = 480;
+export declare function prepareEmbeddingText(text: string): string;
 /**
  * Decision object for enhanced embedding generation
  */

package/dist/embeddings.js

@@ -14,7 +14,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getQuantized = exports.getEmbeddingDim = exports.getModelName = exports.loadConfig = exports.MODEL_NAME = exports.EMBEDDING_DIM = exports.embeddingCache = void 0;
+exports.getQuantized = exports.getEmbeddingDim = exports.getModelName = exports.loadConfig = exports.MODEL_NAME = exports.EMBEDDING_DIM = exports.embeddingCache = exports.EMBEDDING_MAX_TOKENISH_SEGMENTS = exports.EMBEDDING_MODEL_MAX_LENGTH = void 0;
+exports.prepareEmbeddingText = prepareEmbeddingText;
 exports.generateEmbedding = generateEmbedding;
 exports.generateEnhancedEmbedding = generateEnhancedEmbedding;
 exports.generateBatchEmbeddings = generateBatchEmbeddings;
@@ -32,10 +33,36 @@ 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']);
+exports.EMBEDDING_MODEL_MAX_LENGTH = 512;
+exports.EMBEDDING_MAX_TOKENISH_SEGMENTS = 480;
+const TOKENISH_SEGMENT_PATTERN = /[\p{Script=Hangul}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]|\S+/gu;
 // 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.');
+    }
+}
+function prepareEmbeddingText(text) {
+    const trimmed = text.trim();
+    let count = 0;
+    let cutIndex = trimmed.length;
+    for (const match of trimmed.matchAll(TOKENISH_SEGMENT_PATTERN)) {
+        count++;
+        if (count > exports.EMBEDDING_MAX_TOKENISH_SEGMENTS) {
+            cutIndex = match.index ?? trimmed.length;
+            break;
+        }
+    }
+    return cutIndex === trimmed.length ? trimmed : trimmed.slice(0, cutIndex).trimEnd();
+}
 /**
  * Load embedding model (configurable)
  *
@@ -45,6 +72,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) {
@@ -101,11 +129,13 @@ async function loadModel() {
  * @throws Error if text is empty or embedding fails
  */
 async function generateEmbedding(text) {
-    if (!text || text.trim().length === 0) {
+    if (typeof text !== 'string' || text.trim().length === 0) {
         throw new Error('Text cannot be empty');
     }
+    assertEmbeddingsEnabled();
+    const preparedText = prepareEmbeddingText(text);
     // Task 2: Check cache first (AC #3)
-    const cached = embedding_cache_js_1.embeddingCache.get(text);
+    const cached = embedding_cache_js_1.embeddingCache.get(preparedText);
     if (cached) {
         return cached;
     }
@@ -114,9 +144,11 @@ async function generateEmbedding(text) {
         const model = await loadModel();
         const expectedDim = (0, config_loader_js_1.getEmbeddingDim)();
         // Generate embedding
-        const output = await model(text, {
+        const output = await model(preparedText, {
             pooling: 'mean', // Mean pooling over tokens
             normalize: true, // L2 normalization
+            truncation: true,
+            max_length: exports.EMBEDDING_MODEL_MAX_LENGTH,
         });
         // Extract Float32Array
         const embedding = output.data;
@@ -127,7 +159,7 @@ async function generateEmbedding(text) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const _latency = Date.now() - startTime;
         // Task 2: Store in cache (AC #3)
-        embedding_cache_js_1.embeddingCache.set(text, embedding);
+        embedding_cache_js_1.embeddingCache.set(preparedText, embedding);
         return embedding;
     }
     catch (error) {
@@ -192,10 +224,16 @@ async function generateBatchEmbeddings(texts) {
     if (!Array.isArray(texts) || texts.length === 0) {
         throw new Error('Texts must be a non-empty array');
     }
-    // Validate all texts
     for (const text of texts) {
-        if (!text || text.trim().length === 0) {
-            throw new Error('All texts must be non-empty');
+        if (typeof text !== 'string' || text.trim().length === 0) {
+            throw new Error('All texts must be non-empty strings');
+        }
+    }
+    assertEmbeddingsEnabled();
+    const preparedTexts = texts.map((text) => prepareEmbeddingText(text));
+    for (const text of preparedTexts) {
+        if (!text || text.length === 0) {
+            throw new Error('All texts must be non-empty strings');
         }
     }
     const startTime = Date.now();
@@ -204,9 +242,11 @@ async function generateBatchEmbeddings(texts) {
         const expectedDim = (0, config_loader_js_1.getEmbeddingDim)();
         // Native batch processing - single model forward pass
         // This is significantly faster than sequential calls
-        const outputs = await model(texts, {
+        const outputs = await model(preparedTexts, {
             pooling: 'mean',
             normalize: true,
+            truncation: true,
+            max_length: exports.EMBEDDING_MODEL_MAX_LENGTH,
         });
         // Extract embeddings from batch output
         const embeddings = [];

package/dist/entities/store.d.ts

@@ -13,9 +13,11 @@ export declare class EntityMergeError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
 }
+declare const OBSERVATION_CONTEXT_KEY_COLUMNS: readonly ["workspace_context_key", "channel_context_key", "thread_context_key", "actor_context_key"];
 type CreateEntityNodeInput = Omit<EntityNode, 'created_at' | 'updated_at'>;
 type AttachEntityAliasInput = Omit<EntityAlias, 'created_at'>;
-type UpsertEntityObservationInput = Omit<EntityObservation, 'created_at'>;
+type ObservationContextKeyColumn = (typeof OBSERVATION_CONTEXT_KEY_COLUMNS)[number];
+type UpsertEntityObservationInput = Omit<EntityObservation, 'created_at'> & Partial<Record<ObservationContextKeyColumn, string | null>>;
 type AppendEntityTimelineEventInput = {
     event: Omit<EntityTimelineEvent, 'id' | 'created_at'> & {
         id?: string;
@@ -27,6 +29,7 @@ export interface UpsertEntityObservationResult {
     id: string;
     created: boolean;
 }
+export declare function clearEntityTableColumnCache(adapter: EntityStoreAdapter): void;
 export declare function parseObservationRow(row: Record<string, unknown>): EntityObservation;
 export declare function createEntityNode(input: CreateEntityNodeInput): Promise<EntityNode>;
 export declare function getEntityNode(id: string, adapter?: EntityStoreAdapter): EntityNode | null;