@jungjaehoon/mama-core 1.3.2 → 1.4.0

package/dist/memory/extraction-prompt.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExtractionPrompt = buildExtractionPrompt;
+exports.parseExtractionResponse = parseExtractionResponse;
+const types_js_1 = require("./types.js");
+const VALID_KINDS = new Set(types_js_1.MEMORY_KINDS);
+function buildExtractionPrompt(messages, existingTopics) {
+    const conversationText = messages.map((m) => `${m.role}: ${m.content}`).join('\n');
+    const hasExistingTopics = existingTopics && existingTopics.length > 0;
+    const topicHint = hasExistingTopics
+        ? `\nExisting topics (REUSE these when the subject matches instead of creating new ones):\n${existingTopics.map((t) => t.replace(/[`$\\]/g, '')).join(', ')}\n`
+        : '';
+    const topicRule = hasExistingTopics
+        ? '- topic: lowercase_snake_case, prefer reusing an existing topic above when the subject matches'
+        : '- topic: lowercase_snake_case';
+    return `You are extracting structured memory units from a conversation about a user's life.
+
+Read the conversation and identify every distinct piece of personal information worth remembering.
+Classify each as one of: preference, fact, decision, lesson, constraint.
+${topicHint}
+Rules:
+${topicRule}
+- summary: concise (<200 chars). MUST include ALL of these when mentioned:
+  • Names (people, pets, brands, stores, apps, services)
+  • Dates and times ("bought on February 15", "every Tuesday", "3 weeks ago")
+  • Numbers and amounts ("$5 coupon", "4 hours", "45 minutes each way", "3 weddings")
+  • Places ("at Target", "from IKEA", "in Chicago")
+  Example: "User redeemed a $5 coupon on coffee creamer at Target on March 3" NOT "User used a coupon"
+- details: quote the exact sentence(s) from the conversation that contain this information
+- confidence: 0.0-1.0 based on how explicitly stated the information is
+- For preferences: state what IS preferred and what is NOT (if mentioned)
+- For countable facts: enumerate items explicitly (e.g., "Weddings attended: 1. Rachel & Mike, 2. Emily & Sarah, 3. Jen & Tom")
+- IMPORTANT: do NOT merge unrelated facts. Each distinct event, purchase, person, or activity is a separate unit
+- Skip small talk, meta-conversation, and assistant's general knowledge responses
+
+Return ONLY a JSON array:
+[{"kind":"...","topic":"...","summary":"...","details":"...","confidence":0.9}]
+
+Conversation:
+${conversationText}`;
+}
+function parseExtractionResponse(response) {
+    if (!response || response.trim().length === 0) {
+        return [];
+    }
+    let jsonStr = response;
+    // Try extracting from markdown code fences
+    const fenceMatch = response.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (fenceMatch) {
+        jsonStr = fenceMatch[1];
+    }
+    // Try extracting bare JSON array
+    if (!jsonStr.trimStart().startsWith('[')) {
+        const arrayMatch = jsonStr.match(/\[[\s\S]*\]/);
+        if (arrayMatch) {
+            jsonStr = arrayMatch[0];
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonStr.trim());
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed
+        .filter((item) => {
+        if (typeof item !== 'object' || item === null)
+            return false;
+        const obj = item;
+        return (typeof obj.kind === 'string' &&
+            VALID_KINDS.has(obj.kind) &&
+            typeof obj.topic === 'string' &&
+            obj.topic.length > 0 &&
+            typeof obj.summary === 'string' &&
+            obj.summary.length > 0);
+    })
+        .map((item) => ({
+        kind: item.kind,
+        topic: String(item.topic),
+        summary: String(item.summary).slice(0, 200),
+        details: typeof item.details === 'string' ? String(item.details) : String(item.summary),
+        confidence: Math.max(0, Math.min(1, Number(item.confidence) || 0.5)),
+    }));
+}
+//# sourceMappingURL=extraction-prompt.js.map

package/dist/memory/finding-store.d.ts

@@ -0,0 +1,5 @@
+import type { AuditFindingRecord } from './types.js';
+export declare function createAuditFinding(input: Omit<AuditFindingRecord, 'finding_id' | 'status' | 'created_at' | 'resolved_at'>): Promise<string>;
+export declare function listOpenAuditFindings(): Promise<AuditFindingRecord[]>;
+export declare function resolveAuditFinding(findingId: string, status: 'resolved' | 'dismissed'): Promise<void>;
+//# sourceMappingURL=finding-store.d.ts.map

package/dist/memory/finding-store.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuditFinding = createAuditFinding;
+exports.listOpenAuditFindings = listOpenAuditFindings;
+exports.resolveAuditFinding = resolveAuditFinding;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const db_manager_js_1 = require("../db-manager.js");
+function safeParseJsonArray(value) {
+    try {
+        return JSON.parse(String(value));
+    }
+    catch {
+        return [];
+    }
+}
+function deserializeFinding(row) {
+    return {
+        finding_id: String(row.finding_id),
+        kind: row.kind,
+        severity: row.severity,
+        summary: String(row.summary),
+        evidence_refs: safeParseJsonArray(row.evidence_refs),
+        affected_memory_ids: safeParseJsonArray(row.affected_memory_ids),
+        recommended_action: String(row.recommended_action),
+        status: row.status,
+        created_at: Number(row.created_at),
+        resolved_at: row.resolved_at === null || row.resolved_at === undefined
+            ? undefined
+            : Number(row.resolved_at),
+    };
+}
+async function createAuditFinding(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const findingId = `finding_${node_crypto_1.default.randomUUID().replace(/-/g, '')}`;
+    adapter
+        .prepare(`
+        INSERT INTO audit_findings (
+          finding_id, kind, severity, summary, evidence_refs, affected_memory_ids,
+          recommended_action, status, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?)
+      `)
+        .run(findingId, input.kind, input.severity, input.summary, JSON.stringify(input.evidence_refs), JSON.stringify(input.affected_memory_ids), input.recommended_action, Date.now());
+    return findingId;
+}
+async function listOpenAuditFindings() {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT finding_id, kind, severity, summary, evidence_refs, affected_memory_ids,
+               recommended_action, status, created_at, resolved_at
+        FROM audit_findings
+        WHERE status = 'open'
+        ORDER BY created_at DESC
+      `)
+        .all();
+    return rows.map(deserializeFinding);
+}
+async function resolveAuditFinding(findingId, status) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    adapter
+        .prepare(`
+        UPDATE audit_findings
+        SET status = ?, resolved_at = ?
+        WHERE finding_id = ?
+      `)
+        .run(status, Date.now(), findingId);
+}
+//# sourceMappingURL=finding-store.js.map

