@jungjaehoon/mama-core 1.5.0 → 1.7.0

package/dist/connectors/raw-query.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchRaw = searchRaw;
+exports.searchAllRaw = searchAllRaw;
+exports.getRawById = getRawById;
+exports.getRawWindow = getRawWindow;
+const types_js_1 = require("../memory/types.js");
+const event_index_js_1 = require("./event-index.js");
+const DEFAULT_RAW_LIMIT = 25;
+const MAX_RAW_LIMIT = 100;
+const DEFAULT_WINDOW_SIZE = 5;
+const MAX_WINDOW_SIZE = 50;
+const VALID_SCOPE_KINDS = new Set(types_js_1.MEMORY_SCOPE_KINDS);
+function placeholders(values) {
+    if (values.length === 0) {
+        throw new Error('Cannot build SQL placeholders for an empty list.');
+    }
+    return values.map(() => '?').join(', ');
+}
+function normalizeLimit(value) {
+    if (value === undefined) {
+        return DEFAULT_RAW_LIMIT;
+    }
+    return Math.min(MAX_RAW_LIMIT, Math.max(0, Math.floor(value)));
+}
+function normalizeWindowSize(value) {
+    if (value === undefined) {
+        return DEFAULT_WINDOW_SIZE;
+    }
+    return Math.min(MAX_WINDOW_SIZE, Math.max(0, Math.floor(value)));
+}
+function escapeFtsQuery(query) {
+    return `"${query.replace(/"/g, '""')}"`;
+}
+function encodeCursor(row) {
+    return Buffer.from(JSON.stringify({
+        rank: row.rank,
+        timestampMs: row.source_timestamp_ms,
+        rawId: row.event_index_id,
+    }), 'utf8').toString('base64url');
+}
+function decodeCursor(cursor) {
+    if (!cursor) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (typeof parsed.rank !== 'number' ||
+            !Number.isFinite(parsed.rank) ||
+            typeof parsed.timestampMs !== 'number' ||
+            !Number.isFinite(parsed.timestampMs) ||
+            typeof parsed.rawId !== 'string' ||
+            parsed.rawId.length === 0) {
+            throw new Error('invalid shape');
+        }
+        return {
+            rank: parsed.rank,
+            timestampMs: parsed.timestampMs,
+            rawId: parsed.rawId,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid raw search cursor: ${message}`);
+    }
+}
+function normalizeConnectors(connectors) {
+    return [...new Set((connectors ?? []).map((connector) => connector.trim()).filter(Boolean))];
+}
+function normalizeScopes(scopes) {
+    return (scopes ?? [])
+        .map((scope) => {
+        const kind = scope.kind.trim();
+        if (!VALID_SCOPE_KINDS.has(kind)) {
+            throw new Error(`Invalid raw search scope kind: ${kind}`);
+        }
+        return { kind: kind, id: scope.id.trim() };
+    })
+        .filter((scope) => scope.id.length > 0);
+}
+function appendFilters(clauses, params, input, alias = 'e') {
+    const connectors = normalizeConnectors(input.connectors);
+    if (connectors.length > 0) {
+        clauses.push(`${alias}.source_connector IN (${placeholders(connectors)})`);
+        params.push(...connectors);
+    }
+    const scopes = normalizeScopes(input.scopes);
+    if (scopes.length > 0) {
+        clauses.push(`(${scopes.map(() => `(${alias}.memory_scope_kind = ? AND ${alias}.memory_scope_id = ?)`).join(' OR ')})`);
+        for (const scope of scopes) {
+            params.push(scope.kind, scope.id);
+        }
+    }
+    if (input.fromMs !== undefined) {
+        clauses.push(`${alias}.source_timestamp_ms >= ?`);
+        params.push(input.fromMs);
+    }
+    if (input.toMs !== undefined) {
+        clauses.push(`${alias}.source_timestamp_ms <= ?`);
+        params.push(input.toMs);
+    }
+}
+function appendCursorFilter(clauses, params, cursor) {
+    if (!cursor) {
+        return;
+    }
+    clauses.push(`(rank > ? OR (rank = ? AND source_timestamp_ms < ?) OR ` +
+        `(rank = ? AND source_timestamp_ms = ? AND event_index_id > ?))`);
+    params.push(cursor.rank, cursor.rank, cursor.timestampMs, cursor.rank, cursor.timestampMs, cursor.rawId);
+}
+function parseMetadata(metadataJson) {
+    if (!metadataJson) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(metadataJson);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function contentPreview(content) {
+    const compact = content.replace(/\s+/g, ' ').trim();
+    return compact.length > 240 ? `${compact.slice(0, 237)}...` : compact;
+}
+function scoreFromRank(rank) {
+    return Number.isFinite(rank) ? 1 / (1 + Math.exp(rank)) : 0;
+}
+function timestampToIso(timestampMs) {
+    if (timestampMs === null || !Number.isFinite(timestampMs)) {
+        return null;
+    }
+    return new Date(timestampMs).toISOString();
+}
+function toRawHit(row) {
+    const record = (0, event_index_js_1.mapConnectorEventIndexRecord)(row);
+    return {
+        raw_id: record.event_index_id,
+        connector: record.source_connector,
+        source_id: record.source_id,
+        channel_id: record.channel,
+        author_label: record.author,
+        created_at: timestampToIso(record.event_datetime ?? record.source_timestamp_ms),
+        content_preview: contentPreview(record.content),
+        score: scoreFromRank(Number(row.rank)),
+        source_ref: record.source_locator ?? record.artifact_locator,
+        metadata: parseMetadata(record.metadata_json),
+    };
+}
+function runSearch(adapter, input) {
+    const query = input.query.trim();
+    if (query.length === 0) {
+        return { hits: [], next_cursor: null };
+    }
+    const limit = normalizeLimit(input.limit);
+    if (limit === 0) {
+        return { hits: [], next_cursor: null };
+    }
+    const params = [escapeFtsQuery(query)];
+    const clauses = [];
+    appendFilters(clauses, params, input);
+    const cursor = decodeCursor(input.cursor);
+    const outerClauses = [];
+    const outerParams = [];
+    appendCursorFilter(outerClauses, outerParams, cursor);
+    const whereSql = clauses.length > 0 ? `AND ${clauses.join(' AND ')}` : '';
+    const cursorSql = outerClauses.length > 0 ? `WHERE ${outerClauses.join(' AND ')}` : '';
+    const rows = adapter
+        .prepare(`
+        WITH ranked AS (
+          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 ?
+            ${whereSql}
+        )
+        SELECT *
+        FROM ranked
+        ${cursorSql}
+        ORDER BY rank ASC, source_timestamp_ms DESC, event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params, ...outerParams, limit + 1);
+    const pageRows = rows.slice(0, limit);
+    const nextRow = rows.length > limit ? pageRows[pageRows.length - 1] : undefined;
+    return {
+        hits: pageRows.map(toRawHit),
+        next_cursor: nextRow
+            ? encodeCursor({
+                rank: Number(nextRow.rank),
+                source_timestamp_ms: Number(nextRow.source_timestamp_ms),
+                event_index_id: String(nextRow.event_index_id),
+            })
+            : null,
+    };
+}
+function searchRaw(adapter, input) {
+    const connectors = normalizeConnectors(input.connectors);
+    if (connectors.length !== 1) {
+        throw new Error('searchRaw requires exactly one connector filter.');
+    }
+    return runSearch(adapter, { ...input, connectors });
+}
+function searchAllRaw(adapter, input) {
+    return runSearch(adapter, input);
+}
+function getRawById(adapter, rawId, visibility) {
+    const params = [rawId];
+    const clauses = ['e.event_index_id = ?'];
+    appendFilters(clauses, params, { query: '*', ...visibility });
+    const row = adapter
+        .prepare(`
+        SELECT e.*, 0 AS rank
+        FROM connector_event_index e
+        WHERE ${clauses.join(' AND ')}
+        LIMIT 1
+      `)
+        .get(...params);
+    return row ? toRawHit(row) : null;
+}
+function getRawWindow(adapter, rawId, input) {
+    const targetParams = [rawId];
+    const targetClauses = ['e.event_index_id = ?'];
+    appendFilters(targetClauses, targetParams, {
+        query: '*',
+        connectors: input.connectors,
+        scopes: input.scopes,
+    });
+    const targetRow = adapter
+        .prepare(`
+        SELECT e.*, 0 AS rank
+        FROM connector_event_index e
+        WHERE ${targetClauses.join(' AND ')}
+        LIMIT 1
+      `)
+        .get(...targetParams);
+    if (!targetRow) {
+        return null;
+    }
+    const target = (0, event_index_js_1.mapConnectorEventIndexRecord)(targetRow);
+    const before = normalizeWindowSize(input.before);
+    const after = normalizeWindowSize(input.after);
+    const beforeRows = beforeWindowRows(adapter, target, input, before);
+    const afterRows = afterWindowRows(adapter, target, input, after);
+    const targetHit = toRawHit(targetRow);
+    return {
+        target: targetHit,
+        items: [...beforeRows.reverse().map(toRawHit), targetHit, ...afterRows.map(toRawHit)],
+    };
+}
+function beforeWindowRows(adapter, target, input, limit) {
+    if (limit === 0) {
+        return [];
+    }
+    const params = [target.source_connector, target.channel, target.source_timestamp_ms];
+    const clauses = [
+        'e.source_connector = ?',
+        target.channel === null ? 'e.channel IS ?' : 'e.channel = ?',
+        'e.source_timestamp_ms < ?',
+    ];
+    appendFilters(clauses, params, {
+        query: '*',
+        connectors: input.connectors,
+        scopes: input.scopes,
+    });
+    return adapter
+        .prepare(`
+        SELECT e.*, 0 AS rank
+        FROM connector_event_index e
+        WHERE ${clauses.join(' AND ')}
+        ORDER BY e.source_timestamp_ms DESC, e.event_index_id DESC
+        LIMIT ?
+      `)
+        .all(...params, limit);
+}
+function afterWindowRows(adapter, target, input, limit) {
+    if (limit === 0) {
+        return [];
+    }
+    const params = [target.source_connector, target.channel, target.source_timestamp_ms];
+    const clauses = [
+        'e.source_connector = ?',
+        target.channel === null ? 'e.channel IS ?' : 'e.channel = ?',
+        'e.source_timestamp_ms > ?',
+    ];
+    appendFilters(clauses, params, {
+        query: '*',
+        connectors: input.connectors,
+        scopes: input.scopes,
+    });
+    return adapter
+        .prepare(`
+        SELECT e.*, 0 AS rank
+        FROM connector_event_index e
+        WHERE ${clauses.join(' AND ')}
+        ORDER BY e.source_timestamp_ms ASC, e.event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params, limit);
+}
+//# sourceMappingURL=raw-query.js.map

package/dist/connectors/types.d.ts

@@ -1,4 +1,5 @@
 import type { Buffer } from 'node:buffer';
+import type { MemoryScopeRef } from '../memory/types.js';
 export interface ConnectorEventIndexRecord {
     event_index_id: string;
     source_connector: string;
@@ -12,6 +13,11 @@ export interface ConnectorEventIndexRecord {
     event_datetime: number | null;
     event_date: string | null;
     source_timestamp_ms: number;
+    source_cursor: string | null;
+    tenant_id: string | null;
+    project_id: string | null;
+    memory_scope_kind: string | null;
+    memory_scope_id: string | null;
     metadata_json: string | null;
     artifact_locator: string | null;
     artifact_title: string | null;
@@ -32,6 +38,11 @@ export interface UpsertConnectorEventIndexInput {
     event_datetime?: number | null;
     event_date?: string | null;
     source_timestamp_ms?: number | null;
+    source_cursor?: string | null;
+    tenant_id?: string | null;
+    project_id?: string | null;
+    memory_scope_kind?: string | null;
+    memory_scope_id?: string | null;
     metadata_json?: string | null;
     metadata?: unknown;
     artifact_locator?: string | null;
@@ -65,5 +76,34 @@ export interface ConnectorEventSearchHit extends ConnectorEventIndexRecord {
     rank: number;
     score: number;
 }
+export interface RawSearchScopeFilter {
+    kind: MemoryScopeRef['kind'];
+    id: string;
+}
+export interface RawSearchInput {
+    query: string;
+    connectors?: string[];
+    scopes?: RawSearchScopeFilter[];
+    fromMs?: number;
+    toMs?: number;
+    cursor?: string;
+    limit?: number;
+}
+export interface RawSearchHit {
+    raw_id: string;
+    connector: string;
+    source_id: string;
+    channel_id: string | null;
+    author_label: string | null;
+    created_at: string | null;
+    content_preview: string;
+    score: number;
+    source_ref: string | null;
+    metadata: Record<string, unknown>;
+}
+export interface RawSearchResult {
+    hits: RawSearchHit[];
+    next_cursor: string | null;
+}
 export type ConnectorEventStalenessStatus = 'healthy' | 'stale-but-warming' | 'warn' | 'unhealthy' | 'never_swept';
 //# sourceMappingURL=types.d.ts.map

package/dist/context-compile/boundary-defaults.d.ts

@@ -0,0 +1,12 @@
+import type { ContextBoundary, ContextProjectRef, ContextRange } from './types.js';
+import type { MemoryScopeRef } from '../memory/types.js';
+export type ContextBoundaryReadableInput = {
+    scopes?: MemoryScopeRef[];
+    connectors?: string[];
+    project_refs?: ContextProjectRef[];
+    tenant_id?: string | null;
+    range?: ContextRange;
+    as_of?: string | number | null;
+};
+export declare function applyContextBoundaryReadDefaults<T extends ContextBoundaryReadableInput>(input: T, boundary: ContextBoundary | undefined): T;
+//# sourceMappingURL=boundary-defaults.d.ts.map

package/dist/context-compile/boundary-defaults.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyContextBoundaryReadDefaults = applyContextBoundaryReadDefaults;
+function parseBoundaryTimeMs(value, field) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            throw new Error(`Invalid context boundary ${field}: ${String(value)}`);
+        }
+        const numeric = Number(trimmed);
+        if (Number.isFinite(numeric)) {
+            return Math.floor(numeric);
+        }
+        const parsed = Date.parse(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    throw new Error(`Invalid context boundary ${field}: ${String(value)}`);
+}
+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 boundary ${field}: ${String(value)}`);
+}
+function intersectRange(range, boundaryRange) {
+    if (!boundaryRange) {
+        return range;
+    }
+    const requestedStartMs = rangeBoundaryMs(range?.start_ms, 'range.start_ms');
+    const requestedEndMs = rangeBoundaryMs(range?.end_ms, 'range.end_ms');
+    const boundaryStartMs = rangeBoundaryMs(boundaryRange.start_ms, 'boundary.range.start_ms');
+    const boundaryEndMs = rangeBoundaryMs(boundaryRange.end_ms, 'boundary.range.end_ms');
+    const startMs = requestedStartMs === null
+        ? boundaryStartMs
+        : boundaryStartMs === null
+            ? requestedStartMs
+            : Math.max(requestedStartMs, boundaryStartMs);
+    const endMs = requestedEndMs === null
+        ? boundaryEndMs
+        : boundaryEndMs === null
+            ? requestedEndMs
+            : Math.min(requestedEndMs, boundaryEndMs);
+    if (startMs === null && endMs === null) {
+        return undefined;
+    }
+    if (startMs !== null && endMs !== null && startMs > endMs) {
+        throw new RangeError(`Context boundary range is empty after intersection: start_ms ${startMs} > end_ms ${endMs}`);
+    }
+    return {
+        ...(startMs !== null ? { start_ms: startMs } : {}),
+        ...(endMs !== null ? { end_ms: endMs } : {}),
+    };
+}
+function clampAsOf(requested, boundaryAsOf) {
+    const requestedMs = parseBoundaryTimeMs(requested, 'as_of');
+    const boundaryMs = parseBoundaryTimeMs(boundaryAsOf, 'boundary.as_of');
+    if (requestedMs === null) {
+        return boundaryAsOf ?? null;
+    }
+    if (boundaryMs === null) {
+        return requested ?? null;
+    }
+    return requestedMs <= boundaryMs ? (requested ?? null) : (boundaryAsOf ?? null);
+}
+function applyContextBoundaryReadDefaults(input, boundary) {
+    if (!boundary) {
+        return input;
+    }
+    const requestedTenantId = input.tenant_id;
+    const boundaryTenantId = boundary.tenant_id;
+    if (requestedTenantId !== undefined &&
+        requestedTenantId !== null &&
+        boundaryTenantId !== undefined &&
+        boundaryTenantId !== null &&
+        requestedTenantId !== boundaryTenantId) {
+        throw new Error('Requested tenant is outside the context boundary');
+    }
+    const scopedInput = {
+        ...input,
+        scopes: input.scopes === undefined ? boundary.scopes : input.scopes,
+        connectors: input.connectors === undefined ? boundary.connectors : input.connectors,
+        project_refs: input.project_refs === undefined ? boundary.project_refs : input.project_refs,
+        range: intersectRange(input.range, boundary.range),
+        as_of: clampAsOf(input.as_of, boundary.as_of),
+    };
+    if (boundaryTenantId !== undefined || requestedTenantId !== undefined) {
+        return {
+            ...scopedInput,
+            tenant_id: boundaryTenantId !== undefined ? boundaryTenantId : requestedTenantId,
+        };
+    }
+    return scopedInput;
+}
+//# sourceMappingURL=boundary-defaults.js.map

