@jungjaehoon/mama-core 1.6.0 → 1.7.0

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;
@@ -33,6 +34,9 @@ Object.defineProperty(exports, "getQuantized", { enumerable: true, get: function
 // 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;
@@ -46,6 +50,19 @@ function assertEmbeddingsEnabled() {
             '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)
  *
@@ -112,12 +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;
     }
@@ -126,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;
@@ -139,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) {
@@ -201,14 +221,19 @@ async function generateEnhancedEmbedding(decision) {
  * @returns Array of embeddings
  */
 async function generateBatchEmbeddings(texts) {
-    assertEmbeddingsEnabled();
     if (!Array.isArray(texts) || texts.length === 0) {
         throw new Error('Texts must be a non-empty array');
     }
-    // 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();
@@ -217,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;

package/dist/entities/store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityMergeError = void 0;
+exports.clearEntityTableColumnCache = clearEntityTableColumnCache;
 exports.parseObservationRow = parseObservationRow;
 exports.createEntityNode = createEntityNode;
 exports.getEntityNode = getEntityNode;
@@ -25,6 +26,13 @@ class EntityMergeError extends Error {
 }
 exports.EntityMergeError = EntityMergeError;
 const MAX_MERGE_CHAIN_DEPTH = 8;
+const OBSERVATION_CONTEXT_KEY_COLUMNS = [
+    'workspace_context_key',
+    'channel_context_key',
+    'thread_context_key',
+    'actor_context_key',
+];
+const tableColumnCache = new WeakMap();
 function now() {
     return Date.now();
 }
@@ -32,6 +40,58 @@ function normalizeSourceLocator(value) {
     // Write empty-string as the null sentinel so SQLite UNIQUE can collapse null-like locators; parseObservationRow maps it back to null on read.
     return value ?? '';
 }
+function normalizeContextKey(value) {
+    return value ?? '';
+}
+function sourceLocatorForInput(input) {
+    return normalizeSourceLocator(input.source_locator);
+}
+function channelContextKey(input) {
+    if (input.channel_context_key !== undefined) {
+        return normalizeContextKey(input.channel_context_key);
+    }
+    if (input.scope_kind !== 'channel' || !input.scope_id) {
+        return '';
+    }
+    return input.scope_id.startsWith(`${input.source_connector}:`)
+        ? input.scope_id
+        : `${input.source_connector}:${input.scope_id}`;
+}
+function actorContextKey(input) {
+    if (input.actor_context_key !== undefined) {
+        return normalizeContextKey(input.actor_context_key);
+    }
+    if (input.observation_type === 'author') {
+        return input.surface_form;
+    }
+    return input.related_surface_forms.find((value) => value.trim().length > 0) ?? '';
+}
+function observationContextKeys(input) {
+    return {
+        workspace_context_key: normalizeContextKey(input.workspace_context_key ?? input.source_connector),
+        channel_context_key: channelContextKey(input),
+        thread_context_key: normalizeContextKey(input.thread_context_key),
+        actor_context_key: actorContextKey(input),
+    };
+}
+function tableColumnNames(adapter, tableName) {
+    let adapterCache = tableColumnCache.get(adapter);
+    if (!adapterCache) {
+        adapterCache = new Map();
+        tableColumnCache.set(adapter, adapterCache);
+    }
+    const cached = adapterCache.get(tableName);
+    if (cached) {
+        return cached;
+    }
+    const rows = adapter.prepare(`PRAGMA table_info(${tableName})`).all();
+    const columns = new Set(rows.map((row) => row.name));
+    adapterCache.set(tableName, columns);
+    return columns;
+}
+function clearEntityTableColumnCache(adapter) {
+    tableColumnCache.delete(adapter);
+}
 function requireStringField(row, field) {
     if (typeof row[field] !== 'string' || row[field].length === 0) {
         throw new Error(`Invalid entity observation row: ${field} must be a non-empty string`);
@@ -134,6 +194,10 @@ function parseObservationRow(row) {
         source_connector: requireStringField(row, 'source_connector'),
         source_locator: sourceLocator && sourceLocator.length > 0 ? sourceLocator : null,
         source_raw_record_id: requireStringField(row, 'source_raw_record_id'),
+        workspace_context_key: optionalStringFieldIfPresent(row, 'workspace_context_key'),
+        channel_context_key: optionalStringFieldIfPresent(row, 'channel_context_key'),
+        thread_context_key: optionalStringFieldIfPresent(row, 'thread_context_key'),
+        actor_context_key: optionalStringFieldIfPresent(row, 'actor_context_key'),
         created_at: createdAt,
     };
 }
@@ -226,44 +290,152 @@ function listEntityAliases(entityId, adapter = (0, db_manager_js_1.getAdapter)()
         created_at: Number(row.created_at),
     }));
 }
-async function upsertEntityObservation(input) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
-    const createdAt = now();
-    const normalizedSourceLocator = normalizeSourceLocator(input.source_locator);
+function observationContextColumns(columns) {
+    return OBSERVATION_CONTEXT_KEY_COLUMNS.filter((column) => columns.has(column));
+}
+function observationInsertValues(input, normalizedSourceLocator, contextColumns, contextKeys, createdAt) {
+    const columns = [
+        'id',
+        'observation_type',
+        'entity_kind_hint',
+        'surface_form',
+        'normalized_form',
+        'lang',
+        'script',
+        'context_summary',
+        'related_surface_forms',
+        'timestamp_observed',
+        'scope_kind',
+        'scope_id',
+        'extractor_version',
+        'embedding_model_version',
+        'source_connector',
+        'source_locator',
+        'source_raw_record_id',
+        ...contextColumns,
+        'created_at',
+    ];
+    const values = [
+        input.id,
+        input.observation_type,
+        input.entity_kind_hint,
+        input.surface_form,
+        input.normalized_form,
+        input.lang,
+        input.script,
+        input.context_summary,
+        JSON.stringify(input.related_surface_forms),
+        input.timestamp_observed,
+        input.scope_kind,
+        input.scope_id,
+        input.extractor_version,
+        input.embedding_model_version,
+        input.source_connector,
+        normalizedSourceLocator,
+        input.source_raw_record_id,
+        ...contextColumns.map((column) => contextKeys[column]),
+        createdAt,
+    ];
+    return { columns, values };
+}
+function findExistingObservation(adapter, input, normalizedSourceLocator, contextColumns, contextKeys) {
+    const conditions = [
+        'source_connector = ?',
+        'source_locator = ?',
+        'source_raw_record_id = ?',
+        'observation_type = ?',
+        ...contextColumns.map((column) => `COALESCE(${column}, '') = ?`),
+    ];
+    const params = [
+        input.source_connector,
+        normalizedSourceLocator,
+        input.source_raw_record_id,
+        input.observation_type,
+        ...contextColumns.map((column) => contextKeys[column]),
+    ];
+    return adapter
+        .prepare(`
+        SELECT id FROM entity_observations
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY created_at ASC, id ASC
+        LIMIT 1
+      `)
+        .get(...params);
+}
+function insertObservation(adapter, input, normalizedSourceLocator, contextColumns, contextKeys, createdAt) {
+    const insert = observationInsertValues(input, normalizedSourceLocator, contextColumns, contextKeys, createdAt);
+    const placeholders = insert.columns.map(() => '?').join(', ');
     adapter
         .prepare(`
-        INSERT INTO entity_observations (
-          id, observation_type, entity_kind_hint, surface_form, normalized_form, lang, script,
-          context_summary, related_surface_forms, timestamp_observed, scope_kind, scope_id,
-          extractor_version, embedding_model_version, source_connector, source_locator,
-          source_raw_record_id, created_at
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(source_connector, source_locator, source_raw_record_id, observation_type)
-        DO UPDATE SET
-          entity_kind_hint = excluded.entity_kind_hint,
-          surface_form = excluded.surface_form,
-          normalized_form = excluded.normalized_form,
-          lang = excluded.lang,
-          script = excluded.script,
-          context_summary = excluded.context_summary,
-          related_surface_forms = excluded.related_surface_forms,
-          timestamp_observed = excluded.timestamp_observed,
-          scope_kind = excluded.scope_kind,
-          scope_id = excluded.scope_id,
-          extractor_version = excluded.extractor_version,
-          embedding_model_version = excluded.embedding_model_version,
-          source_locator = excluded.source_locator,
-          created_at = entity_observations.created_at
+        INSERT INTO entity_observations (${insert.columns.join(', ')})
+        VALUES (${placeholders})
       `)
-        .run(input.id, input.observation_type, input.entity_kind_hint, input.surface_form, input.normalized_form, input.lang, input.script, input.context_summary, JSON.stringify(input.related_surface_forms), input.timestamp_observed, input.scope_kind, input.scope_id, input.extractor_version, input.embedding_model_version, input.source_connector, normalizedSourceLocator, input.source_raw_record_id, createdAt);
-    const saved = adapter
+        .run(...insert.values);
+}
+function updateObservation(adapter, id, input, normalizedSourceLocator, contextColumns, contextKeys) {
+    const assignments = [
+        'entity_kind_hint = ?',
+        'surface_form = ?',
+        'normalized_form = ?',
+        'lang = ?',
+        'script = ?',
+        'context_summary = ?',
+        'related_surface_forms = ?',
+        'timestamp_observed = ?',
+        'scope_kind = ?',
+        'scope_id = ?',
+        'extractor_version = ?',
+        'embedding_model_version = ?',
+        'source_locator = ?',
+        ...contextColumns.map((column) => `${column} = ?`),
+    ];
+    const values = [
+        input.entity_kind_hint,
+        input.surface_form,
+        input.normalized_form,
+        input.lang,
+        input.script,
+        input.context_summary,
+        JSON.stringify(input.related_surface_forms),
+        input.timestamp_observed,
+        input.scope_kind,
+        input.scope_id,
+        input.extractor_version,
+        input.embedding_model_version,
+        normalizedSourceLocator,
+        ...contextColumns.map((column) => contextKeys[column]),
+        id,
+    ];
+    adapter
         .prepare(`
-        SELECT * FROM entity_observations
-        WHERE source_connector = ? AND source_locator = ? AND source_raw_record_id = ? AND observation_type = ?
+        UPDATE entity_observations
+        SET ${assignments.join(', ')}
+        WHERE id = ?
       `)
-        .get(input.source_connector, normalizedSourceLocator, input.source_raw_record_id, input.observation_type);
+        .run(...values);
+}
+function saveObservation(adapter, input) {
+    const columns = tableColumnNames(adapter, 'entity_observations');
+    const contextColumns = observationContextColumns(columns);
+    const contextKeys = observationContextKeys(input);
+    const normalizedSourceLocator = sourceLocatorForInput(input);
+    const existing = findExistingObservation(adapter, input, normalizedSourceLocator, contextColumns, contextKeys);
+    if (existing) {
+        const id = requireStringField(existing, 'id');
+        updateObservation(adapter, id, input, normalizedSourceLocator, contextColumns, contextKeys);
+        return { id, created: false };
+    }
+    insertObservation(adapter, input, normalizedSourceLocator, contextColumns, contextKeys, now());
+    return { id: input.id, created: true };
+}
+async function upsertEntityObservation(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const result = saveObservation(adapter, input);
+    const saved = adapter.prepare('SELECT * FROM entity_observations WHERE id = ?').get(result.id);
+    if (!saved) {
+        throw new Error(`Failed to load saved entity observation ${result.id}`);
+    }
     return parseObservationRow(saved);
 }
 async function upsertEntityObservations(inputs) {
@@ -271,51 +443,7 @@ async function upsertEntityObservations(inputs) {
     const adapter = (0, db_manager_js_1.getAdapter)();
     const observations = [];
     const upsertOne = (input) => {
-        const normalizedSourceLocator = normalizeSourceLocator(input.source_locator);
-        const existing = adapter
-            .prepare(`
-          SELECT id FROM entity_observations
-          WHERE source_connector = ? AND source_locator = ? AND source_raw_record_id = ? AND observation_type = ?
-        `)
-            .get(input.source_connector, normalizedSourceLocator, input.source_raw_record_id, input.observation_type);
-        const createdAt = now();
-        adapter
-            .prepare(`
-          INSERT INTO entity_observations (
-            id, observation_type, entity_kind_hint, surface_form, normalized_form, lang, script,
-            context_summary, related_surface_forms, timestamp_observed, scope_kind, scope_id,
-            extractor_version, embedding_model_version, source_connector, source_locator,
-            source_raw_record_id, created_at
-          )
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(source_connector, source_locator, source_raw_record_id, observation_type)
-          DO UPDATE SET
-            entity_kind_hint = excluded.entity_kind_hint,
-            surface_form = excluded.surface_form,
-            normalized_form = excluded.normalized_form,
-            lang = excluded.lang,
-            script = excluded.script,
-            context_summary = excluded.context_summary,
-            related_surface_forms = excluded.related_surface_forms,
-            timestamp_observed = excluded.timestamp_observed,
-            scope_kind = excluded.scope_kind,
-            scope_id = excluded.scope_id,
-            extractor_version = excluded.extractor_version,
-            embedding_model_version = excluded.embedding_model_version,
-            source_locator = excluded.source_locator,
-            created_at = entity_observations.created_at
-        `)
-            .run(input.id, input.observation_type, input.entity_kind_hint, input.surface_form, input.normalized_form, input.lang, input.script, input.context_summary, JSON.stringify(input.related_surface_forms), input.timestamp_observed, input.scope_kind, input.scope_id, input.extractor_version, input.embedding_model_version, input.source_connector, normalizedSourceLocator, input.source_raw_record_id, createdAt);
-        const saved = adapter
-            .prepare(`
-          SELECT * FROM entity_observations
-          WHERE source_connector = ? AND source_locator = ? AND source_raw_record_id = ? AND observation_type = ?
-        `)
-            .get(input.source_connector, normalizedSourceLocator, input.source_raw_record_id, input.observation_type);
-        observations.push({
-            id: requireStringField(saved, 'id'),
-            created: !existing,
-        });
+        observations.push(saveObservation(adapter, input));
     };
     if ('transaction' in adapter && typeof adapter.transaction === 'function') {
         const txResult = adapter.transaction(() => {

package/dist/entities/types.d.ts

@@ -12,7 +12,7 @@ export declare const ENTITY_NODE_STATUSES: readonly ["active", "merged", "archiv
 export type EntityNodeStatus = (typeof ENTITY_NODE_STATUSES)[number];
 export declare const ENTITY_ALIAS_STATUSES: readonly ["active", "suppressed"];
 export type EntityAliasStatus = (typeof ENTITY_ALIAS_STATUSES)[number];
-export declare const ENTITY_OBSERVATION_TYPES: readonly ["generic", "author", "channel"];
+export declare const ENTITY_OBSERVATION_TYPES: readonly ["generic", "author", "channel", "thread"];
 export type EntityObservationType = (typeof ENTITY_OBSERVATION_TYPES)[number];
 export declare const ENTITY_CANDIDATE_KINDS: readonly ["alias_to_entity", "entity_to_entity", "cluster"];
 export type EntityCandidateKind = (typeof ENTITY_CANDIDATE_KINDS)[number];
@@ -71,6 +71,10 @@ export interface EntityObservation {
     source_connector: string;
     source_locator: string | null;
     source_raw_record_id: string;
+    workspace_context_key?: string | null;
+    channel_context_key?: string | null;
+    thread_context_key?: string | null;
+    actor_context_key?: string | null;
     created_at: number;
 }
 export interface EntityResolutionCandidate {

package/dist/entities/types.js

@@ -14,7 +14,7 @@ exports.ENTITY_MERGE_ACTION_TYPES = ['merge', 'reject', 'defer', 'split'];
 exports.ENTITY_SCOPE_KINDS = ['project', 'channel', 'user', 'global'];
 exports.ENTITY_NODE_STATUSES = ['active', 'merged', 'archived'];
 exports.ENTITY_ALIAS_STATUSES = ['active', 'suppressed'];
-exports.ENTITY_OBSERVATION_TYPES = ['generic', 'author', 'channel'];
+exports.ENTITY_OBSERVATION_TYPES = ['generic', 'author', 'channel', 'thread'];
 exports.ENTITY_CANDIDATE_KINDS = ['alias_to_entity', 'entity_to_entity', 'cluster'];
 exports.ENTITY_ACTOR_TYPES = ['system', 'user', 'agent'];
 exports.ENTITY_INGEST_RUN_STATUSES = ['running', 'complete', 'failed'];

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export { appendToolTrace, listToolTracesForRun } from './model-runs/tool-trace-s
 export { TWIN_EDGE_SOURCES, TWIN_EDGE_TYPES, TWIN_REF_KINDS, type InsertTwinEdgeInput, type ListVisibleTwinEdgesOptions, type TwinEdgeRecord, type TwinEdgeSource, type TwinEdgeType, type TwinRef, type TwinRefKind, type TwinScopeRef, } from './edges/types.js';
 export { getTwinEdge, insertTwinEdge, listTwinEdgesForRefs, mapTwinEdgeRow, } from './edges/store.js';
 export { assertTwinRefsVisibleToScopes, listVisibleTwinEdgesForRefs, } from './edges/ref-validation.js';
+export * from './context-compile/index.js';
 export * from './agent-situation/index.js';
 export * from './agent-graph/index.js';
 export * from './entities/types.js';

package/dist/index.js

@@ -150,6 +150,7 @@ Object.defineProperty(exports, "mapTwinEdgeRow", { enumerable: true, get: functi
 var ref_validation_js_1 = require("./edges/ref-validation.js");
 Object.defineProperty(exports, "assertTwinRefsVisibleToScopes", { enumerable: true, get: function () { return ref_validation_js_1.assertTwinRefsVisibleToScopes; } });
 Object.defineProperty(exports, "listVisibleTwinEdgesForRefs", { enumerable: true, get: function () { return ref_validation_js_1.listVisibleTwinEdgesForRefs; } });
+__exportStar(require("./context-compile/index.js"), exports);
 __exportStar(require("./agent-situation/index.js"), exports);
 __exportStar(require("./agent-graph/index.js"), exports);
 __exportStar(require("./entities/types.js"), exports);

package/dist/memory/provenance.js

@@ -16,6 +16,7 @@ const ALLOWED_PROVENANCE_FIELDS = new Set([
     'envelope_hash',
     'tool_name',
     'gateway_call_id',
+    'context_packet_id',
     'source_turn_id',
     'source_message_ref',
     'source_refs',

package/dist/memory/types.d.ts

@@ -119,6 +119,7 @@ export interface MemoryWriteProvenance {
     envelope_hash?: string;
     tool_name?: string;
     gateway_call_id?: string;
+    context_packet_id?: string;
     source_turn_id?: string;
     source_message_ref?: string;
     source_refs?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,6 +49,7 @@
     "./connectors/types": "./dist/connectors/types.js",
     "./agent-situation": "./dist/agent-situation/index.js",
     "./agent-graph": "./dist/agent-graph/index.js",
+    "./context-compile": "./dist/context-compile/index.js",
     "./edges/types": "./dist/edges/types.js",
     "./edges/store": "./dist/edges/store.js",
     "./edges/ref-validation": "./dist/edges/ref-validation.js"
@@ -74,7 +75,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jungjaehoon-lifegamez/MAMA.git",
+    "url": "git+https://github.com/jungjaehoon-lifegamez/MAMA.git",
     "directory": "packages/mama-core"
   },
   "bugs": {