@jungjaehoon/mama-core 1.6.0 → 1.8.1

package/db/migrations/037-create-context-packets.sql

@@ -0,0 +1,32 @@
+CREATE TABLE IF NOT EXISTS context_packets (
+  packet_id TEXT PRIMARY KEY,
+  task TEXT NOT NULL,
+  packet_json TEXT NOT NULL,
+  scope_json TEXT NOT NULL,
+  scope_hash TEXT NOT NULL,
+  envelope_hash TEXT NOT NULL,
+  model_run_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  input_snapshot_ref TEXT NOT NULL,
+  source_refs_json TEXT NOT NULL DEFAULT '[]',
+  tenant_id TEXT NOT NULL DEFAULT 'default',
+  project_id TEXT NOT NULL,
+  memory_scope_kind TEXT NOT NULL CHECK (memory_scope_kind IN ('global', 'user', 'channel', 'project')),
+  memory_scope_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL CHECK (created_at >= 0)
+);
+
+CREATE INDEX IF NOT EXISTS idx_context_packets_model_run
+  ON context_packets(model_run_id, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_context_packets_envelope
+  ON context_packets(envelope_hash, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_context_packets_scope
+  ON context_packets(tenant_id, project_id, memory_scope_kind, memory_scope_id, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_context_packets_scope_hash
+  ON context_packets(scope_hash, created_at DESC);
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (37, 'Create context packet append-only store');

package/db/migrations/038-create-vnext-operator-contracts.sql

@@ -0,0 +1,57 @@
+CREATE TABLE IF NOT EXISTS vnext_operator_cursors (
+  cursor_name TEXT PRIMARY KEY,
+  last_change_seq INTEGER NOT NULL DEFAULT 0 CHECK (last_change_seq >= 0),
+  last_idempotency_key TEXT,
+  updated_at_ms INTEGER NOT NULL CHECK (updated_at_ms >= 0)
+);
+
+CREATE TABLE IF NOT EXISTS vnext_operator_commits (
+  commit_id TEXT PRIMARY KEY,
+  cursor_name TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  first_change_seq INTEGER NOT NULL CHECK (first_change_seq >= 0),
+  last_change_seq INTEGER NOT NULL CHECK (last_change_seq >= first_change_seq),
+  status TEXT NOT NULL CHECK (status IN ('changed', 'no_update')),
+  changed_refs_json TEXT NOT NULL CHECK (json_valid(changed_refs_json)),
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+  FOREIGN KEY (cursor_name) REFERENCES vnext_operator_cursors(cursor_name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_vnext_operator_commits_cursor_seq
+  ON vnext_operator_commits(cursor_name, last_change_seq);
+
+CREATE TABLE IF NOT EXISTS operator_no_updates (
+  no_update_id TEXT PRIMARY KEY,
+  scope_key TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  idempotency_key TEXT NOT NULL UNIQUE,
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0)
+);
+
+CREATE INDEX IF NOT EXISTS idx_operator_no_updates_scope_created
+  ON operator_no_updates(scope_key, created_at_ms DESC);
+
+CREATE TABLE IF NOT EXISTS worker_proposals (
+  proposal_id TEXT PRIMARY KEY,
+  worker_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  status TEXT NOT NULL CHECK (status IN ('proposed', 'accepted', 'rejected', 'superseded')),
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+  accepted_at_ms INTEGER CHECK (
+    (status = 'proposed' AND accepted_at_ms IS NULL) OR
+    (status = 'accepted' AND accepted_at_ms IS NOT NULL AND accepted_at_ms >= created_at_ms) OR
+    (status = 'rejected' AND accepted_at_ms IS NULL) OR
+    (status = 'superseded' AND (accepted_at_ms IS NULL OR accepted_at_ms >= created_at_ms))
+  )
+);
+
+CREATE INDEX IF NOT EXISTS idx_worker_proposals_status_kind
+  ON worker_proposals(status, kind, created_at_ms);
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (38, 'Create vNext operator contracts');

package/db/migrations/039-add-connector-event-operator-ingest-seq.sql

@@ -0,0 +1,96 @@
+ALTER TABLE connector_event_index
+  ADD COLUMN operator_ingest_seq INTEGER CHECK (
+    operator_ingest_seq IS NULL OR operator_ingest_seq >= 1
+  );
+
+CREATE TABLE IF NOT EXISTS connector_event_index_operator_seq_cursors (
+  source_connector TEXT NOT NULL,
+  channel TEXT NOT NULL DEFAULT '',
+  next_seq INTEGER NOT NULL CHECK (next_seq >= 1),
+  PRIMARY KEY (source_connector, channel)
+);
+
+WITH ranked_events AS (
+  SELECT
+    event_index_id,
+    ROW_NUMBER() OVER (
+      PARTITION BY source_connector, COALESCE(channel, '')
+      ORDER BY rowid ASC
+    ) AS operator_seq
+  FROM connector_event_index
+)
+UPDATE connector_event_index
+SET operator_ingest_seq = (
+  SELECT operator_seq
+  FROM ranked_events
+  WHERE ranked_events.event_index_id = connector_event_index.event_index_id
+)
+WHERE operator_ingest_seq IS NULL;
+
+INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
+  source_connector,
+  channel,
+  next_seq
+)
+SELECT
+  source_connector,
+  COALESCE(channel, ''),
+  COALESCE(MAX(operator_ingest_seq), 0) + 1
+FROM connector_event_index
+GROUP BY source_connector, COALESCE(channel, '');
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_connector_event_index_operator_scope_seq
+  ON connector_event_index(source_connector, COALESCE(channel, ''), operator_ingest_seq)
+  WHERE operator_ingest_seq IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_connector_event_index_operator_cursor_order
+  ON connector_event_index(source_connector, channel, operator_ingest_seq);
+
+CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_operator_ingest_seq_ai
+AFTER INSERT ON connector_event_index
+WHEN NEW.operator_ingest_seq IS NULL
+BEGIN
+  INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
+    source_connector,
+    channel,
+    next_seq
+  )
+  VALUES (NEW.source_connector, COALESCE(NEW.channel, ''), 1);
+
+  UPDATE connector_event_index
+  SET operator_ingest_seq = (
+    SELECT next_seq
+    FROM connector_event_index_operator_seq_cursors
+    WHERE source_connector = NEW.source_connector
+      AND channel = COALESCE(NEW.channel, '')
+  )
+  WHERE event_index_id = NEW.event_index_id;
+
+  UPDATE connector_event_index_operator_seq_cursors
+  SET next_seq = next_seq + 1
+  WHERE source_connector = NEW.source_connector
+    AND channel = COALESCE(NEW.channel, '');
+END;
+
+CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_operator_ingest_seq_explicit_ai
+AFTER INSERT ON connector_event_index
+WHEN NEW.operator_ingest_seq IS NOT NULL
+BEGIN
+  INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
+    source_connector,
+    channel,
+    next_seq
+  )
+  VALUES (NEW.source_connector, COALESCE(NEW.channel, ''), 1);
+
+  UPDATE connector_event_index_operator_seq_cursors
+  SET next_seq = CASE
+    WHEN next_seq <= NEW.operator_ingest_seq THEN NEW.operator_ingest_seq + 1
+    ELSE next_seq
+  END
+  WHERE source_connector = NEW.source_connector
+    AND channel = COALESCE(NEW.channel, '');
+END;
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (39, 'Add connector event operator ingest sequence');

package/db/migrations/040-create-operator-memory-commit-intents.sql

@@ -0,0 +1,19 @@
+CREATE TABLE IF NOT EXISTS operator_memory_commit_intents (
+  intent_id TEXT PRIMARY KEY,
+  cursor_name TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  expected_memory_count INTEGER NOT NULL CHECK (expected_memory_count > 0),
+  memory_payload_hash TEXT NOT NULL CHECK (memory_payload_hash LIKE 'sha256:%'),
+  memory_ids_json TEXT NOT NULL CHECK (json_valid(memory_ids_json)),
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  status TEXT NOT NULL CHECK (status IN ('pending', 'saving', 'saved', 'promoted')),
+  claim_token TEXT,
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+  updated_at_ms INTEGER NOT NULL CHECK (updated_at_ms >= created_at_ms)
+);
+
+CREATE INDEX IF NOT EXISTS idx_operator_memory_commit_intents_cursor_created
+  ON operator_memory_commit_intents(cursor_name, created_at_ms DESC);
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (40, 'Create operator memory commit intents');

package/db/migrations/041-enforce-operator-memory-commit-claim-invariant.sql

@@ -0,0 +1,74 @@
+CREATE TABLE IF NOT EXISTS operator_memory_commit_intents (
+  intent_id TEXT PRIMARY KEY,
+  cursor_name TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  expected_memory_count INTEGER NOT NULL CHECK (expected_memory_count > 0),
+  memory_payload_hash TEXT NOT NULL CHECK (memory_payload_hash LIKE 'sha256:%'),
+  memory_ids_json TEXT NOT NULL CHECK (json_valid(memory_ids_json)),
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  status TEXT NOT NULL CHECK (status IN ('pending', 'saving', 'saved', 'promoted')),
+  claim_token TEXT,
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+  updated_at_ms INTEGER NOT NULL CHECK (updated_at_ms >= created_at_ms)
+);
+
+DROP TABLE IF EXISTS operator_memory_commit_intents_v041;
+
+CREATE TABLE operator_memory_commit_intents_v041 (
+  intent_id TEXT PRIMARY KEY,
+  cursor_name TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  expected_memory_count INTEGER NOT NULL CHECK (expected_memory_count > 0),
+  memory_payload_hash TEXT NOT NULL CHECK (memory_payload_hash LIKE 'sha256:%'),
+  memory_ids_json TEXT NOT NULL CHECK (json_valid(memory_ids_json)),
+  source_refs_json TEXT NOT NULL CHECK (json_valid(source_refs_json)),
+  status TEXT NOT NULL CHECK (status IN ('pending', 'saving', 'saved', 'promoted')),
+  claim_token TEXT CHECK (
+    (status = 'saving' AND claim_token IS NOT NULL) OR
+    (status != 'saving' AND claim_token IS NULL)
+  ),
+  created_at_ms INTEGER NOT NULL CHECK (created_at_ms >= 0),
+  updated_at_ms INTEGER NOT NULL CHECK (updated_at_ms >= created_at_ms)
+);
+
+INSERT INTO operator_memory_commit_intents_v041 (
+  intent_id,
+  cursor_name,
+  idempotency_key,
+  expected_memory_count,
+  memory_payload_hash,
+  memory_ids_json,
+  source_refs_json,
+  status,
+  claim_token,
+  created_at_ms,
+  updated_at_ms
+)
+SELECT
+  intent_id,
+  cursor_name,
+  idempotency_key,
+  expected_memory_count,
+  memory_payload_hash,
+  memory_ids_json,
+  source_refs_json,
+  CASE
+    WHEN status = 'saving' AND claim_token IS NULL THEN 'pending'
+    ELSE status
+  END,
+  CASE
+    WHEN status = 'saving' AND claim_token IS NOT NULL THEN claim_token
+    ELSE NULL
+  END,
+  created_at_ms,
+  updated_at_ms
+FROM operator_memory_commit_intents;
+
+DROP TABLE operator_memory_commit_intents;
+ALTER TABLE operator_memory_commit_intents_v041 RENAME TO operator_memory_commit_intents;
+
+CREATE INDEX IF NOT EXISTS idx_operator_memory_commit_intents_cursor_created
+  ON operator_memory_commit_intents(cursor_name, created_at_ms DESC);
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (41, 'Enforce operator memory commit claim invariant');

package/db/migrations/042-embedding-prefix-scheme.sql

@@ -0,0 +1,46 @@
+-- Migration 042: track the embedding instruction-prefix scheme (e5 query/passage).
+-- Fresh DB (no stored vectors) starts current; an upgraded DB with pre-existing
+-- unprefixed vectors (in EITHER vector store) is marked legacy so the runtime guard
+-- forces a re-embed.
+--
+-- Robustness: a SQLite statement that references a missing table fails at prepare
+-- time, so a sqlite_master-gated WHERE clause alone cannot protect a reference to an
+-- absent table. Some legacy-recovery paths reach 042 with a partial schema (e.g. a DB
+-- whose schema_version was fast-forwarded past migration 030, so wiki_page_embeddings
+-- does not exist yet). We therefore CREATE IF NOT EXISTS both vector-store tables with
+-- the exact shapes of migrations 013/030 (no-op on any normally-migrated DB, empty
+-- shells on partial ones) before the marker statement references them. The runtime
+-- guard in db-manager (assertEmbeddingSchemeCurrent) independently counts both tables
+-- (try/catch-wrapped), so the two layers agree.
+
+CREATE TABLE IF NOT EXISTS embedding_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+-- Shape of migration 013 (embeddings) - no-op unless the schema is partial.
+CREATE TABLE IF NOT EXISTS embeddings (
+  rowid INTEGER PRIMARY KEY,
+  embedding BLOB NOT NULL
+);
+
+-- Shape of migration 030 (wiki_page_embeddings) - no-op unless the schema is partial.
+-- The FK to wiki_page_index resolves lazily in SQLite, so this is safe even when
+-- wiki_page_index itself is absent.
+CREATE TABLE IF NOT EXISTS wiki_page_embeddings (
+  page_id TEXT PRIMARY KEY REFERENCES wiki_page_index(page_id) ON DELETE CASCADE,
+  embedding BLOB NOT NULL
+);
+
+INSERT OR IGNORE INTO embedding_meta (key, value)
+SELECT 'embedding_prefix_scheme',
+  CASE
+    WHEN EXISTS (SELECT 1 FROM embeddings)
+      OR EXISTS (SELECT 1 FROM wiki_page_embeddings)
+    THEN 'legacy-unprefixed'
+    ELSE 'e5-prefixed-v1'
+  END;
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES (42, 'Track embedding prefix scheme (e5 query/passage)');

package/dist/cases/wiki-page-index.js

@@ -153,7 +153,7 @@ function buildFtsQuery(query) {
         .match(/[\p{L}\p{N}_]+/gu)
         ?.filter((token) => token.length > 0);
     if (!tokens || tokens.length === 0) {
-        return query;
+        return '';
     }
     return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(' OR ');
 }
@@ -264,6 +264,10 @@ function ftsSearchWikiPages(adapter, query, limit) {
     if (!searchTableExists(adapter, 'wiki_pages_fts')) {
         return [];
     }
+    const ftsQuery = buildFtsQuery(query);
+    if (!ftsQuery) {
+        return [];
+    }
     const schema = readSchema(adapter);
     const rows = adapter
         .prepare(`
@@ -273,7 +277,7 @@ function ftsSearchWikiPages(adapter, query, limit) {
         ORDER BY raw
         LIMIT ?
       `)
-        .all(buildFtsQuery(query), boundedLimit);
+        .all(ftsQuery, boundedLimit);
     const hits = [];
     for (const row of rows) {
         const record = selectByFtsPageId(adapter, schema, row.page_id);

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