package/dist/context-compile/compiler-policy.d.ts

@@ -0,0 +1,39 @@
+import type { ContextEvidence, ContextRef } from './types.js';
+import type { ContextCandidate, HiddenCandidateAggregate } from './source-readers.js';
+export interface ContextCompilerPolicyInput {
+    task: string;
+    candidates: ContextCandidate[];
+    hidden: HiddenCandidateAggregate;
+    limit?: number;
+    strictness?: 'recall' | 'balanced' | 'strict' | 'low' | 'medium' | 'high';
+    max_tokens?: number;
+}
+export interface ContextCompilerPolicyResult {
+    selected_evidence: ContextEvidence[];
+    source_refs: ContextRef[];
+    evidence_clusters: unknown[];
+    related_decisions: Array<{
+        memory_id: string;
+        title: string;
+    }>;
+    rejected_refs: ContextRef[];
+    rejected_summary: string[];
+    missing_context: string[];
+    caveats: string[];
+    retrieval_diagnostics: {
+        candidate_count: number;
+        selected_count: number;
+        rejected_count: number;
+        hidden: HiddenCandidateAggregate;
+        deduplicated_count: number;
+        strict_vector_only_rejected_count: number;
+        token_budget_rejected_count: number;
+        limit_rejected_count: number;
+        truncated_by_tokens: boolean;
+        estimated_tokens: number;
+    };
+    estimated_tokens: number;
+}
+export declare function estimateEvidenceTokens(evidence: Pick<ContextEvidence, 'title' | 'excerpt'>): number;
+export declare function applyContextCompilerPolicy(input: ContextCompilerPolicyInput): ContextCompilerPolicyResult;
+//# sourceMappingURL=compiler-policy.d.ts.map

