@knolo/core 3.2.0 → 3.2.2

package/README.md

@@ -319,10 +319,73 @@ Properties:
 
 ---
 
-# 📄 License
+# 🕸 ClaimGraph API
 
-Apache-2.0
+`@knolo/core` includes a deterministic ClaimGraph subsystem.
+
+## Build-time config
+
+```ts
+type BuildPackOptions = {
+  graph?: {
+    enabled?: boolean; // default true
+    maxEdgesPerDoc?: number; // default 500
+  };
+};
+```
+
+## Query-time config
+
+```ts
+type QueryOptions = {
+  graph?: {
+    expand?: boolean; // default false
+    maxExtraTerms?: number; // default 12
+    predicates?: string[]; // default ['defined_as', 'is', 'mentions', 'ref']
+  };
+};
+```
+
+## Exports
 
+```ts
+import {
+  buildClaimGraph,
+  getClaimGraph,
+  applyClaimGraphLog,
+  mergeClaimGraphLogs,
+  expandQueryWithGraph,
+  createGraphLog,
+  appendOp,
+} from '@knolo/core';
+```
+
+Types:
+
+* `ClaimNode`
+* `ClaimEdge`
+* `ClaimGraph`
+* `ClaimOp`
+* `ClaimGraphLog`
+
+## Notes on determinism and bounds
+
+* Node IDs are hash-derived from normalized labels.
+* Edge IDs are hash-derived from `(from, predicate, to, evidence)`.
+* Node labels are normalized and deterministically truncated.
+* Evidence arrays are sorted + unique.
+* Node/edge arrays are sorted by ID in final graph.
+* Extraction is bounded with `maxEdgesPerDoc`.
+* Query expansion is bounded with `maxExtraTerms` and stable ordering.
 
+## Pack format note
 
+`.knolo` binary layout now supports an optional trailing ClaimGraph JSON section after existing sections.
+Runtimes that ignore unknown trailing bytes remain compatible.
+
+---
+
+# 📄 License
+
+Apache-2.0
 

package/dist/builder.d.ts

@@ -16,5 +16,9 @@ export type BuildPackOptions = {
             perVectorScale?: true;
         };
     };
+    graph?: {
+        enabled?: boolean;
+        maxEdgesPerDoc?: number;
+    };
 };
 export declare function buildPack(docs: BuildInputDoc[], opts?: BuildPackOptions): Promise<Uint8Array>;

package/dist/builder.js

@@ -9,6 +9,7 @@ import { tokenize } from './tokenize.js';
 import { getTextEncoder } from './utils/utf8.js';
 import { encodeScaleF16, quantizeEmbeddingInt8L2Norm } from './semantic.js';
 import { validateAgentRegistry } from './agent.js';
