@jungjaehoon/mama-core 1.5.0 → 1.7.0

package/dist/context-compile/types.d.ts

@@ -0,0 +1,138 @@
+import type { MemoryScopeRef } from '../memory/types.js';
+export declare const CONTEXT_REF_KINDS: readonly ["memory", "raw", "entity", "case"];
+export type ContextRefKind = (typeof CONTEXT_REF_KINDS)[number];
+export declare const UNSUPPORTED_CONTEXT_REF_KINDS: readonly ["decision", "wiki_page", "context_packet", "report"];
+export type UnsupportedContextRefKind = (typeof UNSUPPORTED_CONTEXT_REF_KINDS)[number];
+export type ContextRef = {
+    kind: 'memory';
+    id: string;
+} | {
+    kind: 'raw';
+    raw_id: string;
+    connector: string;
+    source_id?: string;
+    channel_id?: string | null;
+} | {
+    kind: 'entity';
+    id: string;
+} | {
+    kind: 'case';
+    id: string;
+};
+export interface ContextRange {
+    start_ms?: number;
+    end_ms?: number;
+}
+export interface ContextProjectRef {
+    kind: 'project';
+    id: string;
+}
+export interface ContextCompileInput {
+    task: string;
+    scopes?: MemoryScopeRef[];
+    seed_refs?: ContextRef[];
+    connectors?: string[];
+    project_refs?: ContextProjectRef[];
+    tenant_id?: string | null;
+    range?: ContextRange;
+    as_of?: string | number | null;
+    limit?: number;
+    max_tool_calls?: number;
+    max_ms?: number;
+    max_tokens?: number;
+    strictness?: 'recall' | 'balanced' | 'strict' | 'low' | 'medium' | 'high';
+}
+export interface ContextBoundary {
+    scopes?: MemoryScopeRef[];
+    connectors?: string[];
+    project_refs?: ContextProjectRef[];
+    tenant_id?: string | null;
+    as_of?: string | number | null;
+    range?: ContextRange;
+}
+export interface CanonicalContextScopes {
+    scopes: MemoryScopeRef[];
+    scopeJson: string;
+    scopeHash: string;
+}
+export interface ContextVisibility {
+    scopes: MemoryScopeRef[];
+    scope_json: string;
+    scope_hash: string;
+    connectors: string[];
+    project_refs: ContextProjectRef[];
+    tenant_id: string | null;
+    as_of: string | number | null;
+    range: ContextRange | null;
+}
+export interface ContextEvidence {
+    ref: ContextRef;
+    title?: string;
+    excerpt?: string;
+    score?: number;
+    reasons?: string[];
+    retrieval_diagnostics?: unknown;
+}
+export interface ContextPacket {
+    packet_id: string;
+    mode: 'general';
+    task: string;
+    scopes: MemoryScopeRef[];
+    scope_hash: string;
+    generated_at: string;
+    range: ContextRange | null;
+    as_of: string | number | null;
+    compiler_version: string;
+    source_refs: ContextRef[];
+    selected_evidence: ContextEvidence[];
+    evidence_clusters: unknown[];
+    related_decisions: unknown[];
+    rejected_refs: ContextRef[];
+    rejected_refs_truncated: boolean;
+    rejected_summary: string[];
+    missing_context: string[];
+    caveats: string[];
+    expansion_trace: unknown[];
+    retrieval_diagnostics: unknown;
+    budget: {
+        max_tool_calls?: number;
+        used_tool_calls: number;
+        max_ms?: number;
+        elapsed_ms: number;
+        max_tokens?: number;
+        estimated_tokens: number;
+        budget_exhausted: boolean;
+    };
+    budget_manifest: {
+        budget_exhausted: boolean;
+        skipped_operators: string[];
+    };
+}
+export interface ContextPacketRecord {
+    packet_id: string;
+    task: string;
+    packet_json: string;
+    packet: ContextPacket;
+    scope_json: string;
+    scopes: MemoryScopeRef[];
+    scope_hash: string;
+    envelope_hash: string;
+    model_run_id: string;
+    agent_id: string;
+    input_snapshot_ref: string;
+    source_refs_json: string;
+    source_refs: ContextRef[];
+    tenant_id: string;
+    project_id: string;
+    memory_scope_kind: MemoryScopeRef['kind'];
+    memory_scope_id: string;
+    created_at: number;
+}
+export interface TrustedContextPacketLookupInput {
+    packetId: string;
+    envelopeHash: string;
+    modelRunId?: string;
+    callerModelRunId?: string;
+    includeFailed?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/context-compile/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSUPPORTED_CONTEXT_REF_KINDS = exports.CONTEXT_REF_KINDS = void 0;
+exports.CONTEXT_REF_KINDS = ['memory', 'raw', 'entity', 'case'];
+exports.UNSUPPORTED_CONTEXT_REF_KINDS = [
+    'decision',
+    'wiki_page',
+    'context_packet',
+    'report',
+];
+//# sourceMappingURL=types.js.map

package/dist/context-compile/visibility.d.ts

@@ -0,0 +1,21 @@
+import { type MemoryScopeRef } from '../memory/types.js';
+import type { ContextBoundary, ContextProjectRef, ContextRef } from './types.js';
+type BoundaryCheckInput = {
+    boundary: ContextBoundary;
+    requestedScopes?: readonly MemoryScopeRef[];
+    requestedConnectors?: readonly string[];
+    requestedProjectRefs?: readonly ContextProjectRef[];
+    requestedTenantId?: string | null;
+    seedRefs?: readonly unknown[];
+};
+export declare function canonicalizeContextScopes(scopes: readonly MemoryScopeRef[] | undefined): {
+    scopes: MemoryScopeRef[];
+    scopeJson: string;
+    scopeHash: string;
+};
+export declare function derivePrimaryContextScope(scopes: readonly MemoryScopeRef[]): MemoryScopeRef;
+export declare function assertContextBoundaryAllowsInput(input: BoundaryCheckInput): void;
+export declare function sanitizeContextPacketForVisibility<T>(packet: T): T;
+export declare function normalizeSeedRefs(seedRefs: readonly unknown[] | undefined): ContextRef[];
+export {};
+//# sourceMappingURL=visibility.d.ts.map

package/dist/context-compile/visibility.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeContextScopes = canonicalizeContextScopes;
+exports.derivePrimaryContextScope = derivePrimaryContextScope;
+exports.assertContextBoundaryAllowsInput = assertContextBoundaryAllowsInput;
+exports.sanitizeContextPacketForVisibility = sanitizeContextPacketForVisibility;
+exports.normalizeSeedRefs = normalizeSeedRefs;
+const node_crypto_1 = require("node:crypto");
+const types_js_1 = require("../memory/types.js");
+const ref_js_1 = require("./ref.js");
+const SCOPE_ORDER = {
+    project: 0,
+    channel: 1,
+    user: 2,
+    global: 3,
+};
+function assertScope(scope) {
+    if (!types_js_1.MEMORY_SCOPE_KINDS.includes(scope.kind)) {
+        throw new Error(`Unsupported memory scope kind: ${scope.kind}`);
+    }
+    const id = scope.id.trim();
+    if (id.length === 0) {
+        throw new Error('Memory scope id must not be empty');
+    }
+    return { kind: scope.kind, id };
+}
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function connectorKey(connector) {
+    const trimmed = connector.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Connector must not be empty');
+    }
+    return trimmed;
+}
+function projectKey(project) {
+    const kind = project.kind.trim();
+    const id = project.id.trim();
+    if (kind.length === 0 || id.length === 0) {
+        throw new Error('Project ref kind and id must not be empty');
+    }
+    return `${kind}\0${id}`;
+}
+function sortScopes(scopes) {
+    return [...scopes].sort((left, right) => {
+        const orderDiff = SCOPE_ORDER[left.kind] - SCOPE_ORDER[right.kind];
+        if (orderDiff !== 0) {
+            return orderDiff;
+        }
+        return left.id.localeCompare(right.id);
+    });
+}
+function canonicalizeContextScopes(scopes) {
+    const unique = new Map();
+    for (const scope of scopes ?? []) {
+        const normalized = assertScope(scope);
+        unique.set(scopeKey(normalized), normalized);
+    }
+    const canonicalScopes = sortScopes([...unique.values()]);
+    const scopeJson = JSON.stringify(canonicalScopes);
+    const scopeHash = (0, node_crypto_1.createHash)('sha256').update(scopeJson).digest('hex');
+    return {
+        scopes: canonicalScopes,
+        scopeJson,
+        scopeHash,
+    };
+}
+function derivePrimaryContextScope(scopes) {
+    const canonical = canonicalizeContextScopes(scopes).scopes;
+    const primary = canonical.find((scope) => scope.kind === 'project') ?? canonical[0];
+    return primary ?? { kind: 'global', id: 'default' };
+}
+function assertContextBoundaryAllowsInput(input) {
+    const hasScopeBoundary = Array.isArray(input.boundary.scopes);
+    const boundaryScopes = canonicalizeContextScopes(input.boundary.scopes).scopes;
+    const requestedScopes = canonicalizeContextScopes(input.requestedScopes).scopes;
+    if (hasScopeBoundary && requestedScopes.length > 0) {
+        const allowed = new Set(boundaryScopes.map(scopeKey));
+        const disallowed = requestedScopes.find((scope) => !allowed.has(scopeKey(scope)));
+        if (disallowed) {
+            throw new Error(`Requested scope is outside the context boundary: ${disallowed.kind}:${disallowed.id}`);
+        }
+    }
+    const hasConnectorBoundary = Array.isArray(input.boundary.connectors);
+    const boundaryConnectors = new Set((input.boundary.connectors ?? []).map(connectorKey));
+    const requestedConnectors = (input.requestedConnectors ?? []).map(connectorKey);
+    if (hasConnectorBoundary) {
+        const disallowedConnector = requestedConnectors.find((connector) => !boundaryConnectors.has(connector));
+        if (disallowedConnector) {
+            throw new Error(`Requested connector is outside the context boundary: ${disallowedConnector}`);
+        }
+    }
+    const hasProjectBoundary = Array.isArray(input.boundary.project_refs);
+    const boundaryProjects = new Set((input.boundary.project_refs ?? []).map(projectKey));
+    const requestedProjects = (input.requestedProjectRefs ?? []).map(projectKey);
+    if (hasProjectBoundary && requestedProjects.length > 0) {
+        const disallowedProject = requestedProjects.find((project) => !boundaryProjects.has(project));
+        if (disallowedProject) {
+            const [kind, id] = disallowedProject.split('\0');
+            throw new Error(`Requested project ref is outside the context boundary: ${kind}:${id}`);
+        }
+    }
+    const boundaryTenantId = input.boundary.tenant_id;
+    if (typeof boundaryTenantId === 'string' &&
+        boundaryTenantId.length > 0 &&
+        input.requestedTenantId !== undefined &&
+        input.requestedTenantId !== null &&
+        input.requestedTenantId !== boundaryTenantId) {
+        throw new Error('Requested tenant is outside the context boundary');
+    }
+    const seedRefs = (0, ref_js_1.normalizeContextRefs)(input.seedRefs);
+    assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary);
+}
+function assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary) {
+    for (const ref of seedRefs) {
+        if (ref.kind === 'raw' && hasConnectorBoundary && !boundaryConnectors.has(ref.connector)) {
+            throw new Error(`Seed raw ref connector is outside the context boundary: ${ref.connector}`);
+        }
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function collectHiddenIdentifiers(value, hidden) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectHiddenIdentifiers(item, hidden);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    const maybeHidden = value;
+    if (maybeHidden.visible === false) {
+        for (const field of ['id', 'raw_id', 'source_id', 'channel_id']) {
+            const fieldValue = value[field];
+            if (typeof fieldValue === 'string' && fieldValue.length > 0) {
+                hidden.add(fieldValue);
+            }
+        }
+    }
+    for (const child of Object.values(value)) {
+        collectHiddenIdentifiers(child, hidden);
+    }
+}
+function isIdentifierBoundary(character) {
+    return character === undefined || !/[A-Za-z0-9_]/.test(character);
+}
+function containsHiddenIdentifier(value, identifier) {
+    if (identifier.length === 0) {
+        return false;
+    }
+    let index = value.indexOf(identifier);
+    while (index !== -1) {
+        const before = value[index - 1];
+        const after = value[index + identifier.length];
+        if (isIdentifierBoundary(before) && isIdentifierBoundary(after)) {
+            return true;
+        }
+        index = value.indexOf(identifier, index + 1);
+    }
+    return false;
+}
+function sanitizeValue(value, hidden) {
+    if (typeof value === 'string') {
+        return [...hidden].some((identifier) => containsHiddenIdentifier(value, identifier))
+            ? undefined
+            : value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => sanitizeValue(item, hidden))
+            .filter((item) => item !== undefined);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    if (value.visible === false) {
+        return undefined;
+    }
+    const sanitized = {};
+    for (const [key, child] of Object.entries(value)) {
+        const next = sanitizeValue(child, hidden);
+        if (next !== undefined) {
+            sanitized[key] = next;
+        }
+    }
+    return sanitized;
+}
+function sanitizeContextPacketForVisibility(packet) {
+    const hidden = new Set();
+    collectHiddenIdentifiers(packet, hidden);
+    return sanitizeValue(packet, hidden);
+}
+function normalizeSeedRefs(seedRefs) {
+    return (0, ref_js_1.normalizeContextRefs)(seedRefs).map((ref) => (0, ref_js_1.normalizeContextRef)(ref));
+}
+//# sourceMappingURL=visibility.js.map

package/dist/db-adapter/node-sqlite-adapter.d.ts

@@ -55,6 +55,15 @@ export declare class NodeSQLiteAdapter extends DatabaseAdapter {
     insertEmbedding(rowid: number, embedding: Float32Array | number[]): RunResult | null;
     getLastInsertRowid(): number;
     runMigrations(migrationsDir: string): void;
+    private repairSkippedFeatureMigrations;
+    private applyRepairMigration;
+    private recoverMemoryProvenanceMigration032;
+    private assertMigration032Complete;
+    private recoverConnectorEventScopeMigration034;
+    private assertMigration034Complete;
+    private tableColumns;
+    private tableExists;
+    private indexExists;
     private migrateFromVssMemories;
 }
 export default NodeSQLiteAdapter;

package/dist/db-adapter/node-sqlite-adapter.js

@@ -18,6 +18,7 @@ const debug_logger_js_1 = require("../debug-logger.js");
 const embeddings_js_1 = require("../embeddings.js");
 const LEGACY_DB_PATH = path_1.default.join(os_1.default.homedir(), '.spinelift', 'memories.db');
 const DEFAULT_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
+const SQLITE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 // Prefer better-sqlite3 (includes FTS5) over node:sqlite (lacks FTS5)
 let BetterSQLite3 = null;
 let DatabaseSync = null;
@@ -320,6 +321,16 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             catch (err) {
                 this.exec('ROLLBACK');
                 const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('duplicate column') && version === 32) {
+                    this.recoverMemoryProvenanceMigration032();
+                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
+                    continue;
+                }
+                if (message.includes('duplicate column') && version === 34) {
+                    this.recoverConnectorEventScopeMigration034();
+                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
+                    continue;
+                }
                 if (message.includes('duplicate column')) {
                     (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} skipped (duplicate column - already applied)`);
                     this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
@@ -339,12 +350,208 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                 throw new Error(`Migration ${file} failed: ${message}`);
             }
         }
+        this.repairSkippedFeatureMigrations(migrationsDir);
         const embeddingsTables = this.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`).all();
         if (embeddingsTables.length === 0) {
             throw new Error('Embeddings table is missing after migrations. Add the required embeddings migration.');
         }
         this.migrateFromVssMemories();
     }
