@jungjaehoon/mama-core 1.6.0 → 1.7.0

package/dist/context-compile/source-readers.js

@@ -0,0 +1,707 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceRefsFromCandidates = sourceRefsFromCandidates;
+exports.readMemoryCandidates = readMemoryCandidates;
+exports.readRawCandidates = readRawCandidates;
+exports.readGraphCandidates = readGraphCandidates;
+const ref_validation_js_1 = require("../edges/ref-validation.js");
+const api_js_1 = require("../memory/api.js");
+const ref_js_1 = require("./ref.js");
+const visibility_js_1 = require("./visibility.js");
+const boundary_defaults_js_1 = require("./boundary-defaults.js");
+function hiddenAggregate() {
+    return { total: 0, by_kind: {}, by_reason: {} };
+}
+function incrementHidden(aggregate, ref, reason) {
+    aggregate.total += 1;
+    aggregate.by_kind[ref.kind] = (aggregate.by_kind[ref.kind] ?? 0) + 1;
+    aggregate.by_reason[reason] = (aggregate.by_reason[reason] ?? 0) + 1;
+}
+function tableExists(adapter, table) {
+    const row = adapter
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?")
+        .get(table);
+    return Boolean(row?.name);
+}
+function placeholders(values) {
+    return values.map(() => '?').join(', ');
+}
+function normalizeLimit(limit) {
+    return Math.max(0, Math.min(100, Math.floor(limit ?? 10)));
+}
+function parseTimestampMs(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return null;
+    }
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        return Math.floor(numeric);
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function asOfMs(input) {
+    if (input.as_of === null || input.as_of === undefined) {
+        return null;
+    }
+    const parsed = parseTimestampMs(input.as_of);
+    if (parsed === null) {
+        throw new Error(`Invalid context source as_of: ${String(input.as_of)}`);
+    }
+    return parsed;
+}
+function timeFilterRequired(input) {
+    return Boolean(input.range?.start_ms !== undefined ||
+        input.range?.end_ms !== undefined ||
+        (input.as_of !== undefined && input.as_of !== null));
+}
+function rangeBoundaryMs(value, field) {
+    if (value === undefined) {
+        return null;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    throw new Error(`Invalid context source ${field}: ${String(value)}`);
+}
+function normalizeContextSourceRange(range) {
+    if (!range) {
+        return undefined;
+    }
+    const startMs = rangeBoundaryMs(range.start_ms, 'range.start_ms');
+    const endMs = rangeBoundaryMs(range.end_ms, 'range.end_ms');
+    if (startMs !== null && endMs !== null && startMs > endMs) {
+        throw new RangeError(`Invalid context source range: start_ms ${startMs} > end_ms ${endMs}`);
+    }
+    if (startMs === null && endMs === null) {
+        return undefined;
+    }
+    return {
+        ...(startMs !== null ? { start_ms: startMs } : {}),
+        ...(endMs !== null ? { end_ms: endMs } : {}),
+    };
+}
+function normalizeContextSourceAsOf(asOf) {
+    if (asOf === null || asOf === undefined) {
+        return asOf;
+    }
+    const parsed = parseTimestampMs(asOf);
+    if (parsed === null) {
+        throw new Error(`Invalid context source as_of: ${String(asOf)}`);
+    }
+    return parsed;
+}
+function normalizeTimeFilters(input) {
+    return {
+        ...input,
+        range: normalizeContextSourceRange(input.range),
+        as_of: normalizeContextSourceAsOf(input.as_of),
+    };
+}
+function maxVisibleTimeMs(input) {
+    const ends = [rangeBoundaryMs(input.range?.end_ms, 'range.end_ms'), asOfMs(input)].filter((value) => typeof value === 'number' && Number.isFinite(value));
+    return ends.length > 0 ? Math.min(...ends) : null;
+}
+function minVisibleTimeMs(input) {
+    return rangeBoundaryMs(input.range?.start_ms, 'range.start_ms');
+}
+function isWithinTimeBoundary(timestampMs, input) {
+    const min = minVisibleTimeMs(input);
+    const max = maxVisibleTimeMs(input);
+    return (min === null || timestampMs >= min) && (max === null || timestampMs <= max);
+}
+function hasExplicitEmptyProjectWindow(input) {
+    return (Array.isArray(input.project_refs) &&
+        input.project_refs.length === 0 &&
+        (input.boundary?.project_refs?.length ?? 0) > 0);
+}
+function applyBoundaryDefaults(input) {
+    return (0, boundary_defaults_js_1.applyContextBoundaryReadDefaults)(input, input.boundary);
+}
+function memoryTimestampMs(memory) {
+    return (parseTimestampMs(memory.event_datetime) ??
+        parseTimestampMs(memory.updated_at) ??
+        parseTimestampMs(memory.created_at));
+}
+function diagnosticsFromUnknown(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    if (typeof record.retrieval_source !== 'string') {
+        return undefined;
+    }
+    return {
+        retrieval_source: record.retrieval_source,
+        vector_similarity: typeof record.vector_similarity === 'number' ? record.vector_similarity : null,
+        lexical_support: record.lexical_support === true,
+        entity_support: record.entity_support === true,
+        scope_support: record.scope_support === true,
+        graph_source: record.graph_source === 'primary' || record.graph_source === 'expanded'
+            ? record.graph_source
+            : null,
+        is_vector_only: record.is_vector_only === true,
+        confirmation_signals: Array.isArray(record.confirmation_signals)
+            ? record.confirmation_signals.filter((signal) => typeof signal === 'string')
+            : [],
+        metadata_signals: Array.isArray(record.metadata_signals)
+            ? record.metadata_signals.filter((signal) => typeof signal === 'string')
+            : [],
+        candidate_threshold_used: typeof record.candidate_threshold_used === 'number' ? record.candidate_threshold_used : 0,
+    };
+}
+function supportFromDiagnostics(diagnostics) {
+    return {
+        retrieval_source: diagnostics?.retrieval_source,
+        lexical_support: diagnostics?.lexical_support,
+        entity_support: diagnostics?.entity_support,
+        scope_support: diagnostics?.scope_support,
+        graph_source: diagnostics?.graph_source,
+        graph_expanded: diagnostics?.graph_source === 'expanded',
+        is_vector_only: diagnostics?.is_vector_only,
+        vector_similarity: diagnostics?.vector_similarity,
+        confirmation_signals: diagnostics?.confirmation_signals ?? [],
+        metadata_signals: diagnostics?.metadata_signals ?? [],
+    };
+}
+function emptySupport(retrievalSource) {
+    return {
+        retrieval_source: retrievalSource,
+        confirmation_signals: [],
+        metadata_signals: [],
+    };
+}
+const EXCLUDED_MEMORY_STATUSES = new Set(['superseded', 'quarantined', 'contradicted', 'stale']);
+function loadScopesForMemoryIds(adapter, memoryIds) {
+    const scopeMap = new Map();
+    if (memoryIds.length === 0 || !tableExists(adapter, 'memory_scope_bindings')) {
+        return scopeMap;
+    }
+    const rows = adapter
+        .prepare(`
+        SELECT msb.memory_id, ms.kind, ms.external_id
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id IN (${placeholders(memoryIds)})
+        ORDER BY msb.is_primary DESC
+      `)
+        .all(...memoryIds);
+    for (const row of rows) {
+        const existing = scopeMap.get(row.memory_id) ?? [];
+        existing.push({ kind: row.kind, id: row.external_id });
+        scopeMap.set(row.memory_id, existing);
+    }
+    return scopeMap;
+}
+function sourceFromTrustContext(value) {
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed.source) {
+                return parsed.source;
+            }
+        }
+        catch {
+            // malformed trust_context falls back to local adapter source
+        }
+    }
+    return { package: 'mama-core', source_type: 'context_compile_adapter' };
+}
+function memoryRecordFromRow(row, scopes) {
+    return {
+        id: String(row.id),
+        topic: String(row.topic ?? ''),
+        kind: (row.kind ?? 'decision'),
+        summary: String(row.summary ?? row.decision ?? ''),
+        details: String(row.reasoning ?? row.decision ?? ''),
+        confidence: typeof row.confidence === 'number' ? row.confidence : 0.5,
+        status: (typeof row.status === 'string' ? row.status : 'active'),
+        scopes,
+        source: sourceFromTrustContext(row.trust_context),
+        created_at: row.created_at ?? 0,
+        updated_at: row.updated_at ??
+            row.created_at ??
+            0,
+        event_date: typeof row.event_date === 'string' ? row.event_date : null,
+        event_datetime: typeof row.event_datetime === 'number' && Number.isFinite(row.event_datetime)
+            ? row.event_datetime
+            : null,
+    };
+}
+function memoryLexicalScore(memory, query) {
+    const tokens = (0, api_js_1.getLexicalQueryTokens)(query);
+    if (tokens.length === 0) {
+        return 1;
+    }
+    const haystack = [memory.topic, memory.summary, memory.details].join(' ').toLowerCase();
+    const phraseBoost = haystack.includes(query.toLowerCase()) ? 2 : 0;
+    return tokens.reduce((score, token) => (haystack.includes(token) ? score + 1 : score), phraseBoost);
+}
+function memoryLexicalWhereClause(tokens) {
+    if (tokens.length === 0) {
+        return null;
+    }
+    const fields = [
+        "LOWER(COALESCE(d.topic, ''))",
+        "LOWER(COALESCE(d.summary, ''))",
+        "LOWER(COALESCE(d.decision, ''))",
+        "LOWER(COALESCE(d.reasoning, ''))",
+    ];
+    return `(${tokens
+        .map(() => `(${fields.map((field) => `instr(${field}, ?) > 0`).join(' OR ')})`)
+        .join(' OR ')})`;
+}
+function pushMemoryLexicalParams(params, tokens) {
+    for (const token of tokens) {
+        const normalized = token.toLowerCase();
+        params.push(normalized, normalized, normalized, normalized);
+    }
+}
+function memoryTimestampSql() {
+    return 'COALESCE(d.event_datetime, d.updated_at, d.created_at)';
+}
+const OPERATIONAL_MEMORY_LABELS = [
+    'dashboard_briefing',
+    'dashboard-briefing',
+    'wiki_compilation',
+    'wiki-compilation',
+    'system-audit',
+    'system_audit',
+];
+function isOperationalMemoryTopic(topic) {
+    const normalized = topic.trim().toLowerCase();
+    return (OPERATIONAL_MEMORY_LABELS.some((label) => normalized === label || normalized.startsWith(`${label}_`)) ||
+        normalized.startsWith('audit_') ||
+        normalized.startsWith('audit-'));
+}
+function taskRequestsOperationalMemory(task) {
+    const normalized = task.toLowerCase();
+    return (OPERATIONAL_MEMORY_LABELS.some((label) => normalized.includes(label)) ||
+        normalized.includes('audit log') ||
+        normalized.includes('audit-log') ||
+        normalized.includes('raw audit'));
+}
+function adapterScopedRecallMemory(adapter, input) {
+    if (!tableExists(adapter, 'decisions')) {
+        throw new Error('Context compile memory reader requires a migrated memory database with a decisions table.');
+    }
+    const scopes = input.scopes ?? [];
+    const params = [];
+    const joins = [];
+    const where = [
+        `(d.status IS NULL OR d.status NOT IN (${[...EXCLUDED_MEMORY_STATUSES].map(() => '?').join(', ')}))`,
+    ];
+    const lexicalTokens = (0, api_js_1.getLexicalQueryTokens)(input.task);
+    params.push(...EXCLUDED_MEMORY_STATUSES);
+    if (scopes.length > 0) {
+        const includesLegacyGlobalSystem = scopes.some((scope) => scope.kind === 'global' && scope.id === 'system');
+        joins.push(includesLegacyGlobalSystem
+            ? 'LEFT JOIN memory_scope_bindings msb ON msb.memory_id = d.id'
+            : 'JOIN memory_scope_bindings msb ON msb.memory_id = d.id');
+        joins.push(includesLegacyGlobalSystem
+            ? 'LEFT JOIN memory_scopes ms ON ms.id = msb.scope_id'
+            : 'JOIN memory_scopes ms ON ms.id = msb.scope_id');
+        // Records written before the 'global'/'system' alignment shipped with id
+        // 'global'. Match both ids when the request includes the global-system
+        // sentinel so legacy records remain visible.
+        const scopeClauses = [];
+        const scopeParams = [];
+        for (const scope of scopes) {
+            if (scope.kind === 'global' && scope.id === 'system') {
+                scopeClauses.push('(ms.kind = ? AND ms.external_id IN (?, ?))');
+                scopeParams.push('global', 'system', 'global');
+            }
+            else {
+                scopeClauses.push('(ms.kind = ? AND ms.external_id = ?)');
+                scopeParams.push(scope.kind, scope.id);
+            }
+        }
+        const scopeMatch = scopeClauses.join(' OR ');
+        where.push(includesLegacyGlobalSystem
+            ? `((${scopeMatch}) OR NOT EXISTS (SELECT 1 FROM memory_scope_bindings legacy_msb WHERE legacy_msb.memory_id = d.id))`
+            : `(${scopeMatch})`);
+        params.push(...scopeParams);
+    }
+    const lexicalWhere = memoryLexicalWhereClause(lexicalTokens);
+    if (lexicalWhere) {
+        where.push(lexicalWhere);
+        pushMemoryLexicalParams(params, lexicalTokens);
+    }
+    const min = minVisibleTimeMs(input);
+    const max = maxVisibleTimeMs(input);
+    const timestampSql = memoryTimestampSql();
+    if (min !== null) {
+        where.push(`${timestampSql} >= ?`);
+        params.push(min);
+    }
+    if (max !== null) {
+        where.push(`${timestampSql} <= ?`);
+        params.push(max);
+    }
+    const rows = adapter
+        .prepare(`
+        SELECT DISTINCT d.id, d.topic, d.decision, d.reasoning, d.confidence, d.created_at,
+               d.updated_at, d.trust_context, d.kind, d.status, d.summary, d.event_date,
+               d.event_datetime
+        FROM decisions d
+        ${joins.join('\n        ')}
+        WHERE ${where.join('\n          AND ')}
+        ORDER BY ${timestampSql} DESC, d.created_at DESC
+        LIMIT ?
+      `)
+        .all(...params, Math.max(normalizeLimit(input.limit) * 5, normalizeLimit(input.limit)));
+    const scopeMap = loadScopesForMemoryIds(adapter, rows.map((row) => String(row.id)));
+    const memories = rows
+        .map((row) => memoryRecordFromRow(row, scopeMap.get(String(row.id)) ?? []))
+        .map((memory) => ({ memory, score: memoryLexicalScore(memory, input.task) }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        return (memoryTimestampMs(right.memory) ?? 0) - (memoryTimestampMs(left.memory) ?? 0);
+    })
+        .slice(0, normalizeLimit(input.limit))
+        .map(({ memory, score }) => ({
+        ...memory,
+        confidence: Math.max(memory.confidence, Math.min(0.95, 0.45 + score * 0.05)),
+        retrieval_diagnostics: {
+            retrieval_source: 'context_compile_adapter',
+            vector_similarity: null,
+            lexical_support: true,
+            entity_support: false,
+            scope_support: scopes.length > 0,
+            graph_source: null,
+            is_vector_only: false,
+            confirmation_signals: ['lexical'],
+            metadata_signals: ['adapter_scoped'],
+            candidate_threshold_used: 0,
+        },
+    }));
+    return {
+        profile: { static: [], dynamic: [], evidence: [] },
+        memories,
+        graph_context: { primary: memories, expanded: [], edges: [] },
+        search_meta: {
+            query: input.task,
+            scope_order: scopes.map((scope) => scope.kind),
+            retrieval_sources: ['context_compile_adapter'],
+        },
+    };
+}
+function resultFromCandidates(candidates, hidden) {
+    const visible = candidates.filter((candidate) => candidate.visible);
+    for (const candidate of candidates) {
+        if (!candidate.visible) {
+            incrementHidden(hidden, candidate.ref, candidate.hidden_reason ?? 'hidden');
+        }
+    }
+    return {
+        candidates: visible,
+        hidden,
+        source_refs: sourceRefsFromCandidates(visible),
+    };
+}
+function sourceRefsFromCandidates(candidates) {
+    const refs = new Map();
+    for (const candidate of candidates) {
+        if (!candidate.visible) {
+            continue;
+        }
+        refs.set((0, ref_js_1.serializeContextRefForProvenance)(candidate.ref), candidate.ref);
+    }
+    return [...refs.values()];
+}
+async function readMemoryCandidates(input, deps = {}) {
+    const effectiveInput = normalizeTimeFilters(applyBoundaryDefaults(input));
+    if (effectiveInput.boundary) {
+        (0, visibility_js_1.assertContextBoundaryAllowsInput)({
+            boundary: effectiveInput.boundary,
+            requestedScopes: effectiveInput.scopes,
+            requestedConnectors: effectiveInput.connectors,
+            requestedProjectRefs: effectiveInput.project_refs,
+            requestedTenantId: effectiveInput.tenant_id,
+        });
+    }
+    if (Array.isArray(effectiveInput.scopes) && effectiveInput.scopes.length === 0) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    const recallOptions = {
+        scopes: effectiveInput.scopes,
+        limit: normalizeLimit(effectiveInput.limit),
+        diagnostics: true,
+        strictness: effectiveInput.strictness,
+        threshold: effectiveInput.threshold,
+        ...(effectiveInput.range ? { range: effectiveInput.range } : {}),
+        ...(effectiveInput.as_of !== undefined ? { as_of: effectiveInput.as_of } : {}),
+    };
+    const bundle = deps.recallMemory
+        ? await deps.recallMemory(effectiveInput.task, recallOptions)
+        : deps.adapter
+            ? adapterScopedRecallMemory(deps.adapter, effectiveInput)
+            : await (0, api_js_1.recallMemory)(effectiveInput.task, recallOptions);
+    const candidates = [];
+    const hidden = hiddenAggregate();
+    const requiresTime = timeFilterRequired(effectiveInput);
+    const allowOperationalMemory = taskRequestsOperationalMemory(effectiveInput.task);
+    for (const memory of bundle.memories) {
+        const ref = { kind: 'memory', id: memory.id };
+        if (!allowOperationalMemory && isOperationalMemoryTopic(memory.topic)) {
+            candidates.push(hiddenCandidate(ref, 'memory', 'operational_summary'));
+            continue;
+        }
+        const timestampMs = memoryTimestampMs(memory);
+        if (timestampMs === null && requiresTime) {
+            candidates.push(hiddenCandidate(ref, 'memory', 'timestamp_missing'));
+            continue;
+        }
+        if (timestampMs !== null && !isWithinTimeBoundary(timestampMs, effectiveInput)) {
+            candidates.push(hiddenCandidate(ref, 'memory', 'time_boundary'));
+            continue;
+        }
+        const diagnostics = diagnosticsFromUnknown(memory.retrieval_diagnostics);
+        candidates.push({
+            ref,
+            title: memory.topic || memory.summary || memory.id,
+            excerpt: memory.summary || memory.details || '',
+            score: typeof memory.confidence === 'number' ? memory.confidence : 0,
+            timestamp_ms: timestampMs,
+            source: 'memory',
+            visible: true,
+            support: supportFromDiagnostics(diagnostics),
+            ...(diagnostics ? { retrieval_diagnostics: diagnostics } : {}),
+        });
+    }
+    return resultFromCandidates(candidates, hidden);
+}
+function hiddenCandidate(ref, source, hiddenReason) {
+    return {
+        ref,
+        title: '',
+        excerpt: '',
+        score: 0,
+        timestamp_ms: null,
+        source,
+        visible: false,
+        hidden_reason: hiddenReason,
+        support: emptySupport(),
+    };
+}
+function readRawCandidates(adapter, input) {
+    const effectiveInput = normalizeTimeFilters(applyBoundaryDefaults(input));
+    if (effectiveInput.boundary) {
+        (0, visibility_js_1.assertContextBoundaryAllowsInput)({
+            boundary: effectiveInput.boundary,
+            requestedScopes: effectiveInput.scopes,
+            requestedConnectors: effectiveInput.connectors,
+            requestedProjectRefs: effectiveInput.project_refs,
+            requestedTenantId: effectiveInput.tenant_id,
+        });
+    }
+    if (!tableExists(adapter, 'connector_event_index')) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    const connectors = effectiveInput.connectors ?? [];
+    const scopes = effectiveInput.scopes ?? [];
+    const projectIds = (effectiveInput.project_refs ?? []).map((project) => project.id);
+    const hasGlobalSystemScope = scopes.some((scope) => scope.kind === 'global' && scope.id === 'system');
+    const hasScopedVisibility = scopes.some((scope) => !(scope.kind === 'global' && scope.id === 'system')) ||
+        projectIds.length > 0 ||
+        Boolean(effectiveInput.tenant_id);
+    const includesLegacyGlobalSystem = hasGlobalSystemScope && !hasScopedVisibility;
+    if (connectors.length === 0 ||
+        scopes.length === 0 ||
+        hasExplicitEmptyProjectWindow(effectiveInput)) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    const clauses = [`source_connector IN (${placeholders(connectors)})`];
+    const params = [...connectors];
+    if (projectIds.length > 0) {
+        const projectMatches = [`project_id IN (${placeholders(projectIds)})`];
+        if (includesLegacyGlobalSystem) {
+            projectMatches.push('project_id IS NULL');
+        }
+        clauses.push(`(${projectMatches.join(' OR ')})`);
+        params.push(...projectIds);
+    }
+    if (effectiveInput.tenant_id) {
+        clauses.push(includesLegacyGlobalSystem ? '(tenant_id = ? OR tenant_id IS NULL)' : 'tenant_id = ?');
+        params.push(effectiveInput.tenant_id);
+    }
+    // Mirror the legacy global-id handling from readMemoryCandidates: rows
+    // saved before the alignment used memory_scope_id='global'.
+    const scopeMatches = [];
+    const scopeParams = [];
+    for (const scope of scopes) {
+        if (scope.kind === 'global' && scope.id === 'system') {
+            scopeMatches.push('(memory_scope_kind = ? AND memory_scope_id IN (?, ?))');
+            scopeParams.push('global', 'system', 'global');
+        }
+        else {
+            scopeMatches.push('(memory_scope_kind = ? AND memory_scope_id = ?)');
+            scopeParams.push(scope.kind, scope.id);
+        }
+    }
+    if (includesLegacyGlobalSystem) {
+        scopeMatches.push('(memory_scope_kind IS NULL AND memory_scope_id IS NULL)');
+    }
+    clauses.push(`(${scopeMatches.join(' OR ')})`);
+    params.push(...scopeParams);
+    const min = minVisibleTimeMs(effectiveInput);
+    const max = maxVisibleTimeMs(effectiveInput);
+    if (min !== null) {
+        clauses.push('COALESCE(event_datetime, source_timestamp_ms) >= ?');
+        params.push(min);
+    }
+    if (max !== null) {
+        clauses.push('COALESCE(event_datetime, source_timestamp_ms) <= ?');
+        params.push(max);
+    }
+    params.push(normalizeLimit(effectiveInput.limit));
+    const rows = adapter
+        .prepare(`
+        SELECT event_index_id, source_connector, source_id, channel, title, content,
+               event_datetime, source_timestamp_ms
+        FROM connector_event_index
+        WHERE ${clauses.join('\n          AND ')}
+        ORDER BY COALESCE(event_datetime, source_timestamp_ms) DESC, event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    const candidates = rows.map((row) => {
+        const sourceId = typeof row.source_id === 'string' && row.source_id.trim().length > 0
+            ? row.source_id
+            : undefined;
+        const ref = {
+            kind: 'raw',
+            connector: String(row.source_connector),
+            raw_id: String(row.event_index_id),
+            ...(sourceId ? { source_id: sourceId } : {}),
+            channel_id: typeof row.channel === 'string' ? row.channel : null,
+        };
+        return {
+            ref,
+            title: String(row.title ?? 'Raw event'),
+            excerpt: String(row.content ?? '').slice(0, 500),
+            score: 0.7,
+            timestamp_ms: parseTimestampMs(row.event_datetime ?? row.source_timestamp_ms),
+            source: 'raw',
+            visible: true,
+            support: emptySupport('connector_event_index'),
+        };
+    });
+    return resultFromCandidates(candidates, hiddenAggregate());
+}
+function readGraphCandidates(adapter, input, visibleRefs, deps = {}) {
+    const effectiveInput = normalizeTimeFilters(applyBoundaryDefaults(input));
+    if (effectiveInput.boundary) {
+        (0, visibility_js_1.assertContextBoundaryAllowsInput)({
+            boundary: effectiveInput.boundary,
+            requestedScopes: effectiveInput.scopes,
+            requestedConnectors: effectiveInput.connectors,
+            requestedProjectRefs: effectiveInput.project_refs,
+            requestedTenantId: effectiveInput.tenant_id,
+        });
+    }
+    if (Array.isArray(effectiveInput.scopes) && effectiveInput.scopes.length === 0) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    if (Array.isArray(effectiveInput.connectors) && effectiveInput.connectors.length === 0) {
+        // Fail closed when caller explicitly narrowed connectors to none, so an
+        // injectable listEdges cannot leak edges back into the result.
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    if (hasExplicitEmptyProjectWindow(effectiveInput)) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    if (visibleRefs.length === 0) {
+        return resultFromCandidates([], hiddenAggregate());
+    }
+    const refs = visibleRefs.map((ref) => (0, ref_js_1.toTwinRef)(ref));
+    const visibleRefKeys = new Set(visibleRefs.map(ref_js_1.serializeContextRefForProvenance));
+    const listEdges = deps.listVisibleTwinEdgesForRefs ?? ref_validation_js_1.listVisibleTwinEdgesForRefs;
+    const min = minVisibleTimeMs(effectiveInput);
+    const max = maxVisibleTimeMs(effectiveInput);
+    const edges = listEdges(adapter, refs, {
+        scopes: effectiveInput.scopes,
+        connectors: effectiveInput.connectors,
+        projectRefs: effectiveInput.project_refs,
+        tenantId: effectiveInput.tenant_id,
+        startMs: min,
+        asOfMs: max,
+        limit: normalizeLimit(effectiveInput.limit),
+    }).filter((edge) => (min === null || edge.created_at >= min) && (max === null || edge.created_at <= max));
+    const candidates = [];
+    const emitted = new Set();
+    for (const edge of edges) {
+        for (const ref of edgeNeighborRefs(adapter, edge)) {
+            const key = (0, ref_js_1.serializeContextRefForProvenance)(ref);
+            if (visibleRefKeys.has(key) || emitted.has(key)) {
+                continue;
+            }
+            emitted.add(key);
+            candidates.push({
+                ref,
+                title: edge.edge_type,
+                excerpt: edge.reason_text ?? '',
+                score: edge.confidence,
+                timestamp_ms: edge.created_at,
+                source: 'graph',
+                visible: true,
+                edge_id: edge.edge_id,
+                edge_type: edge.edge_type,
+                support: {
+                    retrieval_source: 'twin_edges',
+                    graph_source: 'expanded',
+                    graph_expanded: true,
+                    confirmation_signals: [],
+                    metadata_signals: ['graph_edge'],
+                },
+            });
+        }
+    }
+    return resultFromCandidates(candidates, hiddenAggregate());
+}
+function edgeNeighborRefs(adapter, edge) {
+    return [edge.subject_ref, edge.object_ref].flatMap((ref) => {
+        const contextRef = contextRefFromTwinRef(adapter, ref);
+        return contextRef ? [contextRef] : [];
+    });
+}
+function contextRefFromTwinRef(adapter, ref) {
+    switch (ref.kind) {
+        case 'memory':
+        case 'entity':
+        case 'case':
+            return { kind: ref.kind, id: ref.id };
+        case 'raw': {
+            const row = adapter
+                .prepare(`
+            SELECT source_connector, source_id, channel
+            FROM connector_event_index
+            WHERE event_index_id = ?
+            LIMIT 1
+          `)
+                .get(ref.id);
+            if (!row || typeof row.source_connector !== 'string') {
+                return null;
+            }
+            const contextRef = {
+                kind: 'raw',
+                connector: row.source_connector,
+                raw_id: ref.id,
+            };
+            if (typeof row.source_id === 'string' && row.source_id.trim().length > 0) {
+                contextRef.source_id = row.source_id;
+            }
+            contextRef.channel_id = typeof row.channel === 'string' ? row.channel : null;
+            return contextRef;
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=source-readers.js.map