@jungjaehoon/mama-core 1.9.0 → 2.1.0

package/dist/connectors/event-index.js

@@ -5,32 +5,10 @@ exports.connectorEventIndexId = connectorEventIndexId;
 exports.connectorEventContentHash = connectorEventContentHash;
 exports.upsertConnectorEventIndex = upsertConnectorEventIndex;
 exports.getConnectorEventIndexRecord = getConnectorEventIndexRecord;
-exports.listConnectorEventsByDatetimeRange = listConnectorEventsByDatetimeRange;
-exports.searchConnectorEventsByFTS = searchConnectorEventsByFTS;
 exports.readConnectorCursor = readConnectorCursor;
-exports.upsertConnectorCursor = upsertConnectorCursor;
 exports.deleteExpiredConnectorEvents = deleteExpiredConnectorEvents;
-exports.computeStalenessStatus = computeStalenessStatus;
 const node_crypto_1 = require("node:crypto");
 const canonicalize_js_1 = require("../canonicalize.js");
-const DEFAULT_RANGE_LIMIT = 100;
-const DEFAULT_SEARCH_LIMIT = 25;
-const MAX_RANGE_LIMIT = 500;
-const FIVE_MINUTES_MS = 5 * 60 * 1000;
-const FIFTEEN_MINUTES_MS = 15 * 60 * 1000;
-const SIXTY_MINUTES_MS = 60 * 60 * 1000;
-function placeholders(values) {
-    if (values.length === 0) {
-        throw new Error('Cannot build SQL placeholders for an empty list.');
-    }
-    return values.map(() => '?').join(', ');
-}
-function positiveLimit(value, fallback, max = MAX_RANGE_LIMIT) {
-    if (value === undefined) {
-        return fallback;
-    }
-    return Math.min(max, Math.max(0, Math.floor(value)));
-}
 function nowIso() {
     return new Date().toISOString();
 }
@@ -119,16 +97,6 @@ function mapConnectorCursorRow(row) {
         indexed_count: Number(row.indexed_count),
     };
 }