package/dist/memory/profile-builder.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryRecord, ProfileSnapshot } from './types.js';
+export declare function classifyProfileEntries(records: MemoryRecord[]): ProfileSnapshot;
+//# sourceMappingURL=profile-builder.d.ts.map

package/dist/memory/profile-builder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyProfileEntries = classifyProfileEntries;
+function isStaticMemory(record) {
+    return record.kind === 'preference' || record.kind === 'constraint';
+}
+function classifyProfileEntries(records) {
+    const active = records.filter((record) => record.status === 'active');
+    const staticEntries = active.filter(isStaticMemory);
+    const dynamicEntries = active.filter((record) => !isStaticMemory(record));
+    return {
+        static: staticEntries,
+        dynamic: dynamicEntries,
+        evidence: active.map((record) => ({
+            memory_id: record.id,
+            topic: record.topic,
+            why_included: isStaticMemory(record)
+                ? 'Long-term preference or constraint'
+                : 'Current active context',
+        })),
+    };
+}
+//# sourceMappingURL=profile-builder.js.map

package/dist/memory/scope-store.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryScopeKind, MemoryScopeRef } from './types.js';
+export declare const PRIORITY_SCOPE_ORDER: MemoryScopeKind[];
+export declare function sortScopesByPriority(scopes: MemoryScopeRef[]): MemoryScopeRef[];
+export declare function getPrimaryScope(scopes: MemoryScopeRef[]): MemoryScopeRef | null;
+//# sourceMappingURL=scope-store.d.ts.map

package/dist/memory/scope-store.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIORITY_SCOPE_ORDER = void 0;
+exports.sortScopesByPriority = sortScopesByPriority;
+exports.getPrimaryScope = getPrimaryScope;
+exports.PRIORITY_SCOPE_ORDER = ['project', 'channel', 'user', 'global'];
+function sortScopesByPriority(scopes) {
+    return [...scopes].sort((left, right) => exports.PRIORITY_SCOPE_ORDER.indexOf(left.kind) - exports.PRIORITY_SCOPE_ORDER.indexOf(right.kind));
+}
+function getPrimaryScope(scopes) {
+    return sortScopesByPriority(scopes)[0] ?? null;
+}
+//# sourceMappingURL=scope-store.js.map

