@jungjaehoon/mama-core 1.8.1 → 2.0.0

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[];

package/dist/context-compile/visibility.js

@@ -8,6 +8,7 @@ exports.normalizeSeedRefs = normalizeSeedRefs;
 const node_crypto_1 = require("node:crypto");
 const types_js_1 = require("../memory/types.js");
 const ref_js_1 = require("./ref.js");
+const channel_grant_js_1 = require("./channel-grant.js");
 const SCOPE_ORDER = {
     project: 0,
     channel: 1,
@@ -110,13 +111,36 @@ function assertContextBoundaryAllowsInput(input) {
         throw new Error('Requested tenant is outside the context boundary');
     }
     const seedRefs = (0, ref_js_1.normalizeContextRefs)(input.seedRefs);
-    assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary);
-}
-function assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary) {
+    assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary, input.boundary.channels);
+}
+/**
+ * A seed ref must satisfy the same visibility rule as a row the reader would have returned.
+ *
+ * The connector check alone was never enough, and once raw visibility is decided by
+ * (connector, channel) it is plainly not: a caller could name the raw id of an event in an
+ * ungranted channel and have its identifiers - upstream source id and channel - come back
+ * in the packet's source_refs, which is then persisted. That is a citation path reaching
+ * past the reading path, the exact asymmetry this rebuild exists to remove.
+ *
+ * The channel is checked only when the boundary carries a grant. Without one there is no
+ * channel rule to enforce and the connector check stands, unchanged.
+ */
+function assertSeedRefsAllowed(seedRefs, boundaryConnectors, hasConnectorBoundary, channelGrant) {
     for (const ref of seedRefs) {
-        if (ref.kind === 'raw' && hasConnectorBoundary && !boundaryConnectors.has(ref.connector)) {
+        if (ref.kind !== 'raw')
+            continue;
+        if (hasConnectorBoundary && !boundaryConnectors.has(ref.connector)) {
             throw new Error(`Seed raw ref connector is outside the context boundary: ${ref.connector}`);
         }
+        if (!channelGrant)
+            continue;
+        // Calls the shared rule rather than re-deriving membership. An inline re-derivation
+        // here already disagreed with it on the empty-channel case, which is how a fourth copy
+        // of a decision starts: not by being written as a copy, but by being written as
+        // "obviously the same check".
+        if (!(0, channel_grant_js_1.isChannelGranted)(ref.connector, ref.channel_id, channelGrant)) {
+            throw new Error(`Seed raw ref channel is outside the context boundary: ${ref.connector}`);
+        }
     }
 }
 function isRecord(value) {

package/dist/db-adapter/node-sqlite-adapter.js

@@ -613,6 +613,10 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                 }
             }
             this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_decisions_topic
+          ON decisions(topic)
+      `);
+            this.exec(`
         CREATE INDEX IF NOT EXISTS idx_decisions_envelope_hash
           ON decisions(envelope_hash)
       `);

package/dist/db-manager.d.ts

@@ -147,11 +147,6 @@ export declare function getAdapter(): DatabaseAdapter;
  */
 export declare function closeDB(): Promise<void>;
 export declare function ensureMemoryScope(kind: string, externalId: string): Promise<string>;
-export declare function bindMemoryToScope(memoryId: string, scopeId: string, isPrimary?: boolean): Promise<void>;
-export declare function listScopesForMemory(memoryId: string): Promise<Array<{
-    kind: string;
-    id: string;
-}>>;
 /**
  * Insert embedding into vector search table
  *
@@ -301,12 +296,4 @@ export declare function fts5Search(query: string, limit?: number): Promise<{
     id: string;
     rank: number;
 }[]>;
-/**
- * Re-generate all embeddings using the currently configured model.
- * Call this after changing the embedding model in config.json.
- *
- * @param onProgress - Optional callback with (completed, total) counts
- * @returns Number of embeddings regenerated
- */
-export declare function reindexEmbeddings(onProgress?: (completed: number, total: number) => void): Promise<number>;
 //# sourceMappingURL=db-manager.d.ts.map

package/dist/db-manager.js

@@ -29,8 +29,6 @@ exports.getDB = getDB;
 exports.getAdapter = getAdapter;
 exports.closeDB = closeDB;
 exports.ensureMemoryScope = ensureMemoryScope;
-exports.bindMemoryToScope = bindMemoryToScope;
-exports.listScopesForMemory = listScopesForMemory;
 exports.insertEmbedding = insertEmbedding;
 exports.vectorSearch = vectorSearch;
 exports.insertDecisionWithEmbedding = insertDecisionWithEmbedding;
@@ -43,7 +41,6 @@ exports.getDbPath = getDbPath;
 exports.resetDBState = resetDBState;
 exports.isTestMode = isTestMode;
 exports.fts5Search = fts5Search;
-exports.reindexEmbeddings = reindexEmbeddings;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const debug_logger_js_1 = require("./debug-logger.js");
@@ -262,27 +259,6 @@ async function ensureMemoryScope(kind, externalId) {
         .run(id, kind, externalId);
     return id;
 }
-async function bindMemoryToScope(memoryId, scopeId, isPrimary = false) {
-    const adapter = getAdapter();
-    adapter
-        .prepare(`
-        INSERT OR REPLACE INTO memory_scope_bindings (memory_id, scope_id, is_primary)
-        VALUES (?, ?, ?)
-      `)
-        .run(memoryId, scopeId, isPrimary ? 1 : 0);
-}
-async function listScopesForMemory(memoryId) {
-    const adapter = getAdapter();
-    return adapter
-        .prepare(`
-        SELECT ms.kind, ms.external_id AS id
-        FROM memory_scope_bindings msb
-        JOIN memory_scopes ms ON ms.id = msb.scope_id
-        WHERE msb.memory_id = ?
-        ORDER BY msb.is_primary DESC, ms.created_at ASC
-      `)
-        .all(memoryId);
-}
 /**
  * Insert embedding into vector search table
  *
@@ -811,46 +787,4 @@ async function fts5Search(query, limit = 10) {
   `);
     return stmt.all(query, limit);
 }