package/dist/context-compile/compiler-policy.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateEvidenceTokens = estimateEvidenceTokens;
+exports.applyContextCompilerPolicy = applyContextCompilerPolicy;
+const ref_js_1 = require("./ref.js");
+function normalizeLimit(limit) {
+    return Math.max(0, Math.min(100, Math.floor(limit ?? 10)));
+}
+function estimateEvidenceTokens(evidence) {
+    const text = `${evidence.title ?? ''}\n${evidence.excerpt ?? ''}`;
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+function sortedCandidates(candidates) {
+    return [...candidates].sort((left, right) => {
+        const scoreDiff = right.score - left.score;
+        if (scoreDiff !== 0) {
+            return scoreDiff;
+        }
+        return (right.timestamp_ms ?? 0) - (left.timestamp_ms ?? 0);
+    });
+}
+function shouldRejectVectorOnly(candidate, strictness) {
+    return (strictness === 'strict' &&
+        candidate.support.is_vector_only === true &&
+        candidate.support.confirmation_signals.length === 0);
+}
+function evidenceFromCandidate(candidate) {
+    return {
+        ref: candidate.ref,
+        title: candidate.title,
+        excerpt: candidate.excerpt,
+        score: candidate.score,
+        reasons: [
+            ...(candidate.support.confirmation_signals ?? []),
+            ...(candidate.support.graph_expanded ? ['graph_expanded'] : []),
+        ],
+        ...(candidate.retrieval_diagnostics
+            ? { retrieval_diagnostics: candidate.retrieval_diagnostics }
+            : {}),
+    };
+}
+function addCountSummary(parts, label, count) {
+    if (count > 0) {
+        parts.push(`${label}: ${count}`);
+    }
+}
+function normalizeStrictness(strictness) {
+    switch (strictness) {
+        case 'low':
+        case 'recall':
+            return 'recall';
+        case 'high':
+        case 'strict':
+            return 'strict';
+        case 'medium':
+        case 'balanced':
+        case undefined:
+            return 'balanced';
+    }
+    return 'balanced';
+}
+function applyContextCompilerPolicy(input) {
+    const limit = normalizeLimit(input.limit);
+    const strictness = normalizeStrictness(input.strictness);
+    const maxTokens = typeof input.max_tokens === 'number' && Number.isFinite(input.max_tokens)
+        ? Math.max(0, Math.floor(input.max_tokens))
+        : null;
+    const seen = new Set();
+    const selected = [];
+    const sourceRefs = [];
+    const rejectedRefs = [];
+    const counters = {
+        deduplicated: 0,
+        strictVectorOnly: 0,
+        tokenBudget: 0,
+        limit: 0,
+    };
+    let estimatedTokens = 0;
+    for (const candidate of sortedCandidates(input.candidates)) {
+        if (!candidate.visible) {
+            continue;
+        }
+        const key = (0, ref_js_1.serializeContextRefForProvenance)(candidate.ref);
+        if (seen.has(key)) {
+            counters.deduplicated += 1;
+            rejectedRefs.push(candidate.ref);
+            continue;
+        }
+        if (shouldRejectVectorOnly(candidate, strictness)) {
+            counters.strictVectorOnly += 1;
+            rejectedRefs.push(candidate.ref);
+            continue;
+        }
+        if (selected.length >= limit) {
+            counters.limit += 1;
+            rejectedRefs.push(candidate.ref);
+            continue;
+        }
+        const evidence = evidenceFromCandidate(candidate);
+        const nextTokens = estimateEvidenceTokens(evidence);
+        if (maxTokens !== null && estimatedTokens + nextTokens > maxTokens) {
+            counters.tokenBudget += 1;
+            rejectedRefs.push(candidate.ref);
+            continue;
+        }
+        selected.push(evidence);
+        sourceRefs.push(candidate.ref);
+        seen.add(key);
+        estimatedTokens += nextTokens;
+    }
+    const rejectedSummary = [];
+    addCountSummary(rejectedSummary, 'deduplicated duplicate candidates', counters.deduplicated);
+    addCountSummary(rejectedSummary, 'strictness rejected vector-only candidates', counters.strictVectorOnly);
+    addCountSummary(rejectedSummary, 'token budget rejected candidates', counters.tokenBudget);
+    addCountSummary(rejectedSummary, 'limit rejected candidates', counters.limit);
+    const caveats = [];
+    if (input.hidden.total > 0) {
+        caveats.push(`hidden candidates omitted: ${input.hidden.total}`);
+    }
+    const relatedDecisions = selected.flatMap((evidence) => evidence.ref.kind === 'memory'
+        ? [{ memory_id: evidence.ref.id, title: evidence.title ?? evidence.ref.id }]
+        : []);
+    return {
+        selected_evidence: selected,
+        source_refs: sourceRefs,
+        evidence_clusters: [],
+        related_decisions: relatedDecisions,
+        rejected_refs: rejectedRefs,
+        rejected_summary: rejectedSummary,
+        missing_context: selected.length === 0 ? [`No visible evidence selected for task: ${input.task}`] : [],
+        caveats,
+        retrieval_diagnostics: {
+            candidate_count: input.candidates.length,
+            selected_count: selected.length,
+            rejected_count: rejectedRefs.length,
+            hidden: input.hidden,
+            deduplicated_count: counters.deduplicated,
+            strict_vector_only_rejected_count: counters.strictVectorOnly,
+            token_budget_rejected_count: counters.tokenBudget,
+            limit_rejected_count: counters.limit,
+            truncated_by_tokens: counters.tokenBudget > 0,
+            estimated_tokens: estimatedTokens,
+        },
+        estimated_tokens: estimatedTokens,
+    };
+}
+//# sourceMappingURL=compiler-policy.js.map

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

@@ -0,0 +1,18 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { ContextBoundary, ContextCompileInput, ContextPacket, ContextRef } from './types.js';
+import { type ContextSourceReadInput, type ContextSourceReadResult } from './source-readers.js';
+type ContextCompilerAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export interface ContextCompilerDeps {
+    adapter?: ContextCompilerAdapter;
+    boundary?: ContextBoundary;
+    signal?: AbortSignal;
+    deadlineMs?: number;
+    now?: () => number;
+    packetId?: () => string;
+    readMemoryCandidates?: (input: ContextSourceReadInput) => Promise<ContextSourceReadResult> | ContextSourceReadResult;
+    readRawCandidates?: (input: ContextSourceReadInput) => Promise<ContextSourceReadResult> | ContextSourceReadResult;
+    readGraphCandidates?: (input: ContextSourceReadInput, visibleRefs: readonly ContextRef[]) => Promise<ContextSourceReadResult> | ContextSourceReadResult;
+}
+export declare function compileContext(input: ContextCompileInput, deps?: ContextCompilerDeps): Promise<ContextPacket>;
+export {};
+//# sourceMappingURL=compiler.d.ts.map