+import { buildClaimGraph } from './graph/build_claim_graph.js';
 export async function buildPack(docs, opts = {}) {
     const normalizedDocs = validateDocs(docs);
     // Prepare blocks (strip MD) and carry heading/docId for optional boosts.
@@ -23,6 +24,10 @@ export async function buildPack(docs, opts = {}) {
     const totalTokens = blockTokenLens.reduce((sum, len) => sum + len, 0);
     const avgBlockLen = blocks.length ? totalTokens / blocks.length : 1;
     const agents = normalizeAgents(opts.agents);
+    const graphEnabled = opts.graph?.enabled ?? true;
+    const claimGraph = graphEnabled
+        ? buildClaimGraph(normalizedDocs, { maxEdgesPerDoc: opts.graph?.maxEdgesPerDoc })
+        : null;
     const meta = {
         version: 3,
         stats: {
@@ -32,6 +37,15 @@ export async function buildPack(docs, opts = {}) {
             avgBlockLen,
         },
         ...(agents ? { agents } : {}),
+        ...(claimGraph
+            ? {
+                claimGraph: {
+                    version: 1,
+                    nodes: claimGraph.nodes.length,
+                    edges: claimGraph.edges.length,
+                },
+            }
+            : {}),
     };
     // Persist blocks as objects to optionally carry heading/docId/token length.
     const blocksPayload = blocks.map((b, i) => ({
@@ -54,6 +68,7 @@ export async function buildPack(docs, opts = {}) {
         ? enc.encode(JSON.stringify(semanticSection.semJson))
         : undefined;
     const semBlob = semanticSection?.semBlob;
+    const graphBytes = claimGraph ? enc.encode(JSON.stringify(claimGraph)) : undefined;
     const totalLength = 4 +
         metaBytes.length +
         4 +
@@ -64,7 +79,8 @@ export async function buildPack(docs, opts = {}) {
         blocksBytes.length +
         (semanticEnabled && semBytes && semBlob
             ? 4 + semBytes.length + 4 + semBlob.length
-            : 0);
+            : 0) +
+        (graphBytes ? 4 + graphBytes.length : 0);
     const out = new Uint8Array(totalLength);
     const dv = new DataView(out.buffer);
     let offset = 0;
@@ -98,6 +114,12 @@ export async function buildPack(docs, opts = {}) {
         dv.setUint32(offset, semBlob.length, true);
         offset += 4;
         out.set(semBlob, offset);
+        offset += semBlob.length;
+    }
+    if (graphBytes) {
+        dv.setUint32(offset, graphBytes.length, true);
+        offset += 4;
+        out.set(graphBytes, offset);
     }
     return out;
 }

package/dist/graph/build_claim_graph.d.ts

@@ -0,0 +1,5 @@
+import type { BuildInputDoc } from '../builder.js';
+import type { ClaimGraph } from './claim_graph.js';
+export declare function buildClaimGraph(docs: BuildInputDoc[], opts?: {
+    maxEdgesPerDoc?: number;
+}): ClaimGraph;

package/dist/graph/build_claim_graph.js

@@ -0,0 +1,88 @@
+import { canonicalEvidence, computeEdgeId, computeNodeId, finalizeGraph, normalizeClaimLabel, } from './claim_graph.js';
+const DEF_RE = /^([A-Za-z0-9 _-]{2,80})\s+(is|are)\s+(.{2,120})[.?!]/;
+const MD_LINK_RE = /\[([^\]]{1,200})\]\(([^)\s]{1,200})\)/g;
+const WIKI_RE = /\[\[([^\]]{1,200})\]\]/g;
+const HEADING_RE = /^(#{1,3})\s+(.+)$/gm;
+const STOPWORDS = new Set(['a', 'an', 'and', 'or', 'the', 'it', 'they', 'this', 'that', 'these', 'those']);
+export function buildClaimGraph(docs, opts = {}) {
+    const maxEdgesPerDoc = Math.max(1, opts.maxEdgesPerDoc ?? 500);
+    const nodeById = new Map();
+    const edgeById = new Map();
+    for (let i = 0; i < docs.length; i++) {
+        const doc = docs[i];
+        const docLabel = normalizeLabel(doc.id || doc.heading || `doc_${i}`);
+        const local = [];
+        for (const m of doc.text.matchAll(MD_LINK_RE)) {
+            addEdge(local, nodeById, normalizeLabel(m[1]), 'ref', normalizeLabel(m[2]), [i]);
+        }
+        for (const m of doc.text.matchAll(WIKI_RE)) {
+            addEdge(local, nodeById, docLabel, 'mentions', normalizeLabel(m[1]), [i]);
+        }
+        const headingMatches = Array.from(doc.text.matchAll(HEADING_RE));
+        for (const h of headingMatches) {
+            const headingLabel = normalizeLabel(h[2] || '');
+            const headingStart = h.index ?? 0;
+            const sentence = firstSentenceAfter(doc.text, headingStart + h[0].length);
+            if (sentence) {
+                addEdge(local, nodeById, headingLabel, 'defined_as', normalizeLabel(sentence), [i]);
+            }
+        }
+        for (const sentence of splitSentences(doc.text)) {
+            const m = sentence.match(DEF_RE);
+            if (!m)
+                continue;
+            const subject = normalizeLabel(m[1]);
+            if (!subject || isStopwordOnly(subject))
+                continue;
+            const objectSnippet = normalizeLabel(m[3]);
+            addEdge(local, nodeById, subject, 'is', objectSnippet, [i]);
+        }
+        local.sort((a, b) => a.id.localeCompare(b.id));
+        for (const edge of local.slice(0, maxEdgesPerDoc)) {
+            const existing = edgeById.get(edge.id);
+            if (existing) {
+                existing.evidence = canonicalEvidence([...(existing.evidence ?? []), ...(edge.evidence ?? [])]);
+            }
+            else {
+                edgeById.set(edge.id, edge);
+            }
+        }
+    }
+    return finalizeGraph({ version: 1, nodes: [...nodeById.values()], edges: [...edgeById.values()] });
+}
+function addEdge(local, nodeById, fromLabel, p, toLabel, evidence) {
+    if (!fromLabel || !toLabel)
+        return;
+    const fromId = ensureNode(nodeById, fromLabel);
+    const toId = ensureNode(nodeById, toLabel);
+    const edgeEvidence = canonicalEvidence(evidence);
+    const id = computeEdgeId(fromId, p, toId, edgeEvidence);
+    local.push({ id, from: fromId, p, to: toId, evidence: edgeEvidence });
+}
+function ensureNode(nodeById, label) {
+    const id = computeNodeId(label);
+    if (!nodeById.has(id))
+        nodeById.set(id, { id, label });
+    return id;
+}
+function normalizeLabel(input) {
+    return normalizeClaimLabel(input, 200);
+}
+function splitSentences(text) {
+    return text
+        .replace(/\r\n/g, '\n')
+        .split(/(?<=[.?!])\s+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function firstSentenceAfter(text, startIdx) {
+    const tail = text.slice(startIdx).replace(/^[^\n]*\n+/, '').trim();
+    if (!tail)
+        return '';
+    const first = splitSentences(tail)[0] ?? '';
+    return first.slice(0, 240);
+}
+function isStopwordOnly(subject) {
+    const words = subject.split(/\s+/).filter(Boolean);
+    return words.length > 0 && words.every((w) => STOPWORDS.has(w));
+}

package/dist/graph/claim_graph.d.ts

@@ -0,0 +1,34 @@
+import type { Pack } from '../pack.runtime.js';
+export type ClaimNode = {
+    id: string;
+    label: string;
+    props?: Record<string, string>;
+};
+export type ClaimEdge = {
+    id: string;
+    from: string;
+    p: string;
+    to: string;
+    evidence?: number[];
+    actor?: string;
+    ts?: number;
+};
+export type ClaimGraph = {
+    version: 1;
+    nodes: ClaimNode[];
+    edges: ClaimEdge[];
+    index?: {
+        labelToId?: Record<string, string>;
+        out?: Record<string, string[]>;
+        in?: Record<string, string[]>;
+    };
+};
+export declare function normalizeClaimLabel(label: string, maxLen?: number): string;
+export declare function computeNodeId(label: string): string;
+export declare function computeEdgeId(from: string, p: string, to: string, evidence?: number[]): string;
+export declare function canonicalEvidence(evidence?: number[]): number[];
+export declare function buildGraphIndex(graph: ClaimGraph): ClaimGraph['index'];
+export declare function finalizeGraph(graph: ClaimGraph): ClaimGraph;
+export declare function getClaimGraph(pack: Pack): ClaimGraph | null;
+export declare function validateClaimGraph(input: unknown): ClaimGraph | null;
+export declare function expandLabelToTerms(label: string): string[];

package/dist/graph/claim_graph.js

@@ -0,0 +1,65 @@
+import { normalize, tokenize } from '../tokenize.js';
+export function normalizeClaimLabel(label, maxLen = 200) {
+    const compact = normalize(label).replace(/\s+/g, ' ').trim();
+    return compact.slice(0, maxLen);
+}
+export function computeNodeId(label) {
+    return `n_${hash32Hex(normalizeClaimLabel(label))}`;
+}
+export function computeEdgeId(from, p, to, evidence) {
+    const evidenceCsv = canonicalEvidence(evidence).join(',');
+    return `e_${hash32Hex(`${from}\n${p}\n${to}\n${evidenceCsv}`)}`;
+}
+export function canonicalEvidence(evidence) {
+    if (!evidence?.length)
+        return [];
+    return Array.from(new Set(evidence.filter((n) => Number.isInteger(n) && n >= 0))).sort((a, b) => a - b);
+}
+export function buildGraphIndex(graph) {
+    const labelToId = {};
+    const out = {};
+    const inbound = {};
+    for (const node of graph.nodes) {
+        labelToId[normalizeClaimLabel(node.label)] = node.id;
+    }
+    for (const edge of graph.edges) {
+        (out[edge.from] ||= []).push(edge.id);
+        (inbound[edge.to] ||= []).push(edge.id);
+    }
+    for (const key of Object.keys(out))
+        out[key].sort();
+    for (const key of Object.keys(inbound))
+        inbound[key].sort();
+    return { labelToId, out, in: inbound };
+}
+export function finalizeGraph(graph) {
+    const nodes = [...graph.nodes].sort((a, b) => a.id.localeCompare(b.id));
+    const edges = [...graph.edges]
+        .map((e) => ({ ...e, evidence: canonicalEvidence(e.evidence) }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const out = { version: 1, nodes, edges };
+    out.index = buildGraphIndex(out);
+    return out;
+}
+export function getClaimGraph(pack) {
+    return pack.claimGraph ?? null;
+}
+export function validateClaimGraph(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const g = input;
+    if (g.version !== 1 || !Array.isArray(g.nodes) || !Array.isArray(g.edges))
+        return null;
+    return finalizeGraph({ version: 1, nodes: g.nodes, edges: g.edges });
+}
+export function expandLabelToTerms(label) {
+    return tokenize(normalizeClaimLabel(label)).map((t) => t.term);
+}
+function hash32Hex(input) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16).padStart(8, '0');
+}

package/dist/graph/log.d.ts

@@ -0,0 +1,33 @@
+import type { Pack } from '../pack.runtime.js';
+import type { ClaimGraph } from './claim_graph.js';
+export type ClaimOp = {
+    op: 'upsert_node';
+    id?: string;
+    label: string;
+    props?: Record<string, string>;
+    ts: number;
+    actor: string;
+} | {
+    op: 'add_edge';
+    from: string;
+    p: string;
+    to: string;
+    evidence?: number[];
+    ts: number;
+    actor: string;
+} | {
+    op: 'tombstone_edge';
+    edgeId: string;
+    ts: number;
+    actor: string;
+};
+export type ClaimGraphLog = {
+    version: 1;
+    ops: ClaimOp[];
+};
+export declare function createGraphLog(): ClaimGraphLog;
+export declare function appendOp(log: ClaimGraphLog, op: ClaimOp): ClaimGraphLog;
+export declare function mergeClaimGraphLogs(a: ClaimGraphLog, b: ClaimGraphLog): ClaimGraphLog;
+export declare function serializeClaimGraphLog(log: ClaimGraphLog): Uint8Array;
+export declare function deserializeClaimGraphLog(data: Uint8Array): ClaimGraphLog;
+export declare function applyClaimGraphLog(graphOrPack: ClaimGraph | Pack, log: ClaimGraphLog): ClaimGraph;

package/dist/graph/log.js

@@ -0,0 +1,106 @@
+import { canonicalEvidence, computeEdgeId, computeNodeId, finalizeGraph, normalizeClaimLabel, } from './claim_graph.js';
+export function createGraphLog() {
+    return { version: 1, ops: [] };
+}
+export function appendOp(log, op) {
+    return { version: 1, ops: [...log.ops, op] };
+}
+export function mergeClaimGraphLogs(a, b) {
+    return { version: 1, ops: [...a.ops, ...b.ops].sort(compareOps) };
+}
+export function serializeClaimGraphLog(log) {
+    return new TextEncoder().encode(JSON.stringify({ version: 1, ops: [...log.ops].sort(compareOps) }));
+}
+export function deserializeClaimGraphLog(data) {
+    const parsed = JSON.parse(new TextDecoder().decode(data));
+    if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.ops)) {
+        throw new Error('Invalid ClaimGraphLog payload');
+    }
+    return { version: 1, ops: parsed.ops.sort(compareOps) };
+}
+export function applyClaimGraphLog(graphOrPack, log) {
+    const baseGraph = isPack(graphOrPack)
+        ? graphOrPack.claimGraph ?? { version: 1, nodes: [], edges: [] }
+        : graphOrPack;
+    const nodeById = new Map(baseGraph.nodes.map((n) => [n.id, { ...n, props: n.props ? { ...n.props } : undefined }]));
+    const edgeById = new Map(baseGraph.edges.map((e) => [e.id, { ...e, evidence: canonicalEvidence(e.evidence) }]));
+    const nodeStamp = new Map();
+    const addStamp = new Map();
+    const tombstoneStamp = new Map();
+    for (const op of [...log.ops].sort(compareOps)) {
+        if (op.op === 'upsert_node') {
+            const label = normalizeClaimLabel(op.label);
+            const id = op.id || computeNodeId(label);
+            const prev = nodeStamp.get(id);
+            if (!prev || compareStamp([op.ts, op.actor], prev) >= 0) {
+                nodeStamp.set(id, [op.ts, op.actor]);
+                nodeById.set(id, { id, label, props: op.props ? { ...op.props } : undefined });
+            }
+            continue;
+        }
+        if (op.op === 'add_edge') {
+            const evidence = canonicalEvidence(op.evidence);
+            const edgeId = computeEdgeId(op.from, op.p, op.to, evidence);
+            const prevAdd = addStamp.get(edgeId);
+            if (!prevAdd || compareStamp([op.ts, op.actor], prevAdd) >= 0) {
+                addStamp.set(edgeId, [op.ts, op.actor]);
+            }
+            const existing = edgeById.get(edgeId);
+            const mergedEvidence = canonicalEvidence([...(existing?.evidence ?? []), ...evidence]);
+            edgeById.set(edgeId, {
+                id: edgeId,
+                from: op.from,
+                p: op.p,
+                to: op.to,
+                evidence: mergedEvidence,
+                actor: op.actor,
+                ts: op.ts,
+            });
+            continue;
+        }
+        const prev = tombstoneStamp.get(op.edgeId);
+        if (!prev || compareStamp([op.ts, op.actor], prev) >= 0) {
+            tombstoneStamp.set(op.edgeId, [op.ts, op.actor]);
+        }
+    }
+    for (const [edgeId, edge] of edgeById) {
+        const add = addStamp.get(edgeId) ?? [-Infinity, ''];
+        const tomb = tombstoneStamp.get(edgeId);
+        if (tomb && compareStamp(tomb, add) > 0) {
+            edgeById.delete(edgeId);
+            continue;
+        }
+        if (!nodeById.has(edge.from)) {
+            nodeById.set(edge.from, { id: edge.from, label: edge.from });
+        }
+        if (!nodeById.has(edge.to)) {
+            nodeById.set(edge.to, { id: edge.to, label: edge.to });
+        }
+    }
+    return finalizeGraph({ version: 1, nodes: [...nodeById.values()], edges: [...edgeById.values()] });
+}
+function compareOps(a, b) {
+    if (a.ts !== b.ts)
+        return a.ts - b.ts;
+    const actorCmp = a.actor.localeCompare(b.actor);
+    if (actorCmp !== 0)
+        return actorCmp;
+    return stableSerializeOp(a).localeCompare(stableSerializeOp(b));
+}
+function stableSerializeOp(op) {
+    if (op.op === 'upsert_node') {
+        return `upsert_node|${op.id || ''}|${normalizeClaimLabel(op.label)}|${JSON.stringify(op.props || {})}`;
+    }
+    if (op.op === 'add_edge') {
+        return `add_edge|${op.from}|${op.p}|${op.to}|${canonicalEvidence(op.evidence).join(',')}`;
+    }
+    return `tombstone_edge|${op.edgeId}`;
+}
+function compareStamp(a, b) {
+    if (a[0] !== b[0])
+        return a[0] - b[0];
+    return a[1].localeCompare(b[1]);
+}
+function isPack(input) {
+    return Boolean(input.meta && input.blocks);
+}

package/dist/graph/query_expand.d.ts

@@ -0,0 +1,6 @@
+import type { Pack } from '../pack.runtime.js';
+export type GraphQueryExpandOptions = {
+    maxExtraTerms?: number;
+    predicates?: string[];
+};
+export declare function expandQueryWithGraph(pack: Pack, queryString: string, opts?: GraphQueryExpandOptions): string;

package/dist/graph/query_expand.js

@@ -0,0 +1,57 @@
+import { normalize, tokenize } from '../tokenize.js';
+import { expandLabelToTerms } from './claim_graph.js';
+export function expandQueryWithGraph(pack, queryString, opts = {}) {
+    const graph = pack.claimGraph;
+    if (!graph || graph.nodes.length === 0 || graph.edges.length === 0)
+        return queryString;
+    const maxExtraTerms = Math.max(1, opts.maxExtraTerms ?? 12);
+    const predicates = new Set((opts.predicates ?? ['defined_as', 'is', 'mentions', 'ref']).map((p) => normalize(p)));
+    const qTokens = tokenize(queryString).map((t) => t.term);
+    if (qTokens.length === 0)
+        return queryString;
+    const qSet = new Set(qTokens);
+    const candidateNodeIds = new Set();
+    const labelEntries = Object.entries(graph.index?.labelToId ?? {}).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [labelNorm, nodeId] of labelEntries) {
+        if (qSet.has(labelNorm))
+            candidateNodeIds.add(nodeId);
+    }
+    for (const token of qTokens.sort()) {
+        for (const [labelNorm, nodeId] of labelEntries) {
+            if (labelNorm.startsWith(token))
+                candidateNodeIds.add(nodeId);
+            if (candidateNodeIds.size >= maxExtraTerms * 4)
+                break;
+        }
+        if (candidateNodeIds.size >= maxExtraTerms * 4)
+            break;
+    }
+    const edgeById = new Map(graph.edges.map((e) => [e.id, e]));
+    const outIdx = graph.index?.out ?? {};
+    const extraTerms = new Set();
+    const sortedNodeIds = [...candidateNodeIds].sort();
+    for (const nodeId of sortedNodeIds) {
+        const edgeIds = [...(outIdx[nodeId] ?? [])].sort();
+        for (const edgeId of edgeIds) {
+            const edge = edgeById.get(edgeId);
+            if (!edge || !predicates.has(normalize(edge.p)))
+                continue;
+            const target = graph.nodes.find((n) => n.id === edge.to);
+            if (!target)
+                continue;
+            for (const term of expandLabelToTerms(target.label)) {
+                if (!qSet.has(term))
+                    extraTerms.add(term);
+                if (extraTerms.size >= maxExtraTerms)
+                    break;
+            }
+            if (extraTerms.size >= maxExtraTerms)
+                break;
+        }
+        if (extraTerms.size >= maxExtraTerms)
+            break;
+    }
+    if (extraTerms.size === 0)
+        return queryString;
+    return `${queryString} ${[...extraTerms].sort().join(' ')}`.trim();
+}

package/dist/index.d.ts

@@ -3,12 +3,23 @@ export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOption
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
 export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { cosineSimilarity, normalizeVector } from './semantic/cosine.js';
+export { createPackFingerprint, serializeSidecar, parseSidecar, validateSidecarForPack, } from './semantic/sidecar.js';
+export { rerankCandidates } from './semantic/rerank.js';
+export { assertProviderCompatible, ensureProviderModelId } from './semantic/provider.js';
 export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
+export { getClaimGraph, validateClaimGraph, } from './graph/claim_graph.js';
+export { buildClaimGraph } from './graph/build_claim_graph.js';
+export { createGraphLog, appendOp, applyClaimGraphLog, mergeClaimGraphLogs, serializeClaimGraphLog, deserializeClaimGraphLog, } from './graph/log.js';
+export { expandQueryWithGraph } from './graph/query_expand.js';
 export type { MountOptions, PackMeta, Pack } from './pack.runtime.js';
 export type { QueryOptions, Hit } from './query.js';
+export type { EmbeddingProvider, SemanticSidecar, SemanticQueryOptions, RetrievalEvidence } from './semantic/types.js';
 export type { ContextPatch } from './patch.js';
 export type { BuildInputDoc, BuildPackOptions } from './builder.js';
 export type { AgentPromptTemplate, AgentToolPolicy, AgentRetrievalDefaults, AgentDefinitionV1, AgentRegistry, ResolveAgentInput, ResolvedAgent, } from './agent.js';
+export type { ClaimGraph, ClaimNode, ClaimEdge } from './graph/claim_graph.js';
+export type { ClaimGraphLog, ClaimOp } from './graph/log.js';
 export { parseToolCallV1FromText } from './tool_parse.js';
 export { nowIso, createTrace } from './trace.js';
 export { assertToolCallAllowed } from './tool_gate.js';

package/dist/index.js

@@ -4,7 +4,15 @@ export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOption
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
 export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { cosineSimilarity, normalizeVector } from './semantic/cosine.js';
+export { createPackFingerprint, serializeSidecar, parseSidecar, validateSidecarForPack, } from './semantic/sidecar.js';
+export { rerankCandidates } from './semantic/rerank.js';
+export { assertProviderCompatible, ensureProviderModelId } from './semantic/provider.js';
 export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
+export { getClaimGraph, validateClaimGraph, } from './graph/claim_graph.js';
+export { buildClaimGraph } from './graph/build_claim_graph.js';
+export { createGraphLog, appendOp, applyClaimGraphLog, mergeClaimGraphLogs, serializeClaimGraphLog, deserializeClaimGraphLog, } from './graph/log.js';
+export { expandQueryWithGraph } from './graph/query_expand.js';
 export { parseToolCallV1FromText } from './tool_parse.js';
 export { nowIso, createTrace } from './trace.js';
 export { assertToolCallAllowed } from './tool_gate.js';

package/dist/pack.runtime.d.ts

@@ -1,4 +1,5 @@
 import type { AgentRegistry } from './agent.js';
+import type { ClaimGraph } from './graph/claim_graph.js';
 export type MountOptions = {
     src: string | ArrayBufferLike | Uint8Array;
 };
@@ -11,6 +12,11 @@ export type PackMeta = {
         avgBlockLen?: number;
     };
     agents?: AgentRegistry;
+    claimGraph?: {
+        version: 1;
+        nodes: number;
+        edges: number;
+    };
 };
 export type Pack = {
     meta: PackMeta;
@@ -30,6 +36,7 @@ export type Pack = {
         vecs: Int8Array;
         scales?: Uint16Array;
     };
+    claimGraph?: ClaimGraph;
 };
 export declare function hasSemantic(pack: Pack): boolean;
 export declare function mountPack(opts: MountOptions): Promise<Pack>;

package/dist/pack.runtime.js

@@ -6,6 +6,7 @@
  */
 import { getTextDecoder } from './utils/utf8.js';
 import { validateAgentRegistry } from './agent.js';
+import { validateClaimGraph } from './graph/claim_graph.js';
 export function hasSemantic(pack) {
     return Boolean(pack.semantic && pack.semantic.dims > 0 && pack.semantic.vecs.length > 0);
 }
@@ -75,16 +76,50 @@ export function mountPackFromBuffer(buf) {
         }
     }
     let semantic;
-    if (offset < buf.byteLength) {
-        const semLen = dv.getUint32(offset, true);
+    let claimGraph;
+    while (offset < buf.byteLength) {
+        const sectionStart = offset;
+        if (buf.byteLength - offset < 4)
+            break;
+        const jsonLen = dv.getUint32(offset, true);
         offset += 4;
-        const semJson = dec.decode(new Uint8Array(buf, offset, semLen));
-        offset += semLen;
-        const sem = JSON.parse(semJson);
-        const semBlobLen = dv.getUint32(offset, true);
-        offset += 4;
-        const semBlob = new Uint8Array(buf, offset, semBlobLen);
-        semantic = parseSemanticSection(sem, semBlob);
+        if (jsonLen < 0 || offset + jsonLen > buf.byteLength) {
+            offset = sectionStart;
+            break;
+        }
+        let parsed;
+        try {
+            const json = dec.decode(new Uint8Array(buf, offset, jsonLen));
+            parsed = JSON.parse(json);
+        }
+        catch {
+            offset = sectionStart;
+            break;
+        }
+        offset += jsonLen;
+        if (!semantic && looksLikeSemanticJson(parsed)) {
+            if (buf.byteLength - offset < 4) {
+                offset = sectionStart;
+                break;
+            }
+            const semBlobLen = dv.getUint32(offset, true);
+            offset += 4;
+            if (semBlobLen < 0 || offset + semBlobLen > buf.byteLength) {
+                offset = sectionStart;
+                break;
+            }
+            const semBlob = new Uint8Array(buf, offset, semBlobLen);
+            offset += semBlobLen;
+            semantic = parseSemanticSection(parsed, semBlob);
+            continue;
+        }
+        const graph = validateClaimGraph(parsed);
+        if (!claimGraph && graph) {
+            claimGraph = graph;
+            continue;
+        }
+        offset = sectionStart;
+        break;
     }
     return {
         meta,
@@ -96,8 +131,18 @@ export function mountPackFromBuffer(buf) {
         namespaces,
         blockTokenLens,
         semantic,
+        claimGraph,
     };
 }
+function looksLikeSemanticJson(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return false;
+    const sem = parsed;
+    return (sem.version === 1 &&
+        sem.encoding === 'int8_l2norm' &&
+        typeof sem.blocks?.vectors?.byteOffset === 'number' &&
+        typeof sem.blocks?.vectors?.length === 'number');
+}
 function parseSemanticSection(sem, blob) {
     const vectors = sem?.blocks?.vectors;
     const scales = sem?.blocks?.scales;

package/dist/query.d.ts

@@ -1,4 +1,5 @@
 import type { Pack } from "./pack.js";
+import type { RetrievalEvidence, SemanticSidecar } from "./semantic/types.js";
 export type QueryOptions = {
     topK?: number;
     minScore?: number;
@@ -12,6 +13,11 @@ export type QueryOptions = {
         weight?: number;
         minTermLength?: number;
     };
+    graph?: {
+        expand?: boolean;
+        maxExtraTerms?: number;
+        predicates?: string[];
+    };
     semantic?: {
         enabled?: boolean;
         mode?: "rerank";
@@ -23,6 +29,14 @@ export type QueryOptions = {
             wSem?: number;
         };
         queryEmbedding?: Float32Array;
+        sidecar?: SemanticSidecar;
+        provider?: {
+            type: "ollama";
+            modelId: string;
+            endpoint?: string;
+        };
+        sidecarPath?: string;
+        minSemanticScore?: number;
         force?: boolean;
     };
 };
@@ -34,6 +48,7 @@ export type Hit = {
     text: string;
     source?: string;
     namespace?: string;
+    evidence?: RetrievalEvidence;
 };
 export declare function query(pack: Pack, q: string, opts?: QueryOptions): Hit[];
 export declare function lexConfidence(hits: Array<{

package/dist/query.js

@@ -14,6 +14,9 @@ import { minCoverSpan, proximityMultiplier } from "./quality/proximity.js";
 import { diversifyAndDedupe } from "./quality/diversify.js";
 import { knsSignature, knsDistance } from "./quality/signature.js";
 import { decodeScaleF16, quantizeEmbeddingInt8L2Norm } from "./semantic.js";
+import { expandQueryWithGraph } from "./graph/query_expand.js";
+import { rerankCandidates } from "./semantic/rerank.js";
+import { parseSidecar } from "./semantic/sidecar.js";
 export function validateQueryOptions(opts) {
     if (!opts)
         return;
@@ -46,6 +49,17 @@ export function validateQueryOptions(opts) {
             throw new Error("query(...): queryExpansion.minTermLength must be a positive integer.");
         }
     }
+    if (opts.graph) {
+        if (opts.graph.expand !== undefined && typeof opts.graph.expand !== "boolean") {
+            throw new Error("query(...): graph.expand must be a boolean when provided.");
+        }
+        if (opts.graph.maxExtraTerms !== undefined && (!Number.isInteger(opts.graph.maxExtraTerms) || opts.graph.maxExtraTerms < 1)) {
+            throw new Error("query(...): graph.maxExtraTerms must be a positive integer.");
+        }
+        if (opts.graph.predicates !== undefined && (!Array.isArray(opts.graph.predicates) || opts.graph.predicates.some((p) => typeof p !== "string"))) {
+            throw new Error("query(...): graph.predicates must be an array of strings when provided.");
+        }
+    }
     validateSemanticQueryOptions(opts.semantic);
 }
 export function validateSemanticQueryOptions(options) {
@@ -66,6 +80,19 @@ export function validateSemanticQueryOptions(options) {
     if (options.queryEmbedding !== undefined && !(options.queryEmbedding instanceof Float32Array)) {
         throw new Error("query(...): semantic.queryEmbedding must be a Float32Array.");
     }
+    if (options.sidecarPath !== undefined && typeof options.sidecarPath !== "string") {
+        throw new Error("query(...): semantic.sidecarPath must be a string when provided.");
+    }
+    if (options.minSemanticScore !== undefined && (!Number.isFinite(options.minSemanticScore) || options.minSemanticScore < 0 || options.minSemanticScore > 1)) {
+        throw new Error("query(...): semantic.minSemanticScore must be a finite number between 0 and 1.");
+    }
+    if (options.provider) {
+        if (options.provider.type !== "ollama")
+            throw new Error('query(...): semantic.provider.type must be "ollama".');
+        if (typeof options.provider.modelId !== "string" || !options.provider.modelId.trim()) {
+            throw new Error("query(...): semantic.provider.modelId must be a non-empty string.");
+        }
+    }
     if (options.blend) {
         if (options.blend.enabled !== undefined && typeof options.blend.enabled !== "boolean") {
             throw new Error("query(...): semantic.blend.enabled must be a boolean when provided.");
@@ -103,10 +130,19 @@ export function query(pack, q, opts = {}) {
             wSem: Math.max(0, opts.semantic?.blend?.wSem ?? 0.25),
         },
         queryEmbedding: opts.semantic?.queryEmbedding,
+        sidecar: resolveSemanticSidecar(opts.semantic?.sidecar, opts.semantic?.sidecarPath),
+        provider: opts.semantic?.provider,
+        minSemanticScore: opts.semantic?.minSemanticScore,
         force: opts.semantic?.force ?? false,
     };
+    const graphQuery = opts.graph?.expand === true
+        ? expandQueryWithGraph(pack, q, {
+            maxExtraTerms: opts.graph?.maxExtraTerms,
+            predicates: opts.graph?.predicates,
+        })
+        : q;
     // --- Query parsing
-    const normTokens = tokenize(q).map((t) => t.term);
+    const normTokens = tokenize(graphQuery).map((t) => t.term);
     // Normalize quoted phrases from q
     const quotedRaw = parsePhrases(q);
     const quoted = quotedRaw.map((seq) => seq.map((t) => normalize(t)).flatMap((s) => s.split(/\s+/)).filter(Boolean));
@@ -266,9 +302,16 @@ export function query(pack, q, opts = {}) {
             return [];
     }
     const confidence = lexConfidence(prelim);
+    let semanticScores;
+    let blendedScores;
+    const originalLexicalScores = new Map(prelim.map((item) => [item.blockId, item.score]));
     if (shouldRerankWithSemantic(pack, semanticOpts, confidence)) {
-        prelim = rerankLexicalHitsWithSemantic(pack, prelim, semanticOpts);
+        const semanticResult = rerankLexicalHitsWithSemantic(pack, prelim, semanticOpts);
+        prelim = semanticResult.hits;
+        semanticScores = semanticResult.semanticScores;
+        blendedScores = semanticResult.blendedScores;
     }
+    const retrievalMode = semanticScores ? "hybrid" : "lexical";
     // --- KNS tie-breaker + de-dup/MMR
     const qSig = knsSignature(normalize(q));
     const pool = prelim.slice(0, topK * 5).map((r) => {
@@ -280,6 +323,13 @@ export function query(pack, q, opts = {}) {
             text,
             source: pack.docIds?.[r.blockId] ?? undefined,
             namespace: pack.namespaces?.[r.blockId] ?? undefined,
+            evidence: {
+                retrieval: retrievalMode,
+                lexicalScore: originalLexicalScores.get(r.blockId) ?? r.score,
+                semanticScore: semanticScores?.get(r.blockId),
+                blendedScore: blendedScores?.get(r.blockId),
+                modelId: semanticOpts.provider?.modelId ?? semanticOpts.sidecar?.modelId,
+            },
         };
     });
     const finalHits = diversifyAndDedupe(pool, { k: topK });
@@ -297,19 +347,66 @@ export function lexConfidence(hits) {
 function shouldRerankWithSemantic(pack, opts, confidence) {
     if (!opts.enabled || opts.mode !== "rerank")
         return false;
-    if (!pack.semantic)
+    if (!pack.semantic && !opts.sidecar)
         return false;
     if (!opts.queryEmbedding) {
         throw new Error("query(...): semantic.queryEmbedding (Float32Array) is required when semantic.enabled=true.");
     }
     return opts.force || confidence < opts.minLexConfidence;
 }
+function resolveSemanticSidecar(sidecar, sidecarPath) {
+    if (sidecar)
+        return sidecar;
+    if (!sidecarPath)
+        return undefined;
+    const raw = sidecarPath.trim();
+    if (!raw)
+        return undefined;
+    if (raw.startsWith("{")) {
+        return parseSidecar(raw);
+    }
+    if (raw.startsWith("data:")) {
+        const comma = raw.indexOf(",");
+        if (comma <= 0)
+            return undefined;
+        const meta = raw.slice(5, comma).toLowerCase();
+        const payload = raw.slice(comma + 1);
+        const decoded = meta.includes(";base64")
+            ? decodeBase64(payload)
+            : decodeURIComponent(payload);
+        if (!decoded.trim())
+            return undefined;
+        return parseSidecar(decoded);
+    }
+    return undefined;
+}
+function decodeBase64(input) {
+    const normalized = input.replace(/\s+/g, "");
+    const atobFn = globalThis.atob;
+    if (typeof atobFn === "function")
+        return atobFn(normalized);
+    const maybeBufferCtor = globalThis.Buffer;
+    if (maybeBufferCtor?.from)
+        return maybeBufferCtor.from(normalized, "base64").toString("utf8");
+    throw new Error("query(...): Unable to decode semantic.sidecarPath base64 payload in this runtime.");
+}
 function rerankLexicalHitsWithSemantic(pack, prelim, opts) {
+    if (opts.sidecar && opts.queryEmbedding) {
+        const sidecarResult = rerankCandidates({
+            lexical: prelim,
+            sidecar: opts.sidecar,
+            queryEmbedding: opts.queryEmbedding,
+            topN: opts.topN,
+            blend: opts.blend,
+            minSemanticScore: opts.minSemanticScore,
+        });
+        return { hits: sidecarResult.reranked, semanticScores: sidecarResult.semanticScores, blendedScores: sidecarResult.blendedScores };
+    }
     const sem = pack.semantic;
     if (!sem || !opts.queryEmbedding)
-        return prelim;
+        return { hits: prelim };
     if (sem.dims <= 0 || sem.vecs.length === 0 || sem.dims !== opts.queryEmbedding.length)
-        return prelim;
+        return { hits: prelim };
     const topN = Math.min(opts.topN, prelim.length);
     const rerankSlice = prelim.slice(0, topN);
     const tail = prelim.slice(topN);
@@ -324,15 +421,19 @@ function rerankLexicalHitsWithSemantic(pack, prelim, opts) {
     const wLex = denom > 0 ? opts.blend.wLex / denom : 0.5;
     const wSem = denom > 0 ? opts.blend.wSem / denom : 0.5;
     const reranked = new Array(topN);
+    const semanticScores = new Map();
+    const blendedScores = new Map();
     for (let i = 0; i < topN; i++) {
         const hit = rerankSlice[i];
+        semanticScores.set(hit.blockId, normSem[i]);
+        blendedScores.set(hit.blockId, opts.blend.enabled ? wLex * normLex[i] + wSem * normSem[i] : semScores[i]);
         reranked[i] = {
             blockId: hit.blockId,
-            score: opts.blend.enabled ? wLex * normLex[i] + wSem * normSem[i] : semScores[i],
+            score: blendedScores.get(hit.blockId) ?? hit.score,
         };
     }
     reranked.sort((a, b) => b.score - a.score || a.blockId - b.blockId);
-    return [...reranked, ...tail];
+    return { hits: [...reranked, ...tail], semanticScores, blendedScores };
 }
 function scoreSemanticInt8(queryQ, queryScale, semantic, hits) {
     const scores = new Float64Array(hits.length);

package/dist/semantic/cosine.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeVector(vector: Float32Array): Float32Array;
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;

package/dist/semantic/cosine.js

@@ -0,0 +1,20 @@
+export function normalizeVector(vector) {
+    let normSq = 0;
+    for (let i = 0; i < vector.length; i++)
+        normSq += vector[i] * vector[i];
+    const norm = Math.sqrt(normSq);
+    if (!norm)
+        return new Float32Array(vector.length);
+    const out = new Float32Array(vector.length);
+    for (let i = 0; i < vector.length; i++)
+        out[i] = vector[i] / norm;
+    return out;
+}
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i++)
+        dot += a[i] * b[i];
+    return dot;
+}

package/dist/semantic/provider.d.ts

@@ -0,0 +1,3 @@
+import type { EmbeddingProvider, SemanticQueryOptions } from './types.js';
+export declare function ensureProviderModelId(options?: SemanticQueryOptions): string | undefined;
+export declare function assertProviderCompatible(options?: SemanticQueryOptions, provider?: EmbeddingProvider): void;

package/dist/semantic/provider.js

@@ -0,0 +1,13 @@
+export function ensureProviderModelId(options) {
+    return options?.provider?.modelId;
+}
+export function assertProviderCompatible(options, provider) {
+    if (!options?.enabled)
+        return;
+    if (!provider && !options.queryEmbedding) {
+        throw new Error('semantic.enabled=true requires either semantic.queryEmbedding or an EmbeddingProvider.');
+    }
+    if (provider && options.provider?.modelId && options.provider.modelId !== provider.modelId) {
+        throw new Error(`Semantic provider model mismatch: options requested ${options.provider.modelId}, provider exposes ${provider.modelId}.`);
+    }
+}

package/dist/semantic/rerank.d.ts

@@ -0,0 +1,23 @@
+import type { SemanticSidecar } from './types.js';
+export declare function rerankCandidates(params: {
+    lexical: Array<{
+        blockId: number;
+        score: number;
+    }>;
+    sidecar: SemanticSidecar;
+    queryEmbedding: Float32Array;
+    topN: number;
+    blend: {
+        enabled: boolean;
+        wLex: number;
+        wSem: number;
+    };
+    minSemanticScore?: number;
+}): {
+    reranked: Array<{
+        blockId: number;
+        score: number;
+    }>;
+    semanticScores: Map<number, number>;
+    blendedScores: Map<number, number>;
+};

package/dist/semantic/rerank.js

@@ -0,0 +1,42 @@
+import { cosineSimilarity, normalizeVector } from './cosine.js';
+export function rerankCandidates(params) {
+    const topN = Math.min(params.topN, params.lexical.length);
+    const head = params.lexical.slice(0, topN);
+    const tail = params.lexical.slice(topN);
+    const q = normalizeVector(params.queryEmbedding);
+    const semanticScores = new Map();
+    const blendedScores = new Map();
+    const lexNorm = minMax(head.map((h) => h.score));
+    const semRaw = [];
+    for (const item of head) {
+        const rec = params.sidecar.blocks.find((b) => b.blockId === item.blockId);
+        const vec = rec ? Float32Array.from(rec.vector) : new Float32Array(q.length);
+        semRaw.push(cosineSimilarity(q, vec));
+    }
+    const semNorm = minMax(semRaw);
+    const denom = params.blend.wLex + params.blend.wSem;
+    const wLex = denom > 0 ? params.blend.wLex / denom : 0.7;
+    const wSem = denom > 0 ? params.blend.wSem / denom : 0.3;
+    const reranked = head.map((item, idx) => {
+        const sem = semNorm[idx];
+        semanticScores.set(item.blockId, sem);
+        if ((params.minSemanticScore ?? 0) > sem) {
+            blendedScores.set(item.blockId, lexNorm[idx]);
+            return { blockId: item.blockId, score: lexNorm[idx] };
+        }
+        const blended = params.blend.enabled ? wLex * lexNorm[idx] + wSem * sem : sem;
+        blendedScores.set(item.blockId, blended);
+        return { blockId: item.blockId, score: blended };
+    });
+    reranked.sort((a, b) => b.score - a.score || a.blockId - b.blockId);
+    return { reranked: [...reranked, ...tail], semanticScores, blendedScores };
+}
+function minMax(values) {
+    if (values.length === 0)
+        return values;
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min)
+        return values.map(() => 1);
+    return values.map((v) => Math.min(1, Math.max(0, (v - min) / (max - min))));
+}

package/dist/semantic/sidecar.d.ts

@@ -0,0 +1,10 @@
+import type { Pack } from '../pack.runtime.js';
+import type { SemanticSidecar } from './types.js';
+export declare function createPackFingerprint(pack: Pick<Pack, 'blocks' | 'docIds' | 'meta'>): string;
+export declare function serializeSidecar(sidecar: SemanticSidecar): string;
+export declare function parseSidecar(raw: string): SemanticSidecar;
+export declare function validateSidecarForPack(input: {
+    sidecar: SemanticSidecar;
+    pack: Pick<Pack, 'blocks' | 'docIds' | 'meta'>;
+    modelId: string;
+}): void;

package/dist/semantic/sidecar.js

@@ -0,0 +1,32 @@
+export function createPackFingerprint(pack) {
+    let hash = 2166136261;
+    const parts = [String(pack.meta?.version ?? 0), ...(pack.docIds ?? []), ...pack.blocks];
+    for (const part of parts) {
+        const text = String(part ?? '');
+        for (let i = 0; i < text.length; i++) {
+            hash ^= text.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+    }
+    return `fnv1a-${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+export function serializeSidecar(sidecar) {
+    return `${JSON.stringify(sidecar, null, 2)}\n`;
+}
+export function parseSidecar(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1)
+        throw new Error(`Unsupported semantic sidecar version: ${parsed.version}`);
+    if (parsed.metric !== 'cosine')
+        throw new Error(`Unsupported semantic metric: ${parsed.metric}`);
+    return parsed;
+}
+export function validateSidecarForPack(input) {
+    const expectedFingerprint = createPackFingerprint(input.pack);
+    if (input.sidecar.packFingerprint !== expectedFingerprint) {
+        throw new Error(`Semantic sidecar pack fingerprint mismatch: expected ${expectedFingerprint}, got ${input.sidecar.packFingerprint}. Regenerate the sidecar for this pack.`);
+    }
+    if (input.sidecar.modelId !== input.modelId) {
+        throw new Error(`Semantic model mismatch: sidecar model is ${input.sidecar.modelId}, but query provider is ${input.modelId}. Use the same embedding model or regenerate the sidecar.`);
+    }
+}

package/dist/semantic/types.d.ts

@@ -0,0 +1,44 @@
+export interface EmbeddingProvider {
+    readonly modelId: string;
+    embedQuery(text: string): Promise<Float32Array>;
+    embedTexts(texts: string[]): Promise<Float32Array[]>;
+}
+export interface SemanticSidecar {
+    version: 1;
+    packFingerprint: string;
+    modelId: string;
+    dimension: number;
+    metric: 'cosine';
+    createdAt: string;
+    blocks: Array<{
+        blockId: number;
+        vector: number[];
+    }>;
+}
+export type SemanticQueryOptions = {
+    enabled?: boolean;
+    mode?: 'rerank';
+    topN?: number;
+    minLexConfidence?: number;
+    minSemanticScore?: number;
+    blend?: {
+        enabled?: boolean;
+        wLex?: number;
+        wSem?: number;
+    };
+    provider?: {
+        type: 'ollama';
+        modelId: string;
+        endpoint?: string;
+    };
+    sidecarPath?: string;
+    queryEmbedding?: Float32Array;
+    force?: boolean;
+};
+export type RetrievalEvidence = {
+    retrieval: 'lexical' | 'hybrid';
+    lexicalScore?: number;
+    semanticScore?: number;
+    blendedScore?: number;
+    modelId?: string;
+};

package/dist/semantic/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knolo/core",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "type": "module",
   "description": "Local-first knowledge packs for small LLMs.",
   "keywords": [