-/**
- * Re-generate all embeddings using the currently configured model.
- * Call this after changing the embedding model in config.json.
- *
- * @param onProgress - Optional callback with (completed, total) counts
- * @returns Number of embeddings regenerated
- */
-async function reindexEmbeddings(onProgress) {
-    const adapter = getAdapter();
-    const { generateEnhancedEmbedding } = await import('./embeddings.js');
-    const decisions = adapter
-        .prepare('SELECT rowid, topic, decision, reasoning, outcome, confidence FROM decisions')
-        .all();
-    if (typeof adapter.insertEmbedding !== 'function') {
-        throw new Error('Embedding insertion is not available on this adapter');
-    }
-    const total = decisions.length;
-    let completed = 0;
-    for (const row of decisions) {
-        try {
-            // e5 passage role (default) - stored vector
-            const embedding = await generateEnhancedEmbedding({
-                topic: row.topic,
-                decision: row.decision,
-                reasoning: row.reasoning || undefined,
-                outcome: row.outcome || undefined,
-                confidence: row.confidence ?? undefined,
-            });
-            adapter.insertEmbedding(row.rowid, embedding);
-            completed++;
-            if (onProgress && completed % 50 === 0) {
-                onProgress(completed, total);
-            }
-        }
-        catch (e) {
-            (0, debug_logger_js_1.error)(`[db-manager] Failed to reindex rowid ${row.rowid}: ${e}`);
-        }
-    }
-    onProgress?.(completed, total);
-    (0, debug_logger_js_1.info)(`[db-manager] Reindexed ${completed}/${total} embeddings`);
-    return completed;
-}
 //# sourceMappingURL=db-manager.js.map

package/dist/decision-formatter.d.ts

@@ -140,13 +140,6 @@ export declare function ensureTokenBudget(text: string, maxTokens: number): stri
  * Heuristic: ~1 token per 4 characters
  */
 export declare function estimateTokens(text: string): number;
-/**
- * Format context in Claude-friendly Instant Answer format
- *
- * Story 014.7.10: Claude-Friendly Context Formatting
- * AC #1: Instant Answer format with trust components
- */
-export declare function formatInstantAnswer(decision: DecisionForFormat | null, options?: FormatOptions): string | null;
 /**
  * Extract quick answer from decision
  */
@@ -161,10 +154,6 @@ export declare function extractCodeExample(decision: DecisionForFormat): string
  * Story 014.7.10 AC #2: Trust Context display
  */
 export declare function formatTrustContext(trustCtx: TrustContext | null | undefined): string | null;
-/**
- * Format decision as curiosity-inducing teaser
- */
-export declare function formatTeaser(decision: DecisionForFormat | null): string | null;
 /**
  * Format mama.recall() results in readable format
  */