package/dist/memory/truth-store.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryScopeRef, MemoryTruthRow } from './types.js';
+export declare function projectMemoryTruth(row: MemoryTruthRow): Promise<void>;
+export declare function queryTruthByTopic(topic: string, options?: {
+    includeHistory?: boolean;
+}): Promise<MemoryTruthRow[]>;
+export declare function queryRelevantTruth(params: {
+    query: string;
+    scopes: MemoryScopeRef[];
+    includeHistory?: boolean;
+}): Promise<MemoryTruthRow[]>;
+//# sourceMappingURL=truth-store.d.ts.map

package/dist/memory/truth-store.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectMemoryTruth = projectMemoryTruth;
+exports.queryTruthByTopic = queryTruthByTopic;
+exports.queryRelevantTruth = queryRelevantTruth;
+const db_manager_js_1 = require("../db-manager.js");
+function deserializeTruthRow(row) {
+    return {
+        memory_id: String(row.memory_id),
+        topic: String(row.topic),
+        truth_status: row.truth_status,
+        effective_summary: String(row.effective_summary),
+        effective_details: String(row.effective_details),
+        trust_score: Number(row.trust_score),
+        scope_refs: JSON.parse(String(row.scope_refs)),
+        supporting_event_ids: JSON.parse(String(row.supporting_event_ids)),
+        superseded_by: typeof row.superseded_by === 'string' ? row.superseded_by : undefined,
+        contradicted_by: typeof row.contradicted_by === 'string'
+            ? JSON.parse(row.contradicted_by)
+            : undefined,
+        created_at: typeof row.created_at === 'number' ? row.created_at : undefined,
+        updated_at: typeof row.updated_at === 'number' ? row.updated_at : undefined,
+        kind: typeof row.kind === 'string' ? row.kind : undefined,
+    };
+}
+function matchesScopes(row, scopes) {
+    if (scopes.length === 0) {
+        return true;
+    }
+    return row.scope_refs.some((scopeRef) => scopes.some((scope) => scope.kind === scopeRef.kind && scope.id === scopeRef.id));
+}
+function matchesQuery(row, query) {
+    const tokens = query
+        .toLowerCase()
+        .split(/[\s,.!?;:()[\]{}"']+/)
+        .filter((token) => token.length > 1);
+    const haystack = [row.topic, row.effective_summary, row.effective_details]
+        .join(' ')
+        .toLowerCase();
+    return tokens.length === 0
+        ? haystack.includes(query.toLowerCase())
+        : tokens.some((token) => haystack.includes(token));
+}
+async function projectMemoryTruth(row) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const now = Date.now();
+    adapter
+        .prepare(`
+        INSERT OR REPLACE INTO memory_truth (
+          memory_id, topic, truth_status, effective_summary, effective_details, trust_score,
+          scope_refs, supporting_event_ids, superseded_by, contradicted_by, created_at, updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT created_at FROM memory_truth WHERE memory_id = ?), ?), ?)
+      `)
+        .run(row.memory_id, row.topic, row.truth_status, row.effective_summary, row.effective_details, row.trust_score, JSON.stringify(row.scope_refs), JSON.stringify(row.supporting_event_ids), row.superseded_by ?? null, row.contradicted_by ? JSON.stringify(row.contradicted_by) : null, row.memory_id, now, now);
+}
+async function queryTruthByTopic(topic, options = {}) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT mt.memory_id, mt.topic, mt.truth_status, mt.effective_summary, mt.effective_details, mt.trust_score,
+               mt.scope_refs, mt.supporting_event_ids, mt.superseded_by, mt.contradicted_by, mt.created_at, mt.updated_at,
+               d.kind
+        FROM memory_truth mt
+        LEFT JOIN decisions d ON d.id = mt.memory_id
+        WHERE mt.topic = ?
+        ORDER BY mt.updated_at DESC
+      `)
+        .all(topic);
+    return rows
+        .map(deserializeTruthRow)
+        .filter((row) => options.includeHistory === true ||
+        (row.truth_status !== 'quarantined' &&
+            row.truth_status !== 'superseded' &&
+            row.truth_status !== 'contradicted'));
+}
+async function queryRelevantTruth(params) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT mt.memory_id, mt.topic, mt.truth_status, mt.effective_summary, mt.effective_details, mt.trust_score,
+               mt.scope_refs, mt.supporting_event_ids, mt.superseded_by, mt.contradicted_by, mt.created_at, mt.updated_at,
+               d.kind
+        FROM memory_truth mt
+        LEFT JOIN decisions d ON d.id = mt.memory_id
+        ORDER BY mt.updated_at DESC
+      `)
+        .all();
+    return rows
+        .map(deserializeTruthRow)
+        .filter((row) => matchesScopes(row, params.scopes))
+        .filter((row) => matchesQuery(row, params.query))
+        .filter((row) => params.includeHistory === true ||
+        (row.truth_status !== 'quarantined' &&
+            row.truth_status !== 'superseded' &&
+            row.truth_status !== 'contradicted'))
+        .sort((left, right) => right.trust_score - left.trust_score);
+}
+//# sourceMappingURL=truth-store.js.map