+    repairSkippedFeatureMigrations(migrationsDir) {
+        if (this.tableExists('decisions')) {
+            const decisionColumns = this.tableColumns('decisions');
+            const hasMissingMemoryProvenanceColumn = [
+                'agent_id',
+                'model_run_id',
+                'envelope_hash',
+                'gateway_call_id',
+                'source_refs_json',
+                'provenance_json',
+            ].some((column) => !decisionColumns.has(column));
+            const hasMissingMemoryProvenanceIndex = [
+                'idx_decisions_envelope_hash',
+                'idx_decisions_model_run_id',
+                'idx_decisions_gateway_call_id',
+                'idx_memory_events_memory_created',
+            ].some((indexName) => !this.indexExists(indexName));
+            if (hasMissingMemoryProvenanceColumn || hasMissingMemoryProvenanceIndex) {
+                this.recoverMemoryProvenanceMigration032();
+                (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped memory provenance migration');
+            }
+        }
+        if (!this.tableExists('model_runs') || !this.tableExists('tool_traces')) {
+            this.applyRepairMigration(migrationsDir, '033-create-model-runs-and-tool-traces.sql', 'model run provenance');
+        }
+        if (this.tableExists('connector_event_index')) {
+            const connectorColumns = this.tableColumns('connector_event_index');
+            const hasMissingConnectorScopeColumn = [
+                'source_cursor',
+                'tenant_id',
+                'project_id',
+                'memory_scope_kind',
+                'memory_scope_id',
+            ].some((column) => !connectorColumns.has(column));
+            if (hasMissingConnectorScopeColumn) {
+                this.recoverConnectorEventScopeMigration034();
+                (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped connector event scope migration');
+            }
+        }
+        if (!this.tableExists('twin_edges')) {
+            this.applyRepairMigration(migrationsDir, '035-create-twin-edges.sql', 'twin edge ledger');
+        }
+        if (!this.tableExists('agent_situation_packets') ||
+            !this.tableExists('agent_situation_refresh_leases')) {
+            this.applyRepairMigration(migrationsDir, '036-create-agent-situation-packets.sql', 'agent situation packet cache');
+        }
+        if (!this.tableExists('context_packets')) {
+            this.applyRepairMigration(migrationsDir, '037-create-context-packets.sql', 'context packet store');
+        }
+    }
+    applyRepairMigration(migrationsDir, fileName, label) {
+        const migrationPath = path_1.default.join(migrationsDir, fileName);
+        if (!fs_1.default.existsSync(migrationPath)) {
+            throw new Error(`Missing repair migration ${fileName} for ${label}`);
+        }
+        const migrationSQL = fs_1.default.readFileSync(migrationPath, 'utf8');
+        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Repairing skipped ${label} migration: ${fileName}`);
+        try {
+            this.transaction(() => {
+                this.exec(migrationSQL);
+            });
+            (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Repair migration ${fileName} applied successfully`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Repair migration ${fileName} failed: ${message}`);
+        }
+    }
+    recoverMemoryProvenanceMigration032() {
+        this.transaction(() => {
+            const expectedDecisionColumns = [
+                'agent_id',
+                'model_run_id',
+                'envelope_hash',
+                'gateway_call_id',
+                'source_refs_json',
+                'provenance_json',
+            ];
+            const decisionColumns = this.tableColumns('decisions');
+            for (const column of expectedDecisionColumns) {
+                if (!decisionColumns.has(column)) {
+                    this.exec(`ALTER TABLE decisions ADD COLUMN ${column} TEXT`);
+                    decisionColumns.add(column);
+                }
+            }
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_decisions_envelope_hash
+          ON decisions(envelope_hash)
+      `);
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_decisions_model_run_id
+          ON decisions(model_run_id)
+      `);
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_decisions_gateway_call_id
+          ON decisions(gateway_call_id)
+      `);
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_memory_events_memory_created
+          ON memory_events(memory_id, created_at DESC)
+      `);
+            this.assertMigration032Complete();
+            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(32, 'Add nullable memory provenance columns');
+        });
+    }
+    assertMigration032Complete() {
+        const decisionColumns = this.tableColumns('decisions');
+        for (const column of [
+            'agent_id',
+            'model_run_id',
+            'envelope_hash',
+            'gateway_call_id',
+            'source_refs_json',
+            'provenance_json',
+        ]) {
+            if (!decisionColumns.has(column)) {
+                throw new Error(`Migration 032 recovery failed: missing decisions.${column}`);
+            }
+        }
+        for (const indexName of [
+            'idx_decisions_envelope_hash',
+            'idx_decisions_model_run_id',
+            'idx_decisions_gateway_call_id',
+            'idx_memory_events_memory_created',
+        ]) {
+            if (!this.indexExists(indexName)) {
+                throw new Error(`Migration 032 recovery failed: missing index ${indexName}`);
+            }
+        }
+    }
+    recoverConnectorEventScopeMigration034() {
+        this.transaction(() => {
+            const expectedColumns = [
+                'source_cursor',
+                'tenant_id',
+                'project_id',
+                'memory_scope_kind',
+                'memory_scope_id',
+            ];
+            const columns = this.tableColumns('connector_event_index');
+            for (const column of expectedColumns) {
+                if (!columns.has(column)) {
+                    this.exec(`ALTER TABLE connector_event_index ADD COLUMN ${column} TEXT`);
+                    columns.add(column);
+                }
+            }
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_connector_event_scope
+          ON connector_event_index(tenant_id, project_id, memory_scope_kind, memory_scope_id)
+      `);
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_connector_event_source_cursor
+          ON connector_event_index(source_connector, source_cursor)
+      `);
+            this.assertMigration034Complete();
+            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(34, 'Add connector event scope columns');
+        });
+    }
+    assertMigration034Complete() {
+        const columns = this.tableColumns('connector_event_index');
+        for (const column of [
+            'source_cursor',
+            'tenant_id',
+            'project_id',
+            'memory_scope_kind',
+            'memory_scope_id',
+        ]) {
+            if (!columns.has(column)) {
+                throw new Error(`Migration 034 recovery failed: missing connector_event_index.${column}`);
+            }
+        }
+        for (const indexName of ['idx_connector_event_scope', 'idx_connector_event_source_cursor']) {
+            if (!this.indexExists(indexName)) {
+                throw new Error(`Migration 034 recovery failed: missing index ${indexName}`);
+            }
+        }
+    }
+    tableColumns(tableName) {
+        if (!SQLITE_IDENTIFIER_PATTERN.test(tableName)) {
+            throw new Error('Invalid SQLite table identifier');
+        }
+        const rows = this.prepare(`PRAGMA table_info(${tableName})`).all();
+        return new Set(rows.map((row) => row.name));
+    }
+    tableExists(tableName) {
+        if (!SQLITE_IDENTIFIER_PATTERN.test(tableName)) {
+            throw new Error('Invalid SQLite table identifier');
+        }
+        const row = this.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(tableName);
+        return row?.name === tableName;
+    }
+    indexExists(indexName) {
+        const row = this.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name = ?").get(indexName);
+        return row?.name === indexName;
+    }
     migrateFromVssMemories() {
         try {
             const vssTables = this.prepare(`SELECT name FROM sqlite_master WHERE name='vss_memories'`).all();

package/dist/db-manager.d.ts

@@ -121,6 +121,7 @@ export interface SemanticEdges {
  * @returns SQLite database connection
  */
 export declare function initDB(): Promise<unknown>;
+export declare function assertTestProcessIsNotUsingRealDb(effectivePath?: string, effectivePathSource?: string): void;
 /**
  * Get database connection (singleton pattern)
  *
@@ -206,6 +207,12 @@ export interface DecisionInput {
     event_date?: string | null;
     /** Source event timestamp in milliseconds when known. */
     event_datetime?: number | null;
+    agent_id?: string | null;
+    model_run_id?: string | null;
+    envelope_hash?: string | null;
+    gateway_call_id?: string | null;
+    source_refs_json?: string | null;
+    provenance_json?: string | null;
 }
 /**
  * Insert decision with embedding
@@ -284,7 +291,7 @@ export declare function resetDBState(options?: {
 /**
  * Check if running in test mode
  *
- * Returns true if MAMA_TEST_MODE or VITEST env vars are set
+ * Returns true if MAMA_TEST_MODE, VITEST, or NODE_ENV=test env vars are set
  */
 export declare function isTestMode(): boolean;
 /**