@jungjaehoon/mama-core 2.4.1 → 4.1.0

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

@@ -1,840 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceRefsFromCandidates = sourceRefsFromCandidates;
-exports.readMemoryCandidates = readMemoryCandidates;
-exports.readRawCandidates = readRawCandidates;
-exports.setContextSourceClockForTests = setContextSourceClockForTests;
-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");
-const channel_grant_js_1 = require("./channel-grant.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());
-    }
-    // These guards hold on BOTH paths. An explicitly emptied project window and an empty
-    // scope list are deliberate "read nothing" requests, and the grant branch skipping them
-    // would have turned two fail-closed states into reads.
-    if ((effectiveInput.connectors ?? []).length === 0 ||
-        (effectiveInput.scopes ?? []).length === 0 ||
-        hasExplicitEmptyProjectWindow(effectiveInput)) {
-        return resultFromCandidates([], hiddenAggregate());
-    }
-    const channelGrant = effectiveInput.boundary?.channels;
-    if (channelGrant) {
-        return readRawCandidatesWithinGrant(adapter, effectiveInput, channelGrant);
-    }
-    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;
-    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);
-    return resultFromCandidates(rows.map(rawRowToCandidate), hiddenAggregate());
-}
-/**
- * Raw visibility decided by the caller's (connector, channel) grant.
- *
- * Two conditions, both necessary: the connector is granted, and the channel is one of the
- * channels granted for it. Nothing else gates a row - not project, not tenant, not the
- * derived scope columns. See ContextBoundary.channels for why those were removed rather
- * than kept alongside: measured on the live index, they hide two thirds of the corpus from
- * any caller precise enough to name a scope, and a reader that answers narrow questions
- * from nothing is worse than one that answers them from the events.
- *
- * The grant is enforced in SQL rather than filtered afterwards, so `limit` counts rows the
- * caller may actually see. Filtering after the limit silently turns "the 200 most recent
- * events" into "however many of the 200 most recent events happened to be readable".
- */
-function readRawCandidatesWithinGrant(adapter, effectiveInput, grant) {
-    const requested = effectiveInput.connectors;
-    if (Array.isArray(requested) && requested.length === 0) {
-        return resultFromCandidates([], hiddenAggregate());
-    }
-    // The rule is compiled to SQL in exactly one place (channel-grant.ts), which is also
-    // where its boolean form lives. Building the clause here a second time is how the three
-    // copies this replaces came about.
-    const granted = (0, channel_grant_js_1.channelGrantClause)(grant, requested, {
-        connector: 'source_connector',
-        channel: 'channel',
-    });
-    // No overlap between what was asked for and what is granted reads nothing. It must not
-    // fall through to an unfiltered scan.
-    if (granted === null) {
-        return resultFromCandidates([], refusedAggregate(countRefusedByGrant(adapter, effectiveInput)));
-    }
-    const clauses = [granted.sql];
-    const params = [...granted.params];
-    const min = minVisibleTimeMs(effectiveInput);
-    if (min !== null) {
-        clauses.push('COALESCE(event_datetime, source_timestamp_ms) >= ?');
-        params.push(min);
-    }
-    // EVIDENCE IS WHAT HAS ALREADY HAPPENED, so the window ends now unless the caller named
-    // a later end explicitly.
-    //
-    // Found by running this reader against a snapshot of the live index rather than against
-    // fixtures. `event_datetime` is when the event OCCURS, and a calendar entry occurs in
-    // the future: 2,762 live rows are future-dated, one of them in 2056. Ordering by that
-    // column descending gave them the entire top-100 - a report asking what happened in the
-    // last seven days received one hundred calendar entries and zero messages. Excluding
-    // them, the same query returns 99 messages and one calendar entry.
-    //
-    // Nothing caught this before because the predicate this replaces returned no rows at
-    // all, so its ordering never mattered. A caller that genuinely wants the future still
-    // gets it by setting range.end_ms or as_of past now.
-    const max = maxVisibleTimeMs(effectiveInput) ?? nowMs();
-    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);
-    return resultFromCandidates(rows.map(rawRowToCandidate), refusedAggregate(countRefusedByGrant(adapter, effectiveInput, granted)));
-}
-/**
- * How many events the grant kept out.
- *
- * Without this the caller cannot tell "this channel was quiet" from "you are not allowed to
- * see this channel", because the filtering happens in SQL and leaves no trace. That
- * distinction is the entire point: an owner asking about a board whose events are all
- * refused would otherwise get a confident empty answer with a clean diagnostics block.
- *
- * Counted in the requested connectors only - rows of connectors the run never asked about
- * are not "refused", they are simply not in question.
- */
-function countRefusedByGrant(adapter, effectiveInput, granted = null) {
-    const requested = effectiveInput.connectors ?? [];
-    if (requested.length === 0)
-        return 0;
-    const clauses = [`source_connector IN (${placeholders(requested)})`];
-    const params = [...requested];
-    if (granted !== null) {
-        // `NOT (connector = ? AND channel IN (...))` is NULL when channel is NULL, so a
-        // NULL-channel row is neither selected nor counted - it vanishes from both sides of
-        // the answer. A connector that does not populate channel would have every event
-        // refused and the count would report zero, which is precisely the confident empty
-        // answer this count exists to prevent.
-        clauses.push(`(channel IS NULL OR NOT ${granted.sql})`);
-        params.push(...granted.params);
-    }
-    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);
-    }
-    const row = adapter
-        .prepare(`SELECT COUNT(*) AS n FROM connector_event_index WHERE ${clauses.join(' AND ')}`)
-        .get(...params);
-    return Number(row?.n ?? 0);
-}
-/** Injectable only so a test can pin the boundary; production reads the clock. */
-let nowMs = () => Date.now();
-function setContextSourceClockForTests(clock) {
-    nowMs = clock;
-}
-function refusedAggregate(refused) {
-    const aggregate = hiddenAggregate();
-    if (refused > 0) {
-        aggregate.total = refused;
-        aggregate.by_kind.raw = refused;
-        aggregate.by_reason.channel_not_granted = refused;
-    }
-    return aggregate;
-}
-function rawRowToCandidate(row) {
-    const sourceId = typeof row.source_id === 'string' && row.source_id.trim().length > 0
-        ? row.source_id
-        : undefined;
-    return {
-        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,
-        },
-        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'),
-    };
-}
-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),
-        // Graph neighbours carry an excerpt, so an ungranted raw row reached through an edge
-        // would disclose content the reader itself refuses.
-        ...(effectiveInput.boundary?.channels ? { channels: effectiveInput.boundary.channels } : {}),
-    }).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