package/dist/memory/types.d.ts

@@ -0,0 +1,267 @@
+export declare const MEMORY_SCOPE_KINDS: readonly ["global", "user", "channel", "project"];
+export type MemoryScopeKind = (typeof MEMORY_SCOPE_KINDS)[number];
+export declare const MEMORY_KINDS: readonly ["decision", "preference", "constraint", "lesson", "fact"];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
+export declare const MEMORY_STATUSES: readonly ["active", "superseded", "contradicted", "stale"];
+export type MemoryStatus = (typeof MEMORY_STATUSES)[number];
+export declare const MEMORY_TRUTH_STATUSES: readonly ["active", "superseded", "contradicted", "stale", "quarantined"];
+export type MemoryTruthStatus = (typeof MEMORY_TRUTH_STATUSES)[number];
+export declare const MEMORY_EDGE_TYPES: readonly ["supersedes", "builds_on", "synthesizes", "contradicts"];
+export type MemoryEdgeType = (typeof MEMORY_EDGE_TYPES)[number];
+export declare const MEMORY_AGENT_ACTIONS: readonly ["save", "supersede", "contradict", "mark_stale", "quarantine", "no_op"];
+export type MemoryAgentAction = (typeof MEMORY_AGENT_ACTIONS)[number];
+export declare const MEMORY_CONSULT_INTENTS: readonly ["bootstrap_session", "validate_claim", "get_relevant_truth", "check_conflicts", "explain_history"];
+export type MemoryConsultIntent = (typeof MEMORY_CONSULT_INTENTS)[number];
+export declare const MEMORY_AUDIT_ACK_STATUSES: readonly ["applied", "skipped", "failed"];
+export type MemoryAuditAckStatus = (typeof MEMORY_AUDIT_ACK_STATUSES)[number];
+export interface MemoryScopeRef {
+    kind: MemoryScopeKind;
+    id: string;
+}
+export interface MemoryRecord {
+    id: string;
+    topic: string;
+    kind: MemoryKind;
+    summary: string;
+    details: string;
+    confidence: number;
+    status: MemoryStatus;
+    scopes: MemoryScopeRef[];
+    source: {
+        package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
+        source_type: string;
+        user_id?: string;
+        channel_id?: string;
+        project_id?: string;
+    };
+    created_at: number | string;
+    updated_at: number | string;
+    /** ISO 8601 date when the event actually occurred (e.g. "2023-01-15"). Null if not set. */
+    event_date?: string | null;
+}
+export interface MemoryEdge {
+    from_id: string;
+    to_id: string;
+    type: MemoryEdgeType;
+    reason?: string;
+}
+export interface ProfileSnapshot {
+    static: MemoryRecord[];
+    dynamic: MemoryRecord[];
+    evidence: Array<{
+        memory_id: string;
+        topic: string;
+        why_included: string;
+    }>;
+}
+export interface RecallBundle {
+    profile: ProfileSnapshot;
+    memories: MemoryRecord[];
+    graph_context: {
+        primary: MemoryRecord[];
+        expanded: MemoryRecord[];
+        edges: MemoryEdge[];
+    };
+    search_meta: {
+        query: string;
+        scope_order: MemoryScopeKind[];
+        retrieval_sources: string[];
+    };
+}
+export interface MemoryEventRecord {
+    event_id: string;
+    event_type: 'observed_conversation' | 'save' | 'supersede' | 'contradict' | 'mark_stale' | 'quarantine' | 'no_op' | 'audit_failed' | 'notice_sent';
+    actor: 'memory_agent' | 'main_agent' | 'user' | 'system';
+    source_turn_id?: string;
+    memory_id?: string;
+    topic?: string;
+    scope_refs: MemoryScopeRef[];
+    evidence_refs?: string[];
+    reason?: string;
+    created_at: number;
+}
+export interface AuditFindingRecord {
+    finding_id: string;
+    kind: 'wrong_direction' | 'memory_conflict' | 'stale_memory' | 'unsupported_claim';
+    severity: 'low' | 'medium' | 'high';
+    summary: string;
+    evidence_refs: string[];
+    affected_memory_ids: string[];
+    recommended_action: string;
+    status: 'open' | 'notified' | 'resolved' | 'dismissed';
+    created_at: number;
+    resolved_at?: number;
+}
+export interface MemoryAuditAck {
+    status: MemoryAuditAckStatus;
+    action: MemoryAgentAction;
+    event_ids: string[];
+    reason?: string;
+}
+export interface AuditNotice {
+    type: 'direction_alert' | 'truth_conflict' | 'truth_update' | 'memory_warning';
+    severity: 'low' | 'medium' | 'high';
+    summary: string;
+    evidence: Array<{
+        type: 'conversation' | 'memory' | 'event';
+        ref: string;
+        excerpt?: string;
+    }>;
+    recommended_action: 'recheck' | 'consult_memory' | 'avoid_claim' | 'use_truth_snapshot';
+    relevant_memories: Array<{
+        id: string;
+        topic: string;
+        summary: string;
+    }>;
+}
+export interface MemoryConsultResult {
+    status: 'ok' | 'conflict' | 'uncertain' | 'no_relevant_memory';
+    summary: string;
+    evidence: Array<{
+        type: 'memory' | 'event';
+        ref: string;
+        excerpt?: string;
+    }>;
+    truth_snapshot?: Array<{
+        id: string;
+        topic: string;
+        summary: string;
+        status: string;
+    }>;
+    recommended_action?: string;
+}
+export interface MemoryAgentBootstrap {
+    current_goal?: string;
+    scope_context: MemoryScopeRef[];
+    channel_summary_markdown?: string;
+    truth_snapshot: Array<{
+        id: string;
+        topic: string;
+        summary: string;
+        trust_score: number;
+    }>;
+    open_audit_findings: Array<{
+        id: string;
+        kind: string;
+        severity: string;
+        summary: string;
+    }>;
+    recent_memory_events: Array<{
+        id: string;
+        type: string;
+        topic?: string;
+        created_at: number;
+    }>;
+    profile_snapshot?: {
+        static: Array<{
+            id: string;
+            summary: string;
+        }>;
+        dynamic: Array<{
+            id: string;
+            summary: string;
+        }>;
+    };
+    main_agent_state?: {
+        active_goal?: string;
+        active_channel?: string;
+        active_user?: string;
+    };
+}
+export interface MemoryTruthRow {
+    memory_id: string;
+    topic: string;
+    kind?: MemoryKind;
+    truth_status: MemoryTruthStatus;
+    effective_summary: string;
+    effective_details: string;
+    trust_score: number;
+    scope_refs: MemoryScopeRef[];
+    supporting_event_ids: string[];
+    superseded_by?: string;
+    contradicted_by?: string[];
+    created_at?: number;
+    updated_at?: number;
+}
+export interface ChannelSummaryRecord {
+    channel_key: string;
+    summary_markdown: string;
+    delta_hash?: string;
+    updated_at: number;
+}
+export interface ChannelSummaryStateDecision {
+    memory_id: string;
+    topic: string;
+    summary: string;
+    updated_at: number;
+}
+export interface ChannelSummaryStateMilestone {
+    topic: string;
+    action: MemoryAgentAction;
+    summary: string;
+    timestamp: number;
+    memory_id?: string;
+}
+export interface ChannelSummaryAuditOutcome {
+    topic: string;
+    status: MemoryAuditAckStatus;
+    reason?: string;
+    timestamp: number;
+}
+export interface ChannelSummaryStateRecord {
+    channel_key: string;
+    active_topic?: string;
+    active_decisions: ChannelSummaryStateDecision[];
+    recent_milestones: ChannelSummaryStateMilestone[];
+    recent_audit_outcomes: ChannelSummaryAuditOutcome[];
+    state_hash: string;
+    updated_at: number;
+}
+export declare function createEmptyRecallBundle(query: string): RecallBundle;
+export declare function createEmptyMemoryAgentBootstrap(input: Pick<MemoryAgentBootstrap, 'scope_context'> & Partial<Omit<MemoryAgentBootstrap, 'scope_context'>>): MemoryAgentBootstrap;
+export declare function createMemoryAuditAck(input: Pick<MemoryAuditAck, 'status' | 'action' | 'event_ids'> & Partial<MemoryAuditAck>): MemoryAuditAck;
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+export interface IngestConversationInput {
+    messages: ConversationMessage[];
+    scopes: MemoryScopeRef[];
+    source: {
+        package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
+        source_type: string;
+        user_id?: string;
+        channel_id?: string;
+        project_id?: string;
+    };
+    extract?: {
+        enabled: boolean;
+        model?: string;
+        apiKey?: string;
+        baseUrl?: string;
+    };
+    /** Prefix for all topics created by this ingestion (e.g. "bench_questionId_") for data isolation */
+    topicPrefix?: string;
+    /**
+     * ISO 8601 date string (e.g. "2023-01-15") representing when the conversation actually occurred.
+     * When provided, all memories extracted from this ingestion will have their event_date set to this value.
+     * Defaults to created_at (ingestion time) if omitted.
+     */
+    sessionDate?: string;
+}
+export interface ExtractedMemoryUnit {
+    kind: MemoryKind;
+    topic: string;
+    summary: string;
+    details: string;
+    confidence: number;
+}
+export interface IngestConversationResult {
+    rawId: string;
+    extractedMemories: Array<{
+        id: string;
+        kind: MemoryKind;
+        topic: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/memory/types.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_AUDIT_ACK_STATUSES = exports.MEMORY_CONSULT_INTENTS = exports.MEMORY_AGENT_ACTIONS = exports.MEMORY_EDGE_TYPES = exports.MEMORY_TRUTH_STATUSES = exports.MEMORY_STATUSES = exports.MEMORY_KINDS = exports.MEMORY_SCOPE_KINDS = void 0;
+exports.createEmptyRecallBundle = createEmptyRecallBundle;
+exports.createEmptyMemoryAgentBootstrap = createEmptyMemoryAgentBootstrap;
+exports.createMemoryAuditAck = createMemoryAuditAck;
+exports.MEMORY_SCOPE_KINDS = ['global', 'user', 'channel', 'project'];
+exports.MEMORY_KINDS = ['decision', 'preference', 'constraint', 'lesson', 'fact'];
+exports.MEMORY_STATUSES = ['active', 'superseded', 'contradicted', 'stale'];
+exports.MEMORY_TRUTH_STATUSES = [
+    'active',
+    'superseded',
+    'contradicted',
+    'stale',
+    'quarantined',
+];
+exports.MEMORY_EDGE_TYPES = ['supersedes', 'builds_on', 'synthesizes', 'contradicts'];
+exports.MEMORY_AGENT_ACTIONS = [
+    'save',
+    'supersede',
+    'contradict',
+    'mark_stale',
+    'quarantine',
+    'no_op',
+];
+exports.MEMORY_CONSULT_INTENTS = [
+    'bootstrap_session',
+    'validate_claim',
+    'get_relevant_truth',
+    'check_conflicts',
+    'explain_history',
+];
+exports.MEMORY_AUDIT_ACK_STATUSES = ['applied', 'skipped', 'failed'];
+function createEmptyRecallBundle(query) {
+    return {
+        profile: {
+            static: [],
+            dynamic: [],
+            evidence: [],
+        },
+        memories: [],
+        graph_context: {
+            primary: [],
+            expanded: [],
+            edges: [],
+        },
+        search_meta: {
+            query,
+            scope_order: ['project'],
+            retrieval_sources: ['vector'],
+        },
+    };
+}
+function createEmptyMemoryAgentBootstrap(input) {
+    return {
+        current_goal: input.current_goal,
+        scope_context: input.scope_context,
+        channel_summary_markdown: input.channel_summary_markdown,
+        truth_snapshot: input.truth_snapshot ?? [],
+        open_audit_findings: input.open_audit_findings ?? [],
+        recent_memory_events: input.recent_memory_events ?? [],
+        profile_snapshot: input.profile_snapshot,
+        main_agent_state: input.main_agent_state,
+    };
+}
+function createMemoryAuditAck(input) {
+    return {
+        status: input.status,
+        action: input.action,
+        event_ids: input.event_ids,
+        reason: input.reason,
+    };
+}
+//# sourceMappingURL=types.js.map