-function connectorFilterSql(connectors, alias = '') {
-    if (!connectors || connectors.length === 0) {
-        return '';
-    }
-    const prefix = alias.length > 0 ? `${alias}.` : '';
-    return ` AND ${prefix}source_connector IN (${placeholders(connectors)})`;
-}
-function hasOwn(input, key) {
-    return Object.prototype.hasOwnProperty.call(input, key);
-}
 function connectorEventIndexId(sourceConnector, sourceId) {
     const digest = (0, node_crypto_1.createHash)('sha1').update(`${sourceConnector}\0${sourceId}`, 'utf8').digest('hex');
     return `evt_${digest.slice(0, 16)}`;
@@ -214,59 +182,6 @@ function getConnectorEventIndexRecord(adapter, sourceConnector, sourceId) {
         .get(sourceConnector, sourceId);
     return row ? mapConnectorEventIndexRow(row) : null;
 }
-function listConnectorEventsByDatetimeRange(adapter, input) {
-    const limit = positiveLimit(input.limit, DEFAULT_RANGE_LIMIT);
-    if (limit === 0) {
-        return [];
-    }
-    const order = input.order === 'desc' ? 'DESC' : 'ASC';
-    const connectors = input.connectors?.filter(Boolean) ?? [];
-    const params = [input.fromMs, input.toMs, ...connectors, limit];
-    const rows = adapter
-        .prepare(`
-        SELECT *
-        FROM connector_event_index
-        WHERE event_datetime >= ?
-          AND event_datetime <= ?
-          ${connectorFilterSql(connectors)}
-        ORDER BY event_datetime ${order}, event_index_id ASC
-        LIMIT ?
-      `)
-        .all(...params);
-    return rows.map(mapConnectorEventIndexRow);
-}
-function searchConnectorEventsByFTS(adapter, query, options = {}) {
-    const normalizedQuery = query.trim();
-    if (normalizedQuery.length === 0) {
-        return [];
-    }
-    const limit = positiveLimit(options.limit, DEFAULT_SEARCH_LIMIT, 100);
-    if (limit === 0) {
-        return [];
-    }
-    const connectors = options.connectors?.filter(Boolean) ?? [];
-    const params = [normalizedQuery, ...connectors, limit];
-    const rows = adapter
-        .prepare(`
-        SELECT e.*, bm25(connector_event_index_fts) AS rank
-        FROM connector_event_index_fts
-        JOIN connector_event_index e
-          ON e.event_index_id = connector_event_index_fts.event_index_id
-        WHERE connector_event_index_fts MATCH ?
-          ${connectorFilterSql(connectors, 'e')}
-        ORDER BY rank ASC, e.event_datetime DESC, e.event_index_id ASC
-        LIMIT ?
-      `)
-        .all(...params);
-    return rows.map((row) => {
-        const rank = Number(row.rank);
-        return {
-            ...mapConnectorEventIndexRow(row),
-            rank,
-            score: Number.isFinite(rank) ? 1 / (1 + Math.exp(rank)) : 0,
-        };
-    });
-}
 function readConnectorCursor(adapter, connectorName) {
     const row = adapter
         .prepare(`
@@ -278,49 +193,6 @@ function readConnectorCursor(adapter, connectorName) {
         .get(connectorName);
     return row ? mapConnectorCursorRow(row) : null;
 }
-function upsertConnectorCursor(adapter, input) {
-    const current = readConnectorCursor(adapter, input.connector_name);
-    const merged = {
-        connector_name: input.connector_name,
-        last_seen_timestamp_ms: input.last_seen_timestamp_ms ?? current?.last_seen_timestamp_ms ?? 0,
-        last_seen_source_id: input.last_seen_source_id ?? current?.last_seen_source_id ?? '',
-        last_sweep_at: hasOwn(input, 'last_sweep_at')
-            ? (input.last_sweep_at ?? null)
-            : (current?.last_sweep_at ?? null),
-        last_success_at: hasOwn(input, 'last_success_at')
-            ? (input.last_success_at ?? null)
-            : (current?.last_success_at ?? null),
-        last_error: hasOwn(input, 'last_error')
-            ? (input.last_error ?? null)
-            : (current?.last_error ?? null),
-        last_error_at: hasOwn(input, 'last_error_at')
-            ? (input.last_error_at ?? null)
-            : (current?.last_error_at ?? null),
-        indexed_count: input.indexed_count ?? current?.indexed_count ?? 0,
-    };
-    adapter
-        .prepare(`
-        INSERT INTO connector_event_index_cursors (
-          connector_name, last_seen_timestamp_ms, last_seen_source_id, last_sweep_at,
-          last_success_at, last_error, last_error_at, indexed_count
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(connector_name) DO UPDATE SET
-          last_seen_timestamp_ms = excluded.last_seen_timestamp_ms,
-          last_seen_source_id = excluded.last_seen_source_id,
-          last_sweep_at = excluded.last_sweep_at,
-          last_success_at = excluded.last_success_at,
-          last_error = excluded.last_error,
-          last_error_at = excluded.last_error_at,
-          indexed_count = excluded.indexed_count
-      `)
-        .run(merged.connector_name, merged.last_seen_timestamp_ms, merged.last_seen_source_id, merged.last_sweep_at, merged.last_success_at, merged.last_error, merged.last_error_at, merged.indexed_count);
-    const saved = readConnectorCursor(adapter, input.connector_name);
-    if (!saved) {
-        throw new Error(`Failed to read connector cursor after upsert: ${input.connector_name}`);
-    }
-    return saved;
-}
 function deleteExpiredConnectorEvents(adapter, input) {
     if (!Number.isFinite(input.nowMs)) {
         throw new Error('deleteExpiredConnectorEvents.nowMs must be a finite number.');
@@ -349,33 +221,4 @@ function deleteExpiredConnectorEvents(adapter, input) {
             .run(cutoffMs);
     return { rows_deleted: result.changes };
 }
-function computeStalenessStatus(cursor, options) {
-    if (!cursor) {
-        return 'never_swept';
-    }
-    if (cursor.last_error !== null) {
-        return 'unhealthy';
-    }
-    if (cursor.last_success_at === null) {
-        return 'never_swept';
-    }
-    const lastSuccessMs = Date.parse(cursor.last_success_at);
-    if (!Number.isFinite(lastSuccessMs)) {
-        return 'unhealthy';
-    }
-    const elapsedMs = options.nowMs - lastSuccessMs;
-    const staleAfterMs = options.staleAfterMs ?? FIVE_MINUTES_MS;
-    const warnAfterMs = options.stalenessWarnAfterMs ?? FIFTEEN_MINUTES_MS;
-    const unhealthyAfterMs = options.unhealthyAfterMs ?? SIXTY_MINUTES_MS;
-    if (elapsedMs > unhealthyAfterMs) {
-        return 'unhealthy';
-    }
-    if (elapsedMs > warnAfterMs) {
-        return 'warn';
-    }
-    if (elapsedMs > staleAfterMs) {
-        return 'stale-but-warming';
-    }
-    return 'healthy';
-}
 //# sourceMappingURL=event-index.js.map

package/dist/context-compile/channel-grant.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The raw visibility rule, in one place.
+ *
+ * There were three copies of this decision. The reader had one, twin-ref validation had a
+ * second, and the standalone citation path had a third that carried a comment promising it
+ * reproduced the reader "clause for clause" - which it did, until the reader changed. The
+ * differential test that was supposed to catch that kept passing, because its fixtures
+ * never exercised the branch production takes. Copies pinned by a test are still copies;
+ * the test just tells you later.
+ *
+ * So the rule lives here, and everything that needs it takes it from here. It has to exist
+ * in two compiled forms - a boolean for checking one row you already hold, and SQL for
+ * selecting rows you do not - and those two forms are adjacent in this file with a
+ * differential over a matrix that includes what production sends. Two forms of one rule is
+ * the irreducible minimum; three copies of a decision is not.
+ */
+/** Connector -> the channels of it that may be read. */
+export type ChannelGrant = Record<string, readonly string[]>;
+/**
+ * The rule: an event is visible when its connector is granted and its channel is one of
+ * the channels granted for that connector.
+ *
+ * A connector absent from the grant is denied. A connector present with an empty list is
+ * also denied - "granted the connector but no channel of it" is not a useful state, and
+ * reading it as "all channels" is how a grant becomes a wildcard.
+ */
+export declare function isChannelGranted(connector: string, channel: string | null | undefined, grant: ChannelGrant): boolean;
+export interface ChannelGrantClause {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * The same rule as a SQL predicate.
+ *
+ * Returns null when nothing is readable, which callers must treat as "select nothing"
+ * rather than "no filter" - an empty WHERE is how a visibility rule turns into a full scan
+ * at the exact moment it should have refused.
+ *
+ * `requestedConnectors` narrows further: a connector the caller did not ask for is not read
+ * even though it is granted. The grant is a ceiling, never an instruction.
+ */
+export declare function channelGrantClause(grant: ChannelGrant, requestedConnectors: readonly string[] | undefined, columns: {
+    connector: string;
+    channel: string;
+}): ChannelGrantClause | null;
+//# sourceMappingURL=channel-grant.d.ts.map

package/dist/context-compile/channel-grant.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * The raw visibility rule, in one place.
+ *
+ * There were three copies of this decision. The reader had one, twin-ref validation had a
+ * second, and the standalone citation path had a third that carried a comment promising it
+ * reproduced the reader "clause for clause" - which it did, until the reader changed. The
+ * differential test that was supposed to catch that kept passing, because its fixtures
+ * never exercised the branch production takes. Copies pinned by a test are still copies;
+ * the test just tells you later.
+ *
+ * So the rule lives here, and everything that needs it takes it from here. It has to exist
+ * in two compiled forms - a boolean for checking one row you already hold, and SQL for
+ * selecting rows you do not - and those two forms are adjacent in this file with a
+ * differential over a matrix that includes what production sends. Two forms of one rule is
+ * the irreducible minimum; three copies of a decision is not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isChannelGranted = isChannelGranted;
+exports.channelGrantClause = channelGrantClause;
+/**
+ * The rule: an event is visible when its connector is granted and its channel is one of
+ * the channels granted for that connector.
+ *
+ * A connector absent from the grant is denied. A connector present with an empty list is
+ * also denied - "granted the connector but no channel of it" is not a useful state, and
+ * reading it as "all channels" is how a grant becomes a wildcard.
+ */
+function isChannelGranted(connector, channel, grant) {
+    if (typeof channel !== 'string' || channel.length === 0)
+        return false;
+    const channels = grant[connector];
+    return Array.isArray(channels) && channels.includes(channel);
+}
+/**
+ * The same rule as a SQL predicate.
+ *
+ * Returns null when nothing is readable, which callers must treat as "select nothing"
+ * rather than "no filter" - an empty WHERE is how a visibility rule turns into a full scan
+ * at the exact moment it should have refused.
+ *
+ * `requestedConnectors` narrows further: a connector the caller did not ask for is not read
+ * even though it is granted. The grant is a ceiling, never an instruction.
+ */
+function channelGrantClause(grant, requestedConnectors, columns) {
+    const pairs = [];
+    const params = [];
+    for (const [connector, channels] of Object.entries(grant)) {
+        if (Array.isArray(requestedConnectors) && !requestedConnectors.includes(connector))
+            continue;
+        // Array.isArray, not `?? []`: the boolean form denies a malformed grant quietly, so
+        // this one must not throw on it. Two forms of a rule that disagree on bad input have
+        // already started to be two rules.
+        if (!Array.isArray(channels))
+            continue;
+        const unique = [
+            ...new Set(channels.filter((channel) => typeof channel === 'string' && channel.length > 0)),
+        ];
+        if (unique.length === 0)
+            continue;
+        pairs.push(`(${columns.connector} = ? AND ${columns.channel} IN (${unique.map(() => '?').join(', ')}))`);
+        params.push(connector, ...unique);
+    }
+    return pairs.length === 0 ? null : { sql: `(${pairs.join(' OR ')})`, params };
+}
+//# sourceMappingURL=channel-grant.js.map

package/dist/context-compile/compiler.js

@@ -152,7 +152,7 @@ function hasSeedRefVisibilityConstraints(input, boundary) {
         input.range !== undefined ||
         (input.as_of !== undefined && input.as_of !== null));
 }
-function assertSeedRefsVisibleToInput(adapter, input, seedRefs) {
+function assertSeedRefsVisibleToInput(adapter, input, seedRefs, boundary) {
     if (seedRefs.length === 0) {
         return [];
     }
@@ -179,6 +179,9 @@ function assertSeedRefsVisibleToInput(adapter, input, seedRefs) {
         tenantId: input.tenant_id,
         startMs: minVisibleMs(input),
         asOfMs: maxVisibleMs(input),
+        // Without this a caller could seed a raw id from a channel the grant refuses and have
+        // its identifiers surface in the packet - a citation path reaching past the read path.
+        ...(boundary?.channels ? { channels: boundary.channels } : {}),
     });
     for (const ref of seedRefs) {
         if (ref.kind !== 'raw') {
@@ -278,7 +281,7 @@ async function compileContext(input, deps = {}) {
         });
     }
     if (deps.adapter || hasSeedRefVisibilityConstraints(effectiveInput, boundary)) {
-        canonicalSeedRefs = assertSeedRefsVisibleToInput(deps.adapter, effectiveInput, seedRefs);
+        canonicalSeedRefs = assertSeedRefsVisibleToInput(deps.adapter, effectiveInput, seedRefs, boundary);
     }
     const canonicalScopes = (0, visibility_js_2.canonicalizeContextScopes)(effectiveInput.scopes);
     const readInput = sourceInput(effectiveInput, boundary);

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

@@ -1,5 +1,6 @@
 export * from './types.js';
 export * from './boundary-defaults.js';
+export * from './channel-grant.js';
 export * from './ref.js';
 export * from './visibility.js';
 export * from './packet-store.js';

package/dist/context-compile/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./boundary-defaults.js"), exports);
+__exportStar(require("./channel-grant.js"), exports);
 __exportStar(require("./ref.js"), exports);
 __exportStar(require("./visibility.js"), exports);
 __exportStar(require("./packet-store.js"), exports);

package/dist/context-compile/packet-store.d.ts

@@ -3,7 +3,6 @@ import type { ContextPacketRecord, TrustedContextPacketLookupInput } from './typ
 type ContextPacketAdapter = Pick<DatabaseAdapter, 'prepare'>;
 export declare function insertContextPacket(adapter: ContextPacketAdapter, packet: ContextPacketRecord): ContextPacketRecord;
 export declare function getContextPacket(adapter: ContextPacketAdapter, packetId: string): ContextPacketRecord | null;
-export declare function listContextPacketsForModelRun(adapter: ContextPacketAdapter, modelRunId: string, limit?: number): ContextPacketRecord[];
 export declare function getContextPacketForTrustedUse(adapter: ContextPacketAdapter, input: TrustedContextPacketLookupInput): ContextPacketRecord | null;
 export {};
 //# sourceMappingURL=packet-store.d.ts.map

package/dist/context-compile/packet-store.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertContextPacket = insertContextPacket;
 exports.getContextPacket = getContextPacket;
-exports.listContextPacketsForModelRun = listContextPacketsForModelRun;
 exports.getContextPacketForTrustedUse = getContextPacketForTrustedUse;
 function parseJson(row, field) {
     const value = row[field];
@@ -222,21 +221,6 @@ function getContextPacket(adapter, packetId) {
     const row = adapter.prepare('SELECT * FROM context_packets WHERE packet_id = ?').get(packetId);
     return row ? mapPacketRow(row) : null;
 }
-function listContextPacketsForModelRun(adapter, modelRunId, limit = 50) {
-    if (!Number.isFinite(limit) || limit <= 0) {
-        return [];
-    }
-    const rows = adapter
-        .prepare(`
-        SELECT *
-        FROM context_packets
-        WHERE model_run_id = ?
-        ORDER BY created_at DESC, packet_id DESC
-        LIMIT ?
-      `)
-        .all(modelRunId, Math.floor(limit));
-    return rows.map((row) => mapPacketRow(row));
-}
 function getContextPacketForTrustedUse(adapter, input) {
     const packet = getContextPacket(adapter, input.packetId);
     if (!packet) {

package/dist/context-compile/source-readers.d.ts

@@ -64,6 +64,7 @@ export interface ContextSourceReaderDeps {
 export declare function sourceRefsFromCandidates(candidates: readonly ContextCandidate[]): ContextRef[];
 export declare function readMemoryCandidates(input: ContextSourceReadInput, deps?: ContextSourceReaderDeps): Promise<ContextSourceReadResult>;
 export declare function readRawCandidates(adapter: ContextSourceAdapter, input: ContextSourceReadInput): ContextSourceReadResult;
+export declare function setContextSourceClockForTests(clock: () => number): void;
 export declare function readGraphCandidates(adapter: ContextSourceAdapter, input: ContextSourceReadInput, visibleRefs: readonly ContextRef[], deps?: ContextSourceReaderDeps): ContextSourceReadResult;
 export {};
 //# sourceMappingURL=source-readers.d.ts.map

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

@@ -3,12 +3,14 @@ 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: {} };
 }
@@ -504,6 +506,18 @@ function readRawCandidates(adapter, input) {
     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);
@@ -512,11 +526,6 @@ function readRawCandidates(adapter, input) {
         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) {
@@ -571,29 +580,150 @@ function readRawCandidates(adapter, input) {
         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 = {
+    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,
-        };
-        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());
+        },
+        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));
@@ -633,6 +763,9 @@ function readGraphCandidates(adapter, input, visibleRefs, deps = {}) {
         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();

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

@@ -49,6 +49,23 @@ export interface ContextBoundary {
     tenant_id?: string | null;
     as_of?: string | number | null;
     range?: ContextRange;
+    /**
+     * Which channels of each connector may be read, keyed by connector.
+     *
+     * When present this DECIDES raw visibility, and the scope/project/tenant clauses are not
+     * applied to raw rows. That is a deliberate replacement, not a relaxation, and the reason
+     * is measurable: on a live index of 30,671 events, `memory_scope_id` is populated on 37%
+     * of rows in three mutually incompatible namespaces, and 63% carry no scope at all - so a
+     * caller that names any specific scope loses exactly the two thirds of the corpus that
+     * were never labelled. A filter that hides most of the data from anyone precise enough to
+     * ask a narrow question is not a privacy boundary; it is a leak of a different kind, the
+     * kind where the system quietly answers from nothing.
+     *
+     * The grant is (connector, channel) because that is what the owner actually configures
+     * and what the connector actually emits. The caller computes it - this module enforces
+     * what it is given and never widens it.
+     */
+    channels?: Record<string, readonly string[]>;
 }
 export interface CanonicalContextScopes {
     scopes: MemoryScopeRef[];