@graphorin/memory 0.5.0

package/dist/graph/entity-resolver.d.ts

@@ -0,0 +1,135 @@
+import { GraphMemoryStoreExt } from "../internal/storage-adapter.js";
+import { EmbedderProvider, Fact, Provider, ProviderRequest, SessionScope } from "@graphorin/core";
+
+//#region src/graph/entity-resolver.d.ts
+
+/** Cosine `≥` this auto-reuses an existing entity (embedding match). */
+declare const DEFAULT_MERGE_THRESHOLD = 0.92;
+/** Cosine in `[this, merge)` is *ambiguous* — adjudicate or mint new. */
+declare const DEFAULT_ADJUDICATE_THRESHOLD = 0.82;
+/**
+ * Outcome of the pure resolution policy. `match` reuses an existing
+ * entity; `ambiguous` flags a middle-similarity candidate for the caller
+ * to adjudicate (or conservatively reject); `new` mints a fresh entity.
+ *
+ * @stable
+ */
+type EntityResolveDecision = {
+  readonly kind: 'match';
+  readonly entityId: string;
+  readonly similarity: number;
+  readonly via: 'lexical' | 'embedding';
+} | {
+  readonly kind: 'ambiguous';
+  readonly entityId: string;
+  readonly similarity: number;
+} | {
+  readonly kind: 'new';
+};
+/** Minimal candidate shape the pure policy compares against. */
+interface ResolutionCandidate {
+  readonly id: string;
+  readonly normalizedName: string;
+  readonly vector: Float32Array | null;
+  /**
+   * MST-11: the embedder that produced `vector`. When both this and the
+   * query's `vectorEmbedderId` are known and differ, the candidate is skipped
+   * for embedding comparison — vectors from different models live in different
+   * spaces, so their cosine is meaningless. Absent on either side ⇒ compared
+   * (byte-identical to the prior behaviour).
+   */
+  readonly embedderId?: string | null;
+}
+/** Inputs to {@link resolveEntityDecision} (all provided by the caller). */
+interface ResolveDecisionInput {
+  readonly normalizedName: string;
+  readonly vector?: Float32Array | null;
+  /** MST-11: the embedder that produced `vector` (gates cross-embedder cosine). */
+  readonly vectorEmbedderId?: string | null;
+  readonly candidates: ReadonlyArray<ResolutionCandidate>;
+  readonly mergeThreshold: number;
+  readonly adjudicateThreshold: number;
+}
+/**
+ * Fold an entity surface form into a canonical lexical key: Unicode
+ * NFKC, lowercased, internal whitespace collapsed, surrounding
+ * punctuation stripped. `"  Anna S. "` → `"anna s"`. Returns `''` for a
+ * name with no letters/digits (the resolver treats that as "no entity").
+ *
+ * @stable
+ */
+declare function normalizeEntityName(name: string): string;
+/**
+ * Cosine similarity of two embeddings in `[-1, 1]`. Compares over the
+ * shorter length and returns `0` when either vector is empty / zero-norm.
+ *
+ * @stable
+ */
+declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * Pure resolution policy: lexical exact match → embedding cosine →
+ * ambiguous band → new. No I/O; deterministic. The caller decides what
+ * to do with `ambiguous` (LLM adjudicate, or conservatively mint new).
+ *
+ * @stable
+ */
+declare function resolveEntityDecision(input: ResolveDecisionInput): EntityResolveDecision;
+/** Tunable thresholds + LLM-adjudication switch for {@link EntityResolver}. */
+interface EntityResolutionConfig {
+  /** Cosine `≥` this auto-reuses a match. Default {@link DEFAULT_MERGE_THRESHOLD}. */
+  readonly mergeThreshold?: number;
+  /** Cosine in `[this, merge)` is ambiguous. Default {@link DEFAULT_ADJUDICATE_THRESHOLD}. */
+  readonly adjudicateThreshold?: number;
+  /**
+   * Resolve the ambiguous band with one provider call. Requires a
+   * `provider`. Default `false` ⇒ ambiguous mints a new entity (no
+   * network call; never auto-merges on weak evidence).
+   */
+  readonly llmAdjudication?: boolean;
+}
+/** Construction deps for {@link EntityResolver}. */
+interface EntityResolverDeps {
+  readonly store: GraphMemoryStoreExt;
+  readonly embedder?: EmbedderProvider | null;
+  readonly embedderId?: () => string | null;
+  readonly provider?: Provider | null;
+  readonly config?: EntityResolutionConfig;
+}
+/** Build the (pure) adjudication request. Exposed for testing. */
+declare function buildAdjudicationRequest(nameA: string, nameB: string, options?: {
+  readonly signal?: AbortSignal;
+}): ProviderRequest;
+/** Parse a yes/no adjudication reply. Conservative: only a clear yes is `true`. */
+declare function parseAdjudication(text: string): boolean;
+/**
+ * Resolves a fact's subject / object strings to canonical entity ids and
+ * links them, applying {@link resolveEntityDecision} backed by an
+ * injected store + embedder (+ optional provider for adjudication).
+ * Constructed only when entity resolution is opted in
+ * (`createMemory({ graph: { entityResolution: true } })`); otherwise the
+ * write path skips it and behaviour is unchanged + offline.
+ *
+ * @stable
+ */
+declare class EntityResolver {
+  #private;
+  constructor(deps: EntityResolverDeps);
+  /**
+   * Resolve a single name to a canonical entity id (find-or-create),
+   * deduping via lexical + embedding similarity. Returns `null` for a
+   * name that normalizes to empty (no entity).
+   */
+  resolve(scope: SessionScope, rawName: string, opts?: {
+    readonly signal?: AbortSignal;
+  }): Promise<string | null>;
+  /**
+   * Resolve + link a fact's subject and object (the predicate is a
+   * relation label, never an entity). Idempotent on re-link.
+   */
+  linkFact(scope: SessionScope, fact: Fact, opts?: {
+    readonly signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+export { DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_MERGE_THRESHOLD, EntityResolutionConfig, EntityResolveDecision, EntityResolver, EntityResolverDeps, ResolutionCandidate, ResolveDecisionInput, buildAdjudicationRequest, cosineSimilarity, normalizeEntityName, parseAdjudication, resolveEntityDecision };
+//# sourceMappingURL=entity-resolver.d.ts.map

package/dist/graph/entity-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-resolver.d.ts","names":[],"sources":["../../src/graph/entity-resolver.ts"],"sourcesContent":[],"mappings":";;;;;;AA2PW,cAxNE,uBAAA,GAwNF,IAAA;;AAGN,cAzNQ,4BAAA,GAyNR,IAAA;;;;;;;;KAhNO,qBAAA;;;;;;;;;;;;;UAWK,mBAAA;;;mBAGE;;;;;;;;;;;UAYF,oBAAA;;oBAEG;;;uBAGG,cAAc;;;;;;;;;;;;iBAarB,mBAAA;;;;;;;iBAeA,gBAAA,IAAoB,iBAAiB;;;;;;;;iBAuBrC,qBAAA,QAA6B,uBAAuB;;UAyCnD,sBAAA;;;;;;;;;;;;;UAcA,kBAAA;kBACC;sBACI;;sBAEA;oBACF;;;iBASJ,wBAAA;oBAGe;IAC5B;;iBAWa,iBAAA;;;;;;;;;;;cAcH,cAAA;;oBASO;;;;;;iBAgBT;sBAEmB;MACzB;;;;;kBAyCM,oBACD;sBACoB;MACzB"}

package/dist/graph/entity-resolver.js

@@ -0,0 +1,202 @@
+//#region src/graph/entity-resolver.ts
+/** Cosine `≥` this auto-reuses an existing entity (embedding match). */
+const DEFAULT_MERGE_THRESHOLD = .92;
+/** Cosine in `[this, merge)` is *ambiguous* — adjudicate or mint new. */
+const DEFAULT_ADJUDICATE_THRESHOLD = .82;
+/**
+* Fold an entity surface form into a canonical lexical key: Unicode
+* NFKC, lowercased, internal whitespace collapsed, surrounding
+* punctuation stripped. `"  Anna S. "` → `"anna s"`. Returns `''` for a
+* name with no letters/digits (the resolver treats that as "no entity").
+*
+* @stable
+*/
+function normalizeEntityName(name) {
+	return name.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim().replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "");
+}
+/**
+* Cosine similarity of two embeddings in `[-1, 1]`. Compares over the
+* shorter length and returns `0` when either vector is empty / zero-norm.
+*
+* @stable
+*/
+function cosineSimilarity(a, b) {
+	const len = Math.min(a.length, b.length);
+	let dot = 0;
+	let na = 0;
+	let nb = 0;
+	for (let i = 0; i < len; i++) {
+		const ai = a[i] ?? 0;
+		const bi = b[i] ?? 0;
+		dot += ai * bi;
+		na += ai * ai;
+		nb += bi * bi;
+	}
+	if (na === 0 || nb === 0) return 0;
+	return dot / Math.sqrt(na * nb);
+}
+/**
+* Pure resolution policy: lexical exact match → embedding cosine →
+* ambiguous band → new. No I/O; deterministic. The caller decides what
+* to do with `ambiguous` (LLM adjudicate, or conservatively mint new).
+*
+* @stable
+*/
+function resolveEntityDecision(input) {
+	for (const c of input.candidates) if (c.normalizedName === input.normalizedName) return {
+		kind: "match",
+		entityId: c.id,
+		similarity: 1,
+		via: "lexical"
+	};
+	const v = input.vector;
+	if (v === void 0 || v === null || v.length === 0) return { kind: "new" };
+	let bestId = null;
+	let bestSim = Number.NEGATIVE_INFINITY;
+	for (const c of input.candidates) {
+		if (c.vector === null || c.vector.length === 0) continue;
+		if (input.vectorEmbedderId != null && c.embedderId != null && c.embedderId !== input.vectorEmbedderId) continue;
+		const sim = cosineSimilarity(v, c.vector);
+		if (sim > bestSim) {
+			bestSim = sim;
+			bestId = c.id;
+		}
+	}
+	if (bestId === null) return { kind: "new" };
+	if (bestSim >= input.mergeThreshold) return {
+		kind: "match",
+		entityId: bestId,
+		similarity: bestSim,
+		via: "embedding"
+	};
+	if (bestSim >= input.adjudicateThreshold) return {
+		kind: "ambiguous",
+		entityId: bestId,
+		similarity: bestSim
+	};
+	return { kind: "new" };
+}
+const ADJUDICATION_SYSTEM_PROMPT = "You decide whether two short names refer to the SAME real-world entity (person, place, org, thing). Reply with a single word: \"yes\" or \"no\". Be conservative — answer \"no\" unless they are clearly the same entity.";
+/** Build the (pure) adjudication request. Exposed for testing. */
+function buildAdjudicationRequest(nameA, nameB, options = {}) {
+	return {
+		messages: [{
+			role: "user",
+			content: `Name A: ${nameA}\nName B: ${nameB}\nSame entity?`
+		}],
+		systemMessage: ADJUDICATION_SYSTEM_PROMPT,
+		temperature: 0,
+		maxTokens: 4,
+		...options.signal !== void 0 ? { signal: options.signal } : {}
+	};
+}
+/** Parse a yes/no adjudication reply. Conservative: only a clear yes is `true`. */
+function parseAdjudication(text) {
+	return /^\s*(yes|true|same)\b/i.test(text);
+}
+/**
+* Resolves a fact's subject / object strings to canonical entity ids and
+* links them, applying {@link resolveEntityDecision} backed by an
+* injected store + embedder (+ optional provider for adjudication).
+* Constructed only when entity resolution is opted in
+* (`createMemory({ graph: { entityResolution: true } })`); otherwise the
+* write path skips it and behaviour is unchanged + offline.
+*
+* @stable
+*/
+var EntityResolver = class {
+	#store;
+	#embedder;
+	#embedderId;
+	#provider;
+	#mergeThreshold;
+	#adjudicateThreshold;
+	#llmAdjudication;
+	constructor(deps) {
+		this.#store = deps.store;
+		this.#embedder = deps.embedder ?? null;
+		this.#embedderId = deps.embedderId ?? (() => null);
+		this.#provider = deps.provider ?? null;
+		this.#mergeThreshold = deps.config?.mergeThreshold ?? DEFAULT_MERGE_THRESHOLD;
+		this.#adjudicateThreshold = deps.config?.adjudicateThreshold ?? DEFAULT_ADJUDICATE_THRESHOLD;
+		this.#llmAdjudication = deps.config?.llmAdjudication ?? false;
+	}
+	/**
+	* Resolve a single name to a canonical entity id (find-or-create),
+	* deduping via lexical + embedding similarity. Returns `null` for a
+	* name that normalizes to empty (no entity).
+	*/
+	async resolve(scope, rawName, opts = {}) {
+		const normalizedName = normalizeEntityName(rawName);
+		if (normalizedName.length === 0) return null;
+		const exact = await this.#store.findEntityByNormalizedName?.(scope, normalizedName);
+		if (exact != null) return exact.id;
+		const vector = await this.#embed(rawName, opts.signal);
+		if (vector === null || vector.length === 0) return this.#create(scope, rawName, normalizedName, vector);
+		const candidates = await this.#store.listEntities(scope);
+		const decision = resolveEntityDecision({
+			normalizedName,
+			vector,
+			vectorEmbedderId: this.#embedderId(),
+			candidates,
+			mergeThreshold: this.#mergeThreshold,
+			adjudicateThreshold: this.#adjudicateThreshold
+		});
+		if (decision.kind === "match") return decision.entityId;
+		if (decision.kind === "ambiguous") {
+			if (this.#llmAdjudication && this.#provider !== null) {
+				if (await this.#adjudicate(rawName, decision.entityId, candidates, opts.signal)) return decision.entityId;
+			}
+		}
+		return this.#create(scope, rawName, normalizedName, vector);
+	}
+	/**
+	* Resolve + link a fact's subject and object (the predicate is a
+	* relation label, never an entity). Idempotent on re-link.
+	*/
+	async linkFact(scope, fact, opts = {}) {
+		if (fact.subject !== void 0) {
+			const id = await this.resolve(scope, fact.subject, opts);
+			if (id !== null) await this.#store.linkFactEntity(fact.id, id, "subject");
+		}
+		if (fact.object !== void 0) {
+			const id = await this.resolve(scope, fact.object, opts);
+			if (id !== null) await this.#store.linkFactEntity(fact.id, id, "object");
+		}
+	}
+	async #embed(name, signal) {
+		const embedder = this.#embedder;
+		if (embedder === null || this.#embedderId() === null) return null;
+		try {
+			const [vector] = await embedder.embed([name]);
+			return vector ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async #create(scope, name, normalizedName, vector) {
+		const embedderId = this.#embedderId();
+		return this.#store.upsertEntity(scope, {
+			name,
+			normalizedName,
+			...vector !== null ? { vector } : {},
+			...vector !== null && embedderId !== null ? { embedderId } : {}
+		});
+	}
+	async #adjudicate(name, candidateId, candidates, signal) {
+		const provider = this.#provider;
+		if (provider === null) return false;
+		const candidate = candidates.find((c) => c.id === candidateId);
+		if (candidate === void 0) return false;
+		try {
+			const request = buildAdjudicationRequest(name, candidate.name, { ...signal !== void 0 ? { signal } : {} });
+			return parseAdjudication((await provider.generate(request)).text ?? "");
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_MERGE_THRESHOLD, EntityResolver, buildAdjudicationRequest, cosineSimilarity, normalizeEntityName, parseAdjudication, resolveEntityDecision };
+//# sourceMappingURL=entity-resolver.js.map

package/dist/graph/entity-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-resolver.js","names":["bestId: string | null","#store","#embedder","#embedderId","#provider","#mergeThreshold","#adjudicateThreshold","#llmAdjudication","#embed","#create","#adjudicate"],"sources":["../../src/graph/entity-resolver.ts"],"sourcesContent":["/**\n * Entity resolution for the lightweight in-SQLite relation graph (P2-1).\n *\n * Raw `subject` / `object` strings on facts fragment (\"Anna\", \"Anna S.\",\n * \"my sister\" become unrelated rows), which kills multi-hop recall. This\n * module folds them into **canonical entities** so the one-hop CTE can\n * traverse relationships. Resolution is layered, cheapest first:\n *\n *   1. **lexical** — exact match on the folded {@link normalizeEntityName}.\n *   2. **embedding** — cosine over candidate name vectors; `≥ mergeThreshold`\n *      reuses the match.\n *   3. **adjudication** — a middle similarity band (`[adjudicate, merge)`)\n *      is *ambiguous*; an opt-in LLM call (provider + `llmAdjudication`)\n *      decides. **Offline / by default the ambiguous band mints a new\n *      entity** — the resolver never auto-merges on weak evidence, because\n *      a wrong merge fuses two distinct people (the stated P2-1 risk).\n *\n * The pure policy ({@link resolveEntityDecision}) is provider-agnostic and\n * does no I/O; {@link EntityResolver} wires it to an injected store +\n * embedder + optional provider. With no embedder it degrades to\n * lexical-only — still useful, and still fully offline.\n *\n * @packageDocumentation\n */\n\nimport type {\n  EmbedderProvider,\n  Fact,\n  Provider,\n  ProviderRequest,\n  SessionScope,\n} from '@graphorin/core';\nimport type { EntityWithEmbedding, GraphMemoryStoreExt } from '../internal/storage-adapter.js';\n\n/** Cosine `≥` this auto-reuses an existing entity (embedding match). */\nexport const DEFAULT_MERGE_THRESHOLD = 0.92;\n/** Cosine in `[this, merge)` is *ambiguous* — adjudicate or mint new. */\nexport const DEFAULT_ADJUDICATE_THRESHOLD = 0.82;\n\n/**\n * Outcome of the pure resolution policy. `match` reuses an existing\n * entity; `ambiguous` flags a middle-similarity candidate for the caller\n * to adjudicate (or conservatively reject); `new` mints a fresh entity.\n *\n * @stable\n */\nexport type EntityResolveDecision =\n  | {\n      readonly kind: 'match';\n      readonly entityId: string;\n      readonly similarity: number;\n      readonly via: 'lexical' | 'embedding';\n    }\n  | { readonly kind: 'ambiguous'; readonly entityId: string; readonly similarity: number }\n  | { readonly kind: 'new' };\n\n/** Minimal candidate shape the pure policy compares against. */\nexport interface ResolutionCandidate {\n  readonly id: string;\n  readonly normalizedName: string;\n  readonly vector: Float32Array | null;\n  /**\n   * MST-11: the embedder that produced `vector`. When both this and the\n   * query's `vectorEmbedderId` are known and differ, the candidate is skipped\n   * for embedding comparison — vectors from different models live in different\n   * spaces, so their cosine is meaningless. Absent on either side ⇒ compared\n   * (byte-identical to the prior behaviour).\n   */\n  readonly embedderId?: string | null;\n}\n\n/** Inputs to {@link resolveEntityDecision} (all provided by the caller). */\nexport interface ResolveDecisionInput {\n  readonly normalizedName: string;\n  readonly vector?: Float32Array | null;\n  /** MST-11: the embedder that produced `vector` (gates cross-embedder cosine). */\n  readonly vectorEmbedderId?: string | null;\n  readonly candidates: ReadonlyArray<ResolutionCandidate>;\n  readonly mergeThreshold: number;\n  readonly adjudicateThreshold: number;\n}\n\n/**\n * Fold an entity surface form into a canonical lexical key: Unicode\n * NFKC, lowercased, internal whitespace collapsed, surrounding\n * punctuation stripped. `\"  Anna S. \"` → `\"anna s\"`. Returns `''` for a\n * name with no letters/digits (the resolver treats that as \"no entity\").\n *\n * @stable\n */\nexport function normalizeEntityName(name: string): string {\n  return name\n    .normalize('NFKC')\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n    .trim()\n    .replace(/^[^\\p{L}\\p{N}]+|[^\\p{L}\\p{N}]+$/gu, '');\n}\n\n/**\n * Cosine similarity of two embeddings in `[-1, 1]`. Compares over the\n * shorter length and returns `0` when either vector is empty / zero-norm.\n *\n * @stable\n */\nexport function cosineSimilarity(a: Float32Array, b: Float32Array): number {\n  const len = Math.min(a.length, b.length);\n  let dot = 0;\n  let na = 0;\n  let nb = 0;\n  for (let i = 0; i < len; i++) {\n    const ai = a[i] ?? 0;\n    const bi = b[i] ?? 0;\n    dot += ai * bi;\n    na += ai * ai;\n    nb += bi * bi;\n  }\n  if (na === 0 || nb === 0) return 0;\n  return dot / Math.sqrt(na * nb);\n}\n\n/**\n * Pure resolution policy: lexical exact match → embedding cosine →\n * ambiguous band → new. No I/O; deterministic. The caller decides what\n * to do with `ambiguous` (LLM adjudicate, or conservatively mint new).\n *\n * @stable\n */\nexport function resolveEntityDecision(input: ResolveDecisionInput): EntityResolveDecision {\n  // 1. Exact lexical match is the cheapest + strongest signal.\n  for (const c of input.candidates) {\n    if (c.normalizedName === input.normalizedName) {\n      return { kind: 'match', entityId: c.id, similarity: 1, via: 'lexical' };\n    }\n  }\n  // 2. Embedding similarity (only when both sides have a vector).\n  const v = input.vector;\n  if (v === undefined || v === null || v.length === 0) return { kind: 'new' };\n  let bestId: string | null = null;\n  let bestSim = Number.NEGATIVE_INFINITY;\n  for (const c of input.candidates) {\n    if (c.vector === null || c.vector.length === 0) continue;\n    // MST-11: never compare vectors across embedders — different models live\n    // in different vector spaces, so their cosine is meaningless. Skip only\n    // when both embedder ids are known and differ.\n    if (\n      input.vectorEmbedderId != null &&\n      c.embedderId != null &&\n      c.embedderId !== input.vectorEmbedderId\n    ) {\n      continue;\n    }\n    const sim = cosineSimilarity(v, c.vector);\n    if (sim > bestSim) {\n      bestSim = sim;\n      bestId = c.id;\n    }\n  }\n  if (bestId === null) return { kind: 'new' };\n  if (bestSim >= input.mergeThreshold) {\n    return { kind: 'match', entityId: bestId, similarity: bestSim, via: 'embedding' };\n  }\n  if (bestSim >= input.adjudicateThreshold) {\n    return { kind: 'ambiguous', entityId: bestId, similarity: bestSim };\n  }\n  return { kind: 'new' };\n}\n\n/** Tunable thresholds + LLM-adjudication switch for {@link EntityResolver}. */\nexport interface EntityResolutionConfig {\n  /** Cosine `≥` this auto-reuses a match. Default {@link DEFAULT_MERGE_THRESHOLD}. */\n  readonly mergeThreshold?: number;\n  /** Cosine in `[this, merge)` is ambiguous. Default {@link DEFAULT_ADJUDICATE_THRESHOLD}. */\n  readonly adjudicateThreshold?: number;\n  /**\n   * Resolve the ambiguous band with one provider call. Requires a\n   * `provider`. Default `false` ⇒ ambiguous mints a new entity (no\n   * network call; never auto-merges on weak evidence).\n   */\n  readonly llmAdjudication?: boolean;\n}\n\n/** Construction deps for {@link EntityResolver}. */\nexport interface EntityResolverDeps {\n  readonly store: GraphMemoryStoreExt;\n  readonly embedder?: EmbedderProvider | null;\n  readonly embedderId?: () => string | null;\n  readonly provider?: Provider | null;\n  readonly config?: EntityResolutionConfig;\n}\n\nconst ADJUDICATION_SYSTEM_PROMPT =\n  'You decide whether two short names refer to the SAME real-world entity ' +\n  '(person, place, org, thing). Reply with a single word: \"yes\" or \"no\". ' +\n  'Be conservative — answer \"no\" unless they are clearly the same entity.';\n\n/** Build the (pure) adjudication request. Exposed for testing. */\nexport function buildAdjudicationRequest(\n  nameA: string,\n  nameB: string,\n  options: { readonly signal?: AbortSignal } = {},\n): ProviderRequest {\n  return {\n    messages: [{ role: 'user', content: `Name A: ${nameA}\\nName B: ${nameB}\\nSame entity?` }],\n    systemMessage: ADJUDICATION_SYSTEM_PROMPT,\n    temperature: 0,\n    maxTokens: 4,\n    ...(options.signal !== undefined ? { signal: options.signal } : {}),\n  };\n}\n\n/** Parse a yes/no adjudication reply. Conservative: only a clear yes is `true`. */\nexport function parseAdjudication(text: string): boolean {\n  return /^\\s*(yes|true|same)\\b/i.test(text);\n}\n\n/**\n * Resolves a fact's subject / object strings to canonical entity ids and\n * links them, applying {@link resolveEntityDecision} backed by an\n * injected store + embedder (+ optional provider for adjudication).\n * Constructed only when entity resolution is opted in\n * (`createMemory({ graph: { entityResolution: true } })`); otherwise the\n * write path skips it and behaviour is unchanged + offline.\n *\n * @stable\n */\nexport class EntityResolver {\n  readonly #store: GraphMemoryStoreExt;\n  readonly #embedder: EmbedderProvider | null;\n  readonly #embedderId: () => string | null;\n  readonly #provider: Provider | null;\n  readonly #mergeThreshold: number;\n  readonly #adjudicateThreshold: number;\n  readonly #llmAdjudication: boolean;\n\n  constructor(deps: EntityResolverDeps) {\n    this.#store = deps.store;\n    this.#embedder = deps.embedder ?? null;\n    this.#embedderId = deps.embedderId ?? (() => null);\n    this.#provider = deps.provider ?? null;\n    this.#mergeThreshold = deps.config?.mergeThreshold ?? DEFAULT_MERGE_THRESHOLD;\n    this.#adjudicateThreshold = deps.config?.adjudicateThreshold ?? DEFAULT_ADJUDICATE_THRESHOLD;\n    this.#llmAdjudication = deps.config?.llmAdjudication ?? false;\n  }\n\n  /**\n   * Resolve a single name to a canonical entity id (find-or-create),\n   * deduping via lexical + embedding similarity. Returns `null` for a\n   * name that normalizes to empty (no entity).\n   */\n  async resolve(\n    scope: SessionScope,\n    rawName: string,\n    opts: { readonly signal?: AbortSignal } = {},\n  ): Promise<string | null> {\n    const normalizedName = normalizeEntityName(rawName);\n    if (normalizedName.length === 0) return null;\n    // 1. Exact lexical match — the cheapest, strongest signal. Resolve it via\n    //    an uncapped indexed lookup so an alias of an arbitrarily-old entity\n    //    dedups without scanning (and deserializing) the bounded candidate\n    //    window, and short-circuits before any embedding call (CS-11). Stores\n    //    that don't implement it fall through to the capped lexical scan below.\n    const exact = await this.#store.findEntityByNormalizedName?.(scope, normalizedName);\n    if (exact != null) return exact.id;\n    const vector = await this.#embed(rawName, opts.signal);\n    // 2. Without a query vector, embedding dedup is impossible — skip the\n    //    BLOB-deserializing candidate scan entirely and mint a new entity.\n    if (vector === null || vector.length === 0) {\n      return this.#create(scope, rawName, normalizedName, vector);\n    }\n    const candidates = await this.#store.listEntities(scope);\n    const decision = resolveEntityDecision({\n      normalizedName,\n      vector,\n      vectorEmbedderId: this.#embedderId(),\n      candidates,\n      mergeThreshold: this.#mergeThreshold,\n      adjudicateThreshold: this.#adjudicateThreshold,\n    });\n    if (decision.kind === 'match') return decision.entityId;\n    if (decision.kind === 'ambiguous') {\n      if (this.#llmAdjudication && this.#provider !== null) {\n        const same = await this.#adjudicate(rawName, decision.entityId, candidates, opts.signal);\n        if (same) return decision.entityId;\n      }\n      // Conservative default: weak evidence ⇒ a distinct new entity.\n    }\n    return this.#create(scope, rawName, normalizedName, vector);\n  }\n\n  /**\n   * Resolve + link a fact's subject and object (the predicate is a\n   * relation label, never an entity). Idempotent on re-link.\n   */\n  async linkFact(\n    scope: SessionScope,\n    fact: Fact,\n    opts: { readonly signal?: AbortSignal } = {},\n  ): Promise<void> {\n    if (fact.subject !== undefined) {\n      const id = await this.resolve(scope, fact.subject, opts);\n      if (id !== null) await this.#store.linkFactEntity(fact.id, id, 'subject');\n    }\n    if (fact.object !== undefined) {\n      const id = await this.resolve(scope, fact.object, opts);\n      if (id !== null) await this.#store.linkFactEntity(fact.id, id, 'object');\n    }\n  }\n\n  async #embed(name: string, signal?: AbortSignal): Promise<Float32Array | null> {\n    const embedder = this.#embedder;\n    if (embedder === null || this.#embedderId() === null) return null;\n    void signal;\n    try {\n      const [vector] = await embedder.embed([name]);\n      return vector ?? null;\n    } catch {\n      return null;\n    }\n  }\n\n  async #create(\n    scope: SessionScope,\n    name: string,\n    normalizedName: string,\n    vector: Float32Array | null,\n  ): Promise<string> {\n    const embedderId = this.#embedderId();\n    return this.#store.upsertEntity(scope, {\n      name,\n      normalizedName,\n      ...(vector !== null ? { vector } : {}),\n      ...(vector !== null && embedderId !== null ? { embedderId } : {}),\n    });\n  }\n\n  async #adjudicate(\n    name: string,\n    candidateId: string,\n    candidates: ReadonlyArray<EntityWithEmbedding>,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    const provider = this.#provider;\n    if (provider === null) return false;\n    const candidate = candidates.find((c) => c.id === candidateId);\n    if (candidate === undefined) return false;\n    try {\n      const request = buildAdjudicationRequest(name, candidate.name, {\n        ...(signal !== undefined ? { signal } : {}),\n      });\n      const response = await provider.generate(request);\n      return parseAdjudication(response.text ?? '');\n    } catch {\n      return false;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/graph/index.d.ts

@@ -0,0 +1 @@
+import { DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_MERGE_THRESHOLD, EntityResolutionConfig, EntityResolveDecision, EntityResolver, EntityResolverDeps, ResolutionCandidate, ResolveDecisionInput, buildAdjudicationRequest, cosineSimilarity, normalizeEntityName, parseAdjudication, resolveEntityDecision } from "./entity-resolver.js";

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import { EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderRegistrationError, GraphorinMemoryError, MemoryToolDeniedError, ProcedureInductionNotConfiguredError, QuarantinePromotionRefusedError, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError } from "./errors/index.js";
+import { LocaleMatch, LocalePack, LocalePatternEntry, LocaleSupersedeKind, defineLocalePack, evaluateMarkers } from "./conflict/locale-packs/types.js";
+import { ConflictAuditDecision, ConflictAuditInputLike, ConflictAuditStage, ConflictMemoryStoreExt, ConsolidatorMemoryStoreExt, ConsolidatorRunFinish, ConsolidatorRunInput, ConsolidatorStatePatch, ConsolidatorStateRow, DecayMemoryStoreExt, DlqBatchInput, DlqBatchRow, EmbeddedWriteOptions, EmbeddingMetaRegistryLike, EpisodicMemoryStoreExt, InsightListOptions as InsightListOptions$1, InsightMemoryStoreExt, InsightSearchStoreOptions, MemoryStoreAdapter, PendingConflictInputLike, PendingConflictRowLike, SemanticMemoryStoreExt, SessionMemoryStoreExt, SessionMessageRecord } from "./internal/storage-adapter.js";
+import { ConflictDecision, ConflictPipeline, ConflictPipelineDeps, ConflictPipelineOptions, ConflictStage, ConflictThresholds, DEFAULT_CONFLICT_THRESHOLDS, PipelineStage, ReconcileAction, ReconcileDecision, StageContext, StageOutcome, reconcileToConflictDecision } from "./conflict/types.js";
+import { _resetBypassWarningForTesting, createConflictPipeline, runConflictPipeline } from "./conflict/pipeline.js";
+import "./conflict/index.js";
+import { ContextualRetrievalMode } from "./internal/contextualize.js";
+import { EpisodeInput, EpisodeRetrievalWeights, EpisodeSearchOptions, EpisodicMemory } from "./tiers/episodic-memory.js";
+import { DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_MERGE_THRESHOLD, EntityResolutionConfig, EntityResolveDecision, EntityResolver, EntityResolverDeps, ResolutionCandidate, ResolveDecisionInput, buildAdjudicationRequest, cosineSimilarity, normalizeEntityName, parseAdjudication, resolveEntityDecision } from "./graph/entity-resolver.js";
+import { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, DifficultyAssessment, DifficultyGateOptions, IterativeRetrievalDeps, IterativeRetrievalOptions, IterativeRetrievalResult, MAX_ITERATIONS_CEILING, RETRIEVAL_GRADE_SYSTEM_PROMPT, RetrievalGrade, RetrievalGradeOptions, RetrievalGrader, assessQueryDifficulty, buildGradeRequest, createProviderRetrievalGrader, parseGrade, runIterativeRetrieval } from "./search/iterative.js";
+import { DEFAULT_MAX_QUERY_VARIANTS, HYDE_SYSTEM_PROMPT, QUERY_EXPANSION_SYSTEM_PROMPT, QueryTransformOptions, QueryTransformer, buildExpansionRequest, buildHydeRequest, createProviderQueryTransformer, parseHypothetical, parseQueryVariants } from "./search/query-transform.js";
+import { ReRankOptions, ReRanker } from "./search/types.js";
+import { FactInput, FactRememberOptions, FactSearchOptions, FusionStrategy, FusionWeights, IterativeRecallResult, IterativeSearchOptions, RememberOutcome, SemanticMemory } from "./tiers/semantic-memory.js";
+import { CONSOLIDATOR_TIER_DEFAULTS, ConsolidatorBudgetSnapshot, ConsolidatorCeilings, ConsolidatorConfig, ConsolidatorLastRuns, ConsolidatorPhase, ConsolidatorStatus, ConsolidatorTier, ConsolidatorTriggerReason, ConsolidatorTriggerSpec, CreateConsolidatorOptions, OnBudgetExceed, PhaseListener, PhaseOutcome } from "./consolidator/types.js";
+import { ParsedTrigger, parseTriggerSpec, reasonFromTrigger } from "./consolidator/triggers.js";
+import { ConsolidatorCatchupPolicy, RegisterTriggersOptions, RegisterTriggersResult, SchedulerLike, TriggerDeclarationLike, registerConsolidatorTriggers } from "./consolidator/scheduler.js";
+import { Consolidator, createConsolidator } from "./consolidator/runtime.js";
+import { BudgetExceededError, CustomTierMisconfiguredError, ProviderNotConfiguredError } from "./consolidator/errors.js";
+import { DEFAULT_INDUCTION_MAX_TOKENS, INDUCTION_SYSTEM_PROMPT, InducedProcedure, MAX_PROCEDURE_STEPS, MAX_TRAJECTORY_STEPS_SHOWN, Trajectory, TrajectoryStep, VerificationResult, WorkflowInducer, WorkflowInductionOptions, buildInductionRequest, checkSuccessCriteria, createProviderWorkflowInducer, normalizeInducedProcedure, parseInducedProcedure, runWorkflowInduction, trajectoryFromRunState } from "./consolidator/phases/induce.js";
+import { createConsolidatorPlaceholder } from "./consolidator/index.js";
+import { CONTENT_ORIGIN_ATTR, ContentAnnotation, ContentOrigin, INBOUND_TRUST_ATTR, InboundTrust, NON_INBOUND_ORIGINS, annotate, shouldFireInboundPreamble, toSpanAttributes } from "./context-engine/annotations.js";
+import { AutoRecallTriggers, BaseTemplateFragments, CompactionSummaryTemplate, ContextLocalePack, InboundSanitizationPreamble, PartialContextLocalePack, defineContextLocalePack } from "./context-engine/locale-packs/types.js";
+import { enLocalePack } from "./context-engine/locale-packs/en.js";
+import { AutoRecallStrategy, AutoRecallStrategyContext, AutoRecallTriggerResult, defaultLocaleHeuristicStrategy, defineAutoRecallStrategy } from "./context-engine/auto-recall.js";
+import { ContextTokenCounter, HEURISTIC_TOKEN_COUNTER, adaptTokenCounter, countMessageTokens, renderMessageText } from "./context-engine/token-counter.js";
+import { CLEARED_TOOL_RESULT_MARKER, ClearToolResultsOptions, ClearToolResultsOutcome, clearOldToolResults } from "./context-engine/compaction/clear-tool-results.js";
+import { CompactionConfig, CompactionContext, CompactionResult, CompactionSource, CompactionStrategy, CompactionSummarizer, CompactionTriggerConfig, PostCompactionHook, PostCompactionHookContext } from "./context-engine/compaction/types.js";
+import { DEFAULT_PRESERVE_RECENT_TURNS, ExecuteCompactionInput, executeCompaction } from "./context-engine/compaction/compactor.js";
+import { NamedPostCompactionHook } from "./context-engine/compaction/hooks/types.js";
+import { reanchorPersonaBlock } from "./context-engine/compaction/hooks/reanchor-persona-block.js";
+import { reanchorPinnedFacts } from "./context-engine/compaction/hooks/reanchor-pinned-facts.js";
+import { reanchorProjectRules } from "./context-engine/compaction/hooks/reanchor-project-rules.js";
+import { CompactionMetadataPayload, RenderedTemplate, SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, buildSummarizerPrompt, renderFinalSummary } from "./context-engine/compaction/templates/summary-9-section.js";
+import { AutoCompactionDefault, DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, resolveAutoCompactionDefault, resolveTriggerThreshold } from "./context-engine/compaction/thresholds.js";
+import { PartitionResult, PrivacyDecision, PrivacyDecisionReason, PrivacyFilterContext, decide, effectiveAcceptsSensitivity, partition } from "./context-engine/privacy-filter.js";
+import { MemoryBaseMode, SkillMetadataCard, composeInboundPreamble, composeLayer1, composeLayer2, composeLayer4Skills } from "./context-engine/templates/composer.js";
+import { AllocationResult, DEFAULT_LAYER_PRIORITY, LayerAllocation, LayerCandidate, LayerId, OverflowMode, allocate, truncateToTokens } from "./context-engine/token-budget.js";
+import { AnnotatedPart, AssembleInput, AssembledPrompt, AutoRecallConfig, ContextEngine, ContextEngineConfig, LayerConfig, PrivacyConfig, ResolvedContextEngineConfig, createContextEngine } from "./context-engine/engine.js";
+import { LocaleResolverLogger, _getLocaleFallbackWarningsForTesting, _resetLocaleFallbackWarningsForTesting, resolveLocalePack } from "./context-engine/locale-packs/resolver.js";
+import { MemoryMetadataDeps, gatherMemoryMetadata, renderMetadataBlock } from "./context-engine/metadata.js";
+import { INBOUND_SANITIZATION_PREAMBLE_EN } from "./context-engine/preambles/inbound-en.js";
+import { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL } from "./context-engine/templates/base-en.js";
+import { CompileOptions, CompileScope, MemoryContextBlocks } from "./context-engine/index.js";
+import { InsightListOptions, InsightMemory, InsightSearchOptions, capInsightsBelowFacts } from "./tiers/insight-memory.js";
+import { InduceOptions, ProceduralMemory, RuleActivationContext, RuleInput } from "./tiers/procedural-memory.js";
+import { SessionCompactionPolicy, SessionCompactionResult, SessionMemory } from "./tiers/session-memory.js";
+import { SharedMemory } from "./tiers/shared-memory.js";
+import { BlockDefinition, BlockSpec, WorkingMemory, defineBlock } from "./tiers/working-memory.js";
+import { MemoryToolDeps, ScopeResolver } from "./tools/types.js";
+import { createBlockAppendTool, createBlockReplaceTool, createBlockRethinkTool } from "./tools/block-tools.js";
+import { createFactForgetTool, createFactHistoryTool, createFactRememberTool, createFactSearchTool, createFactSupersedeTool, createFactValidateTool } from "./tools/fact-tools.js";
+import { createConversationSearchTool, createDeepRecallTool, createRecallEpisodesTool } from "./tools/recall-tools.js";
+import { BuildMemoryToolsOptions, buildMemoryTools } from "./tools/index.js";
+import { CreateMemoryOptions, Memory, _resetConsolidatorConfigWarningForTesting, createMemory } from "./facade.js";
+import "./graph/index.js";
+import { EmbedderMigrationStrategy, MigrateEmbedderOptions, MigrationProgress, migrateEmbedder } from "./migration/embedder-migration.js";
+import "./migration/index.js";
+import { RecallExplanation, RecalledMemoryExplanation, explainRecall, formatRecallExplanation } from "./search/explain.js";
+import { RRFReranker, RRF_DEFAULT_K, WeightedRRFReranker, fuseRrf, fuseWeighted } from "./search/rrf.js";
+import "./search/index.js";
+import "./tiers/index.js";
+
+//#region src/index.d.ts
+/**
+ * `@graphorin/memory` — seven-tier memory system for the Graphorin
+ * framework (MST-13: working / session / episodic / semantic /
+ * procedural / shared + the read-only insight tier from P1-1).
+ *
+ * Surface overview:
+ *
+ *  - The {@link createMemory} facade that wires every tier sub-module
+ *    + the memory tools + the search reranker + the context-engine +
+ *    the consolidator.
+ *  - Tier sub-modules under `./tiers`: {@link WorkingMemory},
+ *    {@link SessionMemory}, {@link EpisodicMemory}, {@link SemanticMemory},
+ *    {@link ProceduralMemory}, {@link SharedMemory}, plus the read-only
+ *    {@link InsightMemory}.
+ *  - Eleven memory tools under `./tools` (plus the gated twelfth,
+ *    `deep_recall`, registered only when iterative retrieval is
+ *    configured): `block_append`, `block_replace`, `block_rethink`,
+ *    `fact_remember`, `fact_search`, `fact_supersede`, `fact_forget`,
+ *    `recall_episodes`, `conversation_search`, `fact_history` (P0-2),
+ *    `fact_validate` (P1-4).
+ *  - The hybrid search composition under `./search`, including the
+ *    built-in {@link RRFReranker} (k=60 default) and the
+ *    {@link ReRanker} contract.
+ *  - The embedder migration runner under `./migration`
+ *    ({@link migrateEmbedder} with three coexistence policies).
+ *  - Typed errors under `./errors`.
+ *
+ * Forward-looking surfaces (for ergonomic typing today):
+ *
+ *  - {@link MemoryContextBlocks} + {@link CompileOptions} from `./context-engine`.
+ *  - {@link Consolidator}, {@link ConsolidatorTriggerSpec},
+ *    {@link ConsolidatorTier} from `./consolidator`.
+ *
+ * @packageDocumentation
+ */
+/** Canonical version constant. Mirrors the `package.json` version. */
+declare const VERSION = "0.5.0";
+//#endregion
+export { type AllocationResult, type AnnotatedPart, type AssembleInput, type AssembledPrompt, type AutoCompactionDefault, type AutoRecallConfig, type AutoRecallStrategy, type AutoRecallStrategyContext, type AutoRecallTriggerResult, type AutoRecallTriggers, BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL, type BaseTemplateFragments, BlockDefinition, BlockSpec, BudgetExceededError, type BuildMemoryToolsOptions, CLEARED_TOOL_RESULT_MARKER, CONSOLIDATOR_TIER_DEFAULTS, CONTENT_ORIGIN_ATTR, type ClearToolResultsOptions, type ClearToolResultsOutcome, type CompactionConfig, type CompactionContext, type CompactionMetadataPayload, type CompactionResult, type CompactionSource, type CompactionStrategy, type CompactionSummarizer, type CompactionSummaryTemplate, type CompactionTriggerConfig, type CompileOptions, type CompileScope, type ConflictAuditDecision, type ConflictAuditInputLike, type ConflictAuditStage, ConflictDecision, type ConflictMemoryStoreExt, ConflictPipeline, ConflictPipelineDeps, ConflictPipelineOptions, ConflictStage, ConflictThresholds, type Consolidator, type ConsolidatorBudgetSnapshot, type ConsolidatorCatchupPolicy, type ConsolidatorCeilings, type ConsolidatorConfig, type ConsolidatorLastRuns, type ConsolidatorMemoryStoreExt, type ConsolidatorPhase, type ConsolidatorRunFinish, type ConsolidatorRunInput, type ConsolidatorStatePatch, type ConsolidatorStateRow, type ConsolidatorStatus, type ConsolidatorTier, type ConsolidatorTriggerReason, type ConsolidatorTriggerSpec, type ContentAnnotation, type ContentOrigin, type ContextEngine, type ContextEngineConfig, type ContextLocalePack, type ContextTokenCounter, type ContextualRetrievalMode, type CreateConsolidatorOptions, type CreateMemoryOptions, CustomTierMisconfiguredError, DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_CONFLICT_THRESHOLDS, DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_INDUCTION_MAX_TOKENS, DEFAULT_LAYER_PRIORITY, DEFAULT_MAX_ITERATIONS, DEFAULT_MAX_QUERY_VARIANTS, DEFAULT_MERGE_THRESHOLD, DEFAULT_PRESERVE_RECENT_TURNS, DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, type DecayMemoryStoreExt, DifficultyAssessment, DifficultyGateOptions, type DlqBatchInput, type DlqBatchRow, type EmbeddedWriteOptions, EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderMigrationStrategy, EmbedderRegistrationError, type EmbeddingMetaRegistryLike, EntityResolutionConfig, EntityResolveDecision, EntityResolver, EntityResolverDeps, EpisodeInput, EpisodeRetrievalWeights, EpisodeSearchOptions, EpisodicMemory, type EpisodicMemoryStoreExt, type ExecuteCompactionInput, FactInput, FactRememberOptions, FactSearchOptions, FusionStrategy, FusionWeights, GraphorinMemoryError, HEURISTIC_TOKEN_COUNTER, HYDE_SYSTEM_PROMPT, INBOUND_SANITIZATION_PREAMBLE_EN, INBOUND_TRUST_ATTR, INDUCTION_SYSTEM_PROMPT, type InboundSanitizationPreamble, type InboundTrust, InduceOptions, type InducedProcedure, InsightListOptions, InsightMemory, type InsightMemoryStoreExt, InsightSearchOptions, type InsightSearchStoreOptions, type InsightListOptions$1 as InsightStoreListOptions, IterativeRecallResult, IterativeRetrievalDeps, IterativeRetrievalOptions, IterativeRetrievalResult, IterativeSearchOptions, type LayerAllocation, type LayerCandidate, type LayerConfig, type LayerId, LocaleMatch, LocalePack, LocalePatternEntry, type LocaleResolverLogger, LocaleSupersedeKind, MAX_ITERATIONS_CEILING, MAX_PROCEDURE_STEPS, MAX_TRAJECTORY_STEPS_SHOWN, type Memory, type MemoryBaseMode, type MemoryContextBlocks, type MemoryMetadataDeps, type MemoryStoreAdapter, MemoryToolDeniedError, type MemoryToolDeps, MigrateEmbedderOptions, MigrationProgress, NON_INBOUND_ORIGINS, type NamedPostCompactionHook, type OnBudgetExceed, type OverflowMode, type ParsedTrigger, type PartialContextLocalePack, type PartitionResult, type PendingConflictInputLike, type PendingConflictRowLike, type PhaseListener, type PhaseOutcome, PipelineStage, type PostCompactionHook, type PostCompactionHookContext, type PrivacyConfig, type PrivacyDecision, type PrivacyDecisionReason, type PrivacyFilterContext, ProceduralMemory, ProcedureInductionNotConfiguredError, ProviderNotConfiguredError, QUERY_EXPANSION_SYSTEM_PROMPT, QuarantinePromotionRefusedError, QueryTransformOptions, QueryTransformer, RETRIEVAL_GRADE_SYSTEM_PROMPT, RRFReranker, RRF_DEFAULT_K, ReRankOptions, ReRanker, RecallExplanation, RecalledMemoryExplanation, ReconcileAction, ReconcileDecision, type RegisterTriggersOptions, type RegisterTriggersResult, RememberOutcome, type RenderedTemplate, ResolutionCandidate, ResolveDecisionInput, type ResolvedContextEngineConfig, RetrievalGrade, RetrievalGradeOptions, RetrievalGrader, RuleActivationContext, RuleInput, SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, type SchedulerLike, type ScopeResolver, SemanticMemory, type SemanticMemoryStoreExt, SessionCompactionPolicy, SessionCompactionResult, SessionMemory, type SessionMemoryStoreExt, type SessionMessageRecord, SharedMemory, type SkillMetadataCard, StageContext, StageOutcome, type Trajectory, type TrajectoryStep, type TriggerDeclarationLike, VERSION, type VerificationResult, WeightedRRFReranker, type WorkflowInducer, type WorkflowInductionOptions, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError, WorkingMemory, _getLocaleFallbackWarningsForTesting, _resetBypassWarningForTesting, _resetConsolidatorConfigWarningForTesting, _resetLocaleFallbackWarningsForTesting, adaptTokenCounter, allocate as allocateTokenBudget, annotate, assessQueryDifficulty, buildAdjudicationRequest, buildExpansionRequest, buildGradeRequest, buildHydeRequest, buildInductionRequest, buildMemoryTools, buildSummarizerPrompt, capInsightsBelowFacts, checkSuccessCriteria, clearOldToolResults, composeInboundPreamble, composeLayer1, composeLayer2, composeLayer4Skills, cosineSimilarity, countMessageTokens, createBlockAppendTool, createBlockReplaceTool, createBlockRethinkTool, createConflictPipeline, createConsolidator, createConsolidatorPlaceholder, createContextEngine, createConversationSearchTool, createDeepRecallTool, createFactForgetTool, createFactHistoryTool, createFactRememberTool, createFactSearchTool, createFactSupersedeTool, createFactValidateTool, createMemory, createProviderQueryTransformer, createProviderRetrievalGrader, createProviderWorkflowInducer, createRecallEpisodesTool, defaultLocaleHeuristicStrategy, defineAutoRecallStrategy, defineBlock, defineContextLocalePack, defineLocalePack, effectiveAcceptsSensitivity, enLocalePack, evaluateMarkers, executeCompaction, explainRecall, formatRecallExplanation, fuseRrf, fuseWeighted, gatherMemoryMetadata, migrateEmbedder, normalizeEntityName, normalizeInducedProcedure, parseAdjudication, parseGrade, parseHypothetical, parseInducedProcedure, parseQueryVariants, parseTriggerSpec, partition as partitionBySensitivity, decide as privacyDecide, reanchorPersonaBlock, reanchorPinnedFacts, reanchorProjectRules, reasonFromTrigger, reconcileToConflictDecision, registerConsolidatorTriggers, renderFinalSummary, renderMessageText, renderMetadataBlock, resolveAutoCompactionDefault, resolveEntityDecision, resolveLocalePack, resolveTriggerThreshold, runConflictPipeline, runIterativeRetrieval, runWorkflowInduction, shouldFireInboundPreamble, toSpanAttributes, trajectoryFromRunState, truncateToTokens };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,OAAA"}

package/dist/index.js

@@ -0,0 +1,95 @@
+import { defineLocalePack, evaluateMarkers } from "./conflict/locale-packs/types.js";
+import { DEFAULT_CONFLICT_THRESHOLDS, reconcileToConflictDecision } from "./conflict/types.js";
+import { _resetBypassWarningForTesting, createConflictPipeline, runConflictPipeline } from "./conflict/pipeline.js";
+import "./conflict/index.js";
+import { EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderRegistrationError, GraphorinMemoryError, MemoryToolDeniedError, ProcedureInductionNotConfiguredError, QuarantinePromotionRefusedError, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError } from "./errors/index.js";
+import { BudgetExceededError, CustomTierMisconfiguredError, ProviderNotConfiguredError } from "./consolidator/errors.js";
+import { DEFAULT_INDUCTION_MAX_TOKENS, INDUCTION_SYSTEM_PROMPT, MAX_PROCEDURE_STEPS, MAX_TRAJECTORY_STEPS_SHOWN, buildInductionRequest, checkSuccessCriteria, createProviderWorkflowInducer, normalizeInducedProcedure, parseInducedProcedure, runWorkflowInduction, trajectoryFromRunState } from "./consolidator/phases/induce.js";
+import { parseTriggerSpec, reasonFromTrigger } from "./consolidator/triggers.js";
+import { registerConsolidatorTriggers } from "./consolidator/scheduler.js";
+import { CONSOLIDATOR_TIER_DEFAULTS } from "./consolidator/types.js";
+import { createConsolidator } from "./consolidator/runtime.js";
+import { createConsolidatorPlaceholder } from "./consolidator/index.js";
+import { CONTENT_ORIGIN_ATTR, INBOUND_TRUST_ATTR, NON_INBOUND_ORIGINS, annotate, shouldFireInboundPreamble, toSpanAttributes } from "./context-engine/annotations.js";
+import { defaultLocaleHeuristicStrategy, defineAutoRecallStrategy } from "./context-engine/auto-recall.js";
+import { HEURISTIC_TOKEN_COUNTER, adaptTokenCounter, countMessageTokens, renderMessageText } from "./context-engine/token-counter.js";
+import { CLEARED_TOOL_RESULT_MARKER, clearOldToolResults } from "./context-engine/compaction/clear-tool-results.js";
+import { SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, buildSummarizerPrompt, renderFinalSummary } from "./context-engine/compaction/templates/summary-9-section.js";
+import { DEFAULT_PRESERVE_RECENT_TURNS, executeCompaction } from "./context-engine/compaction/compactor.js";
+import { reanchorPersonaBlock } from "./context-engine/compaction/hooks/reanchor-persona-block.js";
+import { reanchorPinnedFacts } from "./context-engine/compaction/hooks/reanchor-pinned-facts.js";
+import { reanchorProjectRules } from "./context-engine/compaction/hooks/reanchor-project-rules.js";
+import { DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, resolveAutoCompactionDefault, resolveTriggerThreshold } from "./context-engine/compaction/thresholds.js";
+import { enLocalePack } from "./context-engine/locale-packs/en.js";
+import { defineContextLocalePack } from "./context-engine/locale-packs/types.js";
+import { _getLocaleFallbackWarningsForTesting, _resetLocaleFallbackWarningsForTesting, resolveLocalePack } from "./context-engine/locale-packs/resolver.js";
+import { gatherMemoryMetadata, renderMetadataBlock } from "./context-engine/metadata.js";
+import { decide, effectiveAcceptsSensitivity, partition } from "./context-engine/privacy-filter.js";
+import { composeInboundPreamble, composeLayer1, composeLayer2, composeLayer4Skills } from "./context-engine/templates/composer.js";
+import { DEFAULT_LAYER_PRIORITY, allocate, truncateToTokens } from "./context-engine/token-budget.js";
+import { createContextEngine } from "./context-engine/engine.js";
+import { INBOUND_SANITIZATION_PREAMBLE_EN } from "./context-engine/preambles/inbound-en.js";
+import { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL } from "./context-engine/templates/base-en.js";
+import "./context-engine/index.js";
+import { DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_MERGE_THRESHOLD, EntityResolver, buildAdjudicationRequest, cosineSimilarity, normalizeEntityName, parseAdjudication, resolveEntityDecision } from "./graph/entity-resolver.js";
+import { DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_MAX_ITERATIONS, MAX_ITERATIONS_CEILING, RETRIEVAL_GRADE_SYSTEM_PROMPT, assessQueryDifficulty, buildGradeRequest, createProviderRetrievalGrader, parseGrade, runIterativeRetrieval } from "./search/iterative.js";
+import { DEFAULT_MAX_QUERY_VARIANTS, HYDE_SYSTEM_PROMPT, QUERY_EXPANSION_SYSTEM_PROMPT, buildExpansionRequest, buildHydeRequest, createProviderQueryTransformer, parseHypothetical, parseQueryVariants } from "./search/query-transform.js";
+import { RRFReranker, RRF_DEFAULT_K, WeightedRRFReranker, fuseRrf, fuseWeighted } from "./search/rrf.js";
+import { EpisodicMemory } from "./tiers/episodic-memory.js";
+import { InsightMemory, capInsightsBelowFacts } from "./tiers/insight-memory.js";
+import { ProceduralMemory } from "./tiers/procedural-memory.js";
+import { explainRecall, formatRecallExplanation } from "./search/explain.js";
+import { SemanticMemory } from "./tiers/semantic-memory.js";
+import { SessionMemory } from "./tiers/session-memory.js";
+import { SharedMemory } from "./tiers/shared-memory.js";
+import { WorkingMemory, defineBlock } from "./tiers/working-memory.js";
+import { createBlockAppendTool, createBlockReplaceTool, createBlockRethinkTool } from "./tools/block-tools.js";
+import { createFactForgetTool, createFactHistoryTool, createFactRememberTool, createFactSearchTool, createFactSupersedeTool, createFactValidateTool } from "./tools/fact-tools.js";
+import { createConversationSearchTool, createDeepRecallTool, createRecallEpisodesTool } from "./tools/recall-tools.js";
+import { buildMemoryTools } from "./tools/index.js";
+import { _resetConsolidatorConfigWarningForTesting, createMemory } from "./facade.js";
+import { migrateEmbedder } from "./migration/embedder-migration.js";
+import "./tiers/index.js";
+
+//#region src/index.ts
+/**
+* `@graphorin/memory` — seven-tier memory system for the Graphorin
+* framework (MST-13: working / session / episodic / semantic /
+* procedural / shared + the read-only insight tier from P1-1).
+*
+* Surface overview:
+*
+*  - The {@link createMemory} facade that wires every tier sub-module
+*    + the memory tools + the search reranker + the context-engine +
+*    the consolidator.
+*  - Tier sub-modules under `./tiers`: {@link WorkingMemory},
+*    {@link SessionMemory}, {@link EpisodicMemory}, {@link SemanticMemory},
+*    {@link ProceduralMemory}, {@link SharedMemory}, plus the read-only
+*    {@link InsightMemory}.
+*  - Eleven memory tools under `./tools` (plus the gated twelfth,
+*    `deep_recall`, registered only when iterative retrieval is
+*    configured): `block_append`, `block_replace`, `block_rethink`,
+*    `fact_remember`, `fact_search`, `fact_supersede`, `fact_forget`,
+*    `recall_episodes`, `conversation_search`, `fact_history` (P0-2),
+*    `fact_validate` (P1-4).
+*  - The hybrid search composition under `./search`, including the
+*    built-in {@link RRFReranker} (k=60 default) and the
+*    {@link ReRanker} contract.
+*  - The embedder migration runner under `./migration`
+*    ({@link migrateEmbedder} with three coexistence policies).
+*  - Typed errors under `./errors`.
+*
+* Forward-looking surfaces (for ergonomic typing today):
+*
+*  - {@link MemoryContextBlocks} + {@link CompileOptions} from `./context-engine`.
+*  - {@link Consolidator}, {@link ConsolidatorTriggerSpec},
+*    {@link ConsolidatorTier} from `./consolidator`.
+*
+* @packageDocumentation
+*/
+/** Canonical version constant. Mirrors the `package.json` version. */
+const VERSION = "0.5.0";
+
+//#endregion
+export { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL, BudgetExceededError, CLEARED_TOOL_RESULT_MARKER, CONSOLIDATOR_TIER_DEFAULTS, CONTENT_ORIGIN_ATTR, CustomTierMisconfiguredError, DEFAULT_ADJUDICATE_THRESHOLD, DEFAULT_CONFLICT_THRESHOLDS, DEFAULT_DIFFICULTY_THRESHOLD, DEFAULT_INDUCTION_MAX_TOKENS, DEFAULT_LAYER_PRIORITY, DEFAULT_MAX_ITERATIONS, DEFAULT_MAX_QUERY_VARIANTS, DEFAULT_MERGE_THRESHOLD, DEFAULT_PRESERVE_RECENT_TURNS, DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, EmbedderMigrationAbortedError, EmbedderMigrationLockedError, EmbedderMigrationStateError, EmbedderRegistrationError, EntityResolver, EpisodicMemory, GraphorinMemoryError, HEURISTIC_TOKEN_COUNTER, HYDE_SYSTEM_PROMPT, INBOUND_SANITIZATION_PREAMBLE_EN, INBOUND_TRUST_ATTR, INDUCTION_SYSTEM_PROMPT, InsightMemory, MAX_ITERATIONS_CEILING, MAX_PROCEDURE_STEPS, MAX_TRAJECTORY_STEPS_SHOWN, MemoryToolDeniedError, NON_INBOUND_ORIGINS, ProceduralMemory, ProcedureInductionNotConfiguredError, ProviderNotConfiguredError, QUERY_EXPANSION_SYSTEM_PROMPT, QuarantinePromotionRefusedError, RETRIEVAL_GRADE_SYSTEM_PROMPT, RRFReranker, RRF_DEFAULT_K, SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, SemanticMemory, SessionMemory, SharedMemory, VERSION, WeightedRRFReranker, WorkingBlockOverflowError, WorkingBlockReadOnlyError, WorkingBlockReplaceMismatchError, WorkingMemory, _getLocaleFallbackWarningsForTesting, _resetBypassWarningForTesting, _resetConsolidatorConfigWarningForTesting, _resetLocaleFallbackWarningsForTesting, adaptTokenCounter, allocate as allocateTokenBudget, annotate, assessQueryDifficulty, buildAdjudicationRequest, buildExpansionRequest, buildGradeRequest, buildHydeRequest, buildInductionRequest, buildMemoryTools, buildSummarizerPrompt, capInsightsBelowFacts, checkSuccessCriteria, clearOldToolResults, composeInboundPreamble, composeLayer1, composeLayer2, composeLayer4Skills, cosineSimilarity, countMessageTokens, createBlockAppendTool, createBlockReplaceTool, createBlockRethinkTool, createConflictPipeline, createConsolidator, createConsolidatorPlaceholder, createContextEngine, createConversationSearchTool, createDeepRecallTool, createFactForgetTool, createFactHistoryTool, createFactRememberTool, createFactSearchTool, createFactSupersedeTool, createFactValidateTool, createMemory, createProviderQueryTransformer, createProviderRetrievalGrader, createProviderWorkflowInducer, createRecallEpisodesTool, defaultLocaleHeuristicStrategy, defineAutoRecallStrategy, defineBlock, defineContextLocalePack, defineLocalePack, effectiveAcceptsSensitivity, enLocalePack, evaluateMarkers, executeCompaction, explainRecall, formatRecallExplanation, fuseRrf, fuseWeighted, gatherMemoryMetadata, migrateEmbedder, normalizeEntityName, normalizeInducedProcedure, parseAdjudication, parseGrade, parseHypothetical, parseInducedProcedure, parseQueryVariants, parseTriggerSpec, partition as partitionBySensitivity, decide as privacyDecide, reanchorPersonaBlock, reanchorPinnedFacts, reanchorProjectRules, reasonFromTrigger, reconcileToConflictDecision, registerConsolidatorTriggers, renderFinalSummary, renderMessageText, renderMetadataBlock, resolveAutoCompactionDefault, resolveEntityDecision, resolveLocalePack, resolveTriggerThreshold, runConflictPipeline, runIterativeRetrieval, runWorkflowInduction, shouldFireInboundPreamble, toSpanAttributes, trajectoryFromRunState, truncateToTokens };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@graphorin/memory` — seven-tier memory system for the Graphorin\n * framework (MST-13: working / session / episodic / semantic /\n * procedural / shared + the read-only insight tier from P1-1).\n *\n * Surface overview:\n *\n *  - The {@link createMemory} facade that wires every tier sub-module\n *    + the memory tools + the search reranker + the context-engine +\n *    the consolidator.\n *  - Tier sub-modules under `./tiers`: {@link WorkingMemory},\n *    {@link SessionMemory}, {@link EpisodicMemory}, {@link SemanticMemory},\n *    {@link ProceduralMemory}, {@link SharedMemory}, plus the read-only\n *    {@link InsightMemory}.\n *  - Eleven memory tools under `./tools` (plus the gated twelfth,\n *    `deep_recall`, registered only when iterative retrieval is\n *    configured): `block_append`, `block_replace`, `block_rethink`,\n *    `fact_remember`, `fact_search`, `fact_supersede`, `fact_forget`,\n *    `recall_episodes`, `conversation_search`, `fact_history` (P0-2),\n *    `fact_validate` (P1-4).\n *  - The hybrid search composition under `./search`, including the\n *    built-in {@link RRFReranker} (k=60 default) and the\n *    {@link ReRanker} contract.\n *  - The embedder migration runner under `./migration`\n *    ({@link migrateEmbedder} with three coexistence policies).\n *  - Typed errors under `./errors`.\n *\n * Forward-looking surfaces (for ergonomic typing today):\n *\n *  - {@link MemoryContextBlocks} + {@link CompileOptions} from `./context-engine`.\n *  - {@link Consolidator}, {@link ConsolidatorTriggerSpec},\n *    {@link ConsolidatorTier} from `./consolidator`.\n *\n * @packageDocumentation\n */\n\n/** Canonical version constant. Mirrors the `package.json` version. */\nexport const VERSION = '0.5.0';\n\nexport * from './conflict/index.js';\nexport {\n  BudgetExceededError,\n  buildInductionRequest,\n  CONSOLIDATOR_TIER_DEFAULTS,\n  type Consolidator,\n  type ConsolidatorBudgetSnapshot,\n  type ConsolidatorCatchupPolicy,\n  type ConsolidatorCeilings,\n  type ConsolidatorConfig,\n  type ConsolidatorLastRuns,\n  type ConsolidatorPhase,\n  type ConsolidatorStatus,\n  type ConsolidatorTier,\n  type ConsolidatorTriggerReason,\n  type ConsolidatorTriggerSpec,\n  type CreateConsolidatorOptions,\n  CustomTierMisconfiguredError,\n  checkSuccessCriteria,\n  createConsolidator,\n  createConsolidatorPlaceholder,\n  createProviderWorkflowInducer,\n  DEFAULT_INDUCTION_MAX_TOKENS,\n  INDUCTION_SYSTEM_PROMPT,\n  type InducedProcedure,\n  MAX_PROCEDURE_STEPS,\n  MAX_TRAJECTORY_STEPS_SHOWN,\n  normalizeInducedProcedure,\n  type OnBudgetExceed,\n  type ParsedTrigger,\n  type PhaseListener,\n  type PhaseOutcome,\n  ProviderNotConfiguredError,\n  parseInducedProcedure,\n  parseTriggerSpec,\n  type RegisterTriggersOptions,\n  type RegisterTriggersResult,\n  reasonFromTrigger,\n  registerConsolidatorTriggers,\n  runWorkflowInduction,\n  type SchedulerLike,\n  type Trajectory,\n  type TrajectoryStep,\n  type TriggerDeclarationLike,\n  trajectoryFromRunState,\n  type VerificationResult,\n  type WorkflowInducer,\n  type WorkflowInductionOptions,\n} from './consolidator/index.js';\nexport {\n  _getLocaleFallbackWarningsForTesting,\n  _resetLocaleFallbackWarningsForTesting,\n  type AllocationResult,\n  type AnnotatedPart,\n  type AssembledPrompt,\n  type AssembleInput,\n  type AutoCompactionDefault,\n  type AutoRecallConfig,\n  type AutoRecallStrategy,\n  type AutoRecallStrategyContext,\n  type AutoRecallTriggerResult,\n  type AutoRecallTriggers,\n  adaptTokenCounter,\n  allocateTokenBudget,\n  annotate,\n  BASE_TEMPLATE_EN_FULL,\n  BASE_TEMPLATE_EN_MINIMAL,\n  type BaseTemplateFragments,\n  buildSummarizerPrompt,\n  CLEARED_TOOL_RESULT_MARKER,\n  type ClearToolResultsOptions,\n  type ClearToolResultsOutcome,\n  CONTENT_ORIGIN_ATTR,\n  type CompactionConfig,\n  type CompactionContext,\n  type CompactionMetadataPayload,\n  type CompactionResult,\n  type CompactionSource,\n  type CompactionStrategy,\n  type CompactionSummarizer,\n  type CompactionSummaryTemplate,\n  type CompactionTriggerConfig,\n  type CompileOptions,\n  type CompileScope,\n  type ContentAnnotation,\n  type ContentOrigin,\n  type ContextEngine,\n  type ContextEngineConfig,\n  type ContextLocalePack,\n  type ContextTokenCounter,\n  clearOldToolResults,\n  composeInboundPreamble,\n  composeLayer1,\n  composeLayer2,\n  composeLayer4Skills,\n  countMessageTokens,\n  createContextEngine,\n  DEFAULT_LAYER_PRIORITY,\n  DEFAULT_PRESERVE_RECENT_TURNS,\n  DEFAULT_RESERVED_FOR_COMPACTION,\n  DEFAULT_RESERVED_FOR_RESPONSE,\n  DEFAULT_THRESHOLD_RATIO,\n  defaultLocaleHeuristicStrategy,\n  defineAutoRecallStrategy,\n  defineContextLocalePack,\n  type ExecuteCompactionInput,\n  effectiveAcceptsSensitivity,\n  enLocalePack,\n  executeCompaction,\n  gatherMemoryMetadata,\n  HEURISTIC_TOKEN_COUNTER,\n  INBOUND_SANITIZATION_PREAMBLE_EN,\n  INBOUND_TRUST_ATTR,\n  type InboundSanitizationPreamble,\n  type InboundTrust,\n  type LayerAllocation,\n  type LayerCandidate,\n  type LayerConfig,\n  type LayerId,\n  type LocaleResolverLogger,\n  type MemoryBaseMode,\n  type MemoryContextBlocks,\n  type MemoryMetadataDeps,\n  type NamedPostCompactionHook,\n  NON_INBOUND_ORIGINS,\n  type OverflowMode,\n  type PartialContextLocalePack,\n  type PartitionResult,\n  type PostCompactionHook,\n  type PostCompactionHookContext,\n  type PrivacyConfig,\n  type PrivacyDecision,\n  type PrivacyDecisionReason,\n  type PrivacyFilterContext,\n  partitionBySensitivity,\n  privacyDecide,\n  type RenderedTemplate,\n  type ResolvedContextEngineConfig,\n  reanchorPersonaBlock,\n  reanchorPinnedFacts,\n  reanchorProjectRules,\n  renderFinalSummary,\n  renderMessageText,\n  renderMetadataBlock,\n  resolveAutoCompactionDefault,\n  resolveLocalePack,\n  resolveTriggerThreshold,\n  type SkillMetadataCard,\n  SUMMARY_TEMPLATE_NAME,\n  SUMMARY_TEMPLATE_VERSION,\n  shouldFireInboundPreamble,\n  toSpanAttributes,\n  truncateToTokens,\n} from './context-engine/index.js';\nexport * from './errors/index.js';\nexport {\n  _resetConsolidatorConfigWarningForTesting,\n  type CreateMemoryOptions,\n  createMemory,\n  type Memory,\n} from './facade.js';\nexport * from './graph/index.js';\nexport type { ContextualRetrievalMode } from './internal/contextualize.js';\nexport type {\n  ConflictAuditDecision,\n  ConflictAuditInputLike,\n  ConflictAuditStage,\n  ConflictMemoryStoreExt,\n  ConsolidatorMemoryStoreExt,\n  ConsolidatorRunFinish,\n  ConsolidatorRunInput,\n  ConsolidatorStatePatch,\n  ConsolidatorStateRow,\n  DecayMemoryStoreExt,\n  DlqBatchInput,\n  DlqBatchRow,\n  EmbeddedWriteOptions,\n  EmbeddingMetaRegistryLike,\n  EpisodicMemoryStoreExt,\n  InsightListOptions as InsightStoreListOptions,\n  InsightMemoryStoreExt,\n  InsightSearchStoreOptions,\n  MemoryStoreAdapter,\n  PendingConflictInputLike,\n  PendingConflictRowLike,\n  SemanticMemoryStoreExt,\n  SessionMemoryStoreExt,\n  SessionMessageRecord,\n} from './internal/storage-adapter.js';\nexport * from './migration/index.js';\nexport * from './search/index.js';\nexport * from './tiers/index.js';\nexport {\n  type BuildMemoryToolsOptions,\n  buildMemoryTools,\n  createBlockAppendTool,\n  createBlockReplaceTool,\n  createBlockRethinkTool,\n  createConversationSearchTool,\n  createDeepRecallTool,\n  createFactForgetTool,\n  createFactHistoryTool,\n  createFactRememberTool,\n  createFactSearchTool,\n  createFactSupersedeTool,\n  createFactValidateTool,\n  createRecallEpisodesTool,\n  type MemoryToolDeps,\n  type ScopeResolver,\n} from './tools/index.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,UAAU"}