@jungjaehoon/mama-core 1.6.0 → 1.8.1

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

@@ -40,27 +40,43 @@ export declare class NodeSQLiteAdapter extends DatabaseAdapter {
     private _vectorSearchEnabled;
     private vectorCache;
     private topicCache;
+    private statusCache;
+    private decisionsHasStatusColumns;
+    private decisionsColumnInfoChecked;
     constructor(config?: SQLiteAdapterConfig);
     get vectorSearchEnabled(): boolean;
     getDbPath(): string;
     connect(): NodeSQLiteConnection;
     reloadVectorCache(): void;
+    refreshDecisionStatusCache(rowid: number): void;
+    private refreshDecisionColumnInfo;
     private loadVectorCache;
     disconnect(): void;
     isConnected(): boolean;
     prepare(sql: string): Statement;
     exec(sql: string): void;
     transaction<T>(fn: () => T): T;
-    vectorSearch(embedding: Float32Array | number[], limit?: number, topicPrefix?: string): VectorSearchResult[] | null;
+    vectorSearch(embedding: Float32Array | number[], limit?: number, topicPrefix?: string, excludeStatuses?: readonly string[]): VectorSearchResult[] | null;
     insertEmbedding(rowid: number, embedding: Float32Array | number[]): RunResult | null;
     getLastInsertRowid(): number;
     runMigrations(migrationsDir: string): void;
+    private repairSkippedFeatureMigrations;
+    private applyRepairMigration;
+    private operatorMemoryCommitIntentTableSql;
+    private hasOperatorMemoryCommitIntentClaimInvariant;
+    private assertMigration040BaseComplete;
+    private assertMigration041Complete;
     private recoverMemoryProvenanceMigration032;
     private assertMigration032Complete;
     private recoverConnectorEventScopeMigration034;
     private assertMigration034Complete;
+    private recoverConnectorEventOperatorSeqMigration039;
+    private assertMigration039Complete;
     private tableColumns;
+    private tableExists;
     private indexExists;
+    private triggerExists;
+    private schemaVersionExists;
     private migrateFromVssMemories;
 }
 export default NodeSQLiteAdapter;