@graphorin/memory 0.5.0

package/dist/facade.d.ts

@@ -0,0 +1,278 @@
+import { EmbeddingMetaRegistryLike, MemoryStoreAdapter } from "./internal/storage-adapter.js";
+import { ConflictPipeline, ConflictPipelineOptions } from "./conflict/types.js";
+import "./conflict/index.js";
+import { ContextualRetrievalMode } from "./internal/contextualize.js";
+import { EpisodicMemory } from "./tiers/episodic-memory.js";
+import { EntityResolutionConfig } from "./graph/entity-resolver.js";
+import { ReRanker } from "./search/types.js";
+import { SemanticMemory } from "./tiers/semantic-memory.js";
+import { SalienceWeights } from "./consolidator/decay.js";
+import { ConsolidatorCeilings, ConsolidatorPhase, ConsolidatorTier, ConsolidatorTriggerSpec, OnBudgetExceed, PhaseListener } from "./consolidator/types.js";
+import { Consolidator } from "./consolidator/runtime.js";
+import "./consolidator/index.js";
+import { ContextEngine, ContextEngineConfig } from "./context-engine/engine.js";
+import { CompileOptions, CompileScope, MemoryContextBlocks } from "./context-engine/index.js";
+import { InsightMemory } from "./tiers/insight-memory.js";
+import { ProceduralMemory } from "./tiers/procedural-memory.js";
+import { SessionMemory } from "./tiers/session-memory.js";
+import { SharedMemory } from "./tiers/shared-memory.js";
+import { BlockDefinition, WorkingMemory } from "./tiers/working-memory.js";
+import { ScopeResolver } from "./tools/types.js";
+import "./tools/index.js";
+import { EmbedderProvider, MemoryMetadata, Provider, SessionScope, Tool, Tracer } from "@graphorin/core";
+
+//#region src/facade.d.ts
+
+/**
+ * Options accepted by {@link createMemory}.
+ *
+ * @stable
+ */
+interface CreateMemoryOptions {
+  /** Storage adapter (default: `@graphorin/store-sqlite`'s `MemoryStore`). */
+  readonly store: MemoryStoreAdapter;
+  /** Embedder registry. The default sqlite store exposes one as `sqlite.embeddings`. */
+  readonly embeddings: EmbeddingMetaRegistryLike;
+  /** Embedder provider (default: none — vector search is disabled). */
+  readonly embedder?: EmbedderProvider;
+  /** Pre-declared working blocks (idempotent — re-defining is a no-op). */
+  readonly workingBlocks?: ReadonlyArray<BlockDefinition>;
+  /**
+   * Tracer used for every `memory.*` span. Defaults to the no-op
+   * tracer from `@graphorin/core` so unit tests do not need to wire
+   * the observability stack.
+   */
+  readonly tracer?: Tracer;
+  /** Override the reranker used by `SemanticMemory.search`. */
+  readonly reranker?: ReRanker;
+  /**
+   * Contextual-retrieval mode for the write path (P1-3). `'late-chunk'`
+   * (default) prepends a deterministic, offline situating context
+   * (entities / timeframe / topics, derived from the fact's own
+   * structured fields) to the text that is embedded + FTS-indexed, so a
+   * terse fact stays findable; the canonical `text` is preserved. `'off'`
+   * indexes the bare text. The `'llm'` enrichment is **not** available on
+   * the hot path — it is a consolidator-only opt-in configured via
+   * `consolidator: { contextualRetrieval: 'llm' }`.
+   */
+  readonly contextualRetrieval?: 'off' | 'late-chunk';
+  /**
+   * Query transformation for retrieval (P2-3, opt-in). When supplied,
+   * `SemanticMemory.search(..., { multiQuery })` fans the query into
+   * reworded variants (multi-query / RAG-Fusion) and `{ hyde }` adds a
+   * hypothetical-answer embedding — both via one cheap LLM call on the
+   * given provider, fused through the existing RRF reranker. Omitted (the
+   * default) ⇒ search stays **offline + single-shot** and the
+   * `multiQuery` / `hyde` search options become silent no-ops. Reserve it
+   * for retrieval-heavy recall, not every search (it adds provider
+   * latency).
+   */
+  readonly queryTransform?: {
+    /** Cheap provider used to rewrite the query / write the HyDE passage. */
+    readonly provider: Provider;
+    /** Hard ceiling on reworded variants requested per call. Default 5. */
+    readonly maxVariants?: number;
+    /** Output-token ceiling per transform call. Default 256. */
+    readonly maxTokens?: number;
+  };
+  /**
+   * Relation-graph entity resolution (P2-1). When `entityResolution` is
+   * `true` **and** the storage adapter exposes a `graph` surface (the
+   * default `@graphorin/store-sqlite` does), `remember(...)` resolves a
+   * fact's subject / object to canonical entities and links them, so
+   * `search(..., { expandHops: 1 })` can traverse relationships. Omitted
+   * (the default) ⇒ facts still carry s/p/o but form no entity links and
+   * the write path stays offline + unchanged. Dedup is lexical +
+   * embedding (offline, via the configured embedder); LLM adjudication of
+   * ambiguous merges is a further opt-in that needs `provider`.
+   */
+  readonly graph?: EntityResolutionConfig & {
+    /** Enable entity resolution + linking on write. Default `false`. */
+    readonly entityResolution?: boolean;
+    /** Provider for opt-in LLM adjudication of ambiguous merges. */
+    readonly provider?: Provider;
+  };
+  /**
+   * Agentic / iterative retrieval (P2-4, opt-in). When supplied,
+   * `SemanticMemory.searchIterative(...)` and the gated `deep_recall`
+   * tool can grade a retrieved set on the given provider and, for queries
+   * judged hard, reformulate + retrieve again (widening to one-hop graph
+   * expansion) up to `maxIterations`, abstaining instead of confabulating
+   * when memory is insufficient. Omitted (the default) ⇒ `searchIterative`
+   * stays a single difficulty-gated pass with **no provider call**, and
+   * `deep_recall` is **not** registered (the tool surface stays at the
+   * canonical eleven). Reserve it for hard multi-hop / temporal recall —
+   * it adds provider latency per pass.
+   */
+  readonly iterativeRetrieval?: {
+    /** Cheap provider used to grade retrieved memories + reformulate. */
+    readonly provider: Provider;
+    /** Default total-pass cap (clamped to `[1, 5]`). Default 3. */
+    readonly maxIterations?: number;
+    /** Output-token ceiling per grade call. Default 256. */
+    readonly maxTokens?: number;
+  };
+  /**
+   * Opt-in workflow induction (P2-2). When set, `ProceduralMemory.induce(...)`
+   * distils a reusable, value-abstracted procedure from a successful agent
+   * trajectory and stores it **quarantined** + `provenance: 'induction'`.
+   * Omitted (the default) ⇒ `induce(...)` throws
+   * {@link ProcedureInductionNotConfiguredError} and the procedural tier
+   * stays pure offline CRUD — no provider call.
+   */
+  readonly procedureInduction?: {
+    /** Provider used to abstract trajectory values into a procedure. */
+    readonly provider: Provider;
+    /** Output-token ceiling per induction call. Default 512. */
+    readonly maxTokens?: number;
+  };
+  /**
+   * Promotion-by-demonstrated-success for quarantined induced
+   * procedures (MCON-2 part 4). Fully offline — orthogonal to
+   * `procedureInduction` (no provider needed). When configured,
+   * `procedural.recordOutcome(scope, id, true)` increments the rule's
+   * persistent success counter and promotes it into `activate()` once
+   * `afterSuccesses` verified reuses accumulate; the injection gate
+   * still refuses flagged texts. Omitted ⇒ outcomes are counted but
+   * nothing auto-promotes.
+   */
+  readonly procedurePromotion?: {
+    /** Successful demonstrated reuses required before promotion (≥ 1). */
+    readonly afterSuccesses: number;
+  };
+  /**
+   * Resolver that produces the live {@link SessionScope} for each
+   * memory-tool invocation. Defaults to a closure that throws — the
+   * agent runtime overrides it in Phase 12.
+   */
+  readonly resolveScope?: ScopeResolver;
+  /**
+   * Consolidator configuration. When omitted, empty, or
+   * `enabled: false`, the facade installs the Phase 10a no-op
+   * placeholder so consumers can still type their interactions without
+   * paying the runtime cost. ANY other setting — including offline
+   * knobs like `decayCapacity` or `contextualRetrieval` — implicitly
+   * enables the production runtime (MST-4); `enabled: false` together
+   * with other settings warns once and keeps the placeholder.
+   */
+  readonly consolidator?: {
+    readonly enabled?: boolean;
+    readonly triggers?: ReadonlyArray<ConsolidatorTriggerSpec>;
+    readonly tier?: ConsolidatorTier;
+    readonly phases?: ReadonlyArray<ConsolidatorPhase>;
+    readonly ceilings?: Partial<ConsolidatorCeilings>;
+    readonly onExceed?: OnBudgetExceed;
+    /** Provider routed to the standard phase when set (MCON-7); falls back to `provider`. */
+    readonly cheapProvider?: Provider | null;
+    /** Provider routed to the deep + reflection passes when set (MCON-7). */
+    readonly deepProvider?: Provider | null;
+    readonly cheapModel?: string | null;
+    readonly deepModel?: string | null;
+    readonly noiseFilters?: ReadonlyArray<'default' | 'minimal' | 'none'>;
+    readonly lockWaitMs?: number;
+    readonly decayTauDays?: number;
+    readonly decayArchiveThreshold?: number;
+    /** Capacity-bounded eviction target for the light phase (X-1). Default unbounded. */
+    readonly decayCapacity?: number | null;
+    /** Weights for the multi-signal salience score (X-1). */
+    readonly salienceWeights?: SalienceWeights;
+    readonly maxStandardBatchSize?: number;
+    readonly maxDeepConflictsPerRun?: number;
+    readonly dlqMaxRetries?: number;
+    readonly dlqBaseBackoffMs?: number;
+    readonly dlqMaxBackoffMs?: number;
+    /** Auto-form quarantined episodes from processed slices (P1-2). Per-tier default. */
+    readonly formEpisodes?: boolean;
+    /** Score episode importance via the consolidator LLM (P1-2). Per-tier default. */
+    readonly importanceScoring?: boolean;
+    /** Opt in to auto-promotion of injection-clean extraction facts (MCON-2). Default off. */
+    readonly autoPromoteExtraction?: boolean;
+    /** Run the deep-phase reflection pass synthesizing cited insights (P1-1). Per-tier default. */
+    readonly reflection?: boolean;
+    /** Accumulated-importance threshold at which reflection fires (P1-1). */
+    readonly importanceThreshold?: number;
+    /** Upper bound on salient questions reflection asks per pass (P1-1). */
+    readonly reflectionMaxQuestions?: number;
+    /**
+     * Contextual retrieval for standard-phase fact writes (P1-3).
+     * `'llm'` opts into one budgeted cheap-model call per write to author
+     * a situating prefix (consolidator-only); `'late-chunk'` (default)
+     * and `'off'` defer to the write-path mode. Per-tier default.
+     */
+    readonly contextualRetrieval?: ContextualRetrievalMode;
+    readonly defaultScope?: SessionScope;
+    readonly provider?: Provider | null;
+    /** Override the wall clock — used by tests. */
+    readonly now?: () => number;
+    /** Stable id seed — used by tests. */
+    readonly randomId?: () => string;
+    /** Subscribe to phase-finished events. */
+    readonly onPhaseFinished?: PhaseListener;
+  };
+  /**
+   * Conflict pipeline configuration (Phase 10b). Default: enabled,
+   * English locale pack, thresholds `0.95 / 0.85 / 0.4`. Pass
+   * `{ mode: 'off' }` to bypass the pipeline entirely (logs a one-shot
+   * WARN per process per the spec).
+   */
+  readonly conflictPipeline?: ConflictPipelineOptions;
+  /**
+   * Context engine configuration (Phase 10d). The engine assembles
+   * the layered six-layer system prompt; `memory.compile(scope)`
+   * delegates to it for the working blocks + rules + metadata
+   * fragments. When omitted, a default engine is created (English
+   * locale; `'full'` base mode; no auto-recall; conservative
+   * `'public-tls'` provider trust).
+   */
+  readonly contextEngine?: ContextEngineConfig;
+}
+/**
+ * The facade returned by {@link createMemory}.
+ *
+ * @stable
+ */
+interface Memory {
+  readonly working: WorkingMemory;
+  readonly session: SessionMemory;
+  readonly episodic: EpisodicMemory;
+  readonly semantic: SemanticMemory;
+  readonly procedural: ProceduralMemory;
+  readonly shared: SharedMemory;
+  /**
+   * Read surface over reflection insights (P1-1). A no-op (returns
+   * empty) when the storage adapter does not expose the optional
+   * insight surface.
+   */
+  readonly insights: InsightMemory;
+  readonly tools: ReadonlyArray<Tool>;
+  readonly consolidator: Consolidator;
+  /** The configured conflict pipeline. Surfaced for tests + CLI tooling. */
+  readonly conflictPipeline: ConflictPipeline;
+  /** The configured context engine (Phase 10d). */
+  readonly contextEngine: ContextEngine;
+  /** The active embedder, when configured. `null` otherwise. */
+  readonly embedder: EmbedderProvider | null;
+  /** The canonical id of the active embedder, when configured. */
+  embedderId(): string | null;
+  /**
+   * Compile a system-prompt block bundle. The bundle carries the
+   * static fragments per memory tier; the agent runtime consumes
+   * the {@link ContextEngine} surface (`memory.contextEngine`)
+   * directly for the full six-layer assembly.
+   */
+  compile(scope: CompileScope, options?: CompileOptions): Promise<MemoryContextBlocks>;
+  /** Counter snapshot consumed by Phase 10d's metadata layer. */
+  metadata(scope: SessionScope): Promise<MemoryMetadata>;
+}
+/**
+ * Wire every memory subsystem in one call. Returns the typed
+ * `Memory` facade ready to be passed into `createAgent({...})`.
+ *
+ * @stable
+ */
+declare function createMemory(options: CreateMemoryOptions): Memory;
+/** @internal — test seam for the one-time disabled-config warning. */
+declare function _resetConsolidatorConfigWarningForTesting(): void;
+//#endregion
+export { CreateMemoryOptions, Memory, _resetConsolidatorConfigWarningForTesting, createMemory };
+//# sourceMappingURL=facade.d.ts.map

package/dist/facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade.d.ts","names":[],"sources":["../src/facade.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuEA;;;;;AAQ2B,UARV,mBAAA,CAQU;EAMP;EAEE,SAAA,KAAA,EAdJ,kBAcI;EAyBC;EAiBJ,SAAA,UAAA,EAtDI,yBAsDJ;EAIK;EAgBD,SAAA,QAAA,CAAA,EAxED,gBAwEC;EAgBA;EAuBG,SAAA,aAAA,CAAA,EA7GC,aA6GD,CA7Ge,eA6Gf,CAAA;EAYY;;;;;EAGN,SAAA,MAAA,CAAA,EAtHZ,MAsHY;EAAR;EACA,SAAA,QAAA,CAAA,EArHF,QAqHE;EAEK;;;;;;;;;;EA6DiB,SAAA,mBAAA,CAAA,EAAA,KAAA,GAAA,YAAA;EAQ7B;;;;;;;;;;;EAgBY,SAAA,cAAA,CAAA,EAAA;IAEH;IAEL,SAAA,QAAA,EAvLE,QAuLF;IASJ;IAAwB,SAAA,WAAA,CAAA,EAAA,MAAA;IAAyB;IAAR,SAAA,SAAA,CAAA,EAAA,MAAA;EAExC,CAAA;EAAuB;;;AASzC;AAuWA;;;;;;;mBAjiBmB;;;;wBAIK;;;;;;;;;;;;;;;;uBAgBD;;;;;;;;;;;;;;;;uBAgBA;;;;;;;;;;;;;;;;;;;;;;;0BAuBG;;;;;;;;;;;;wBAYF,cAAc;oBAClB;sBACE,cAAc;wBACZ,QAAQ;wBACR;;6BAEK;;4BAED;;;4BAGA;;;;;;;+BAOG;;;;;;;;;;;;;;;;;;;;;;;;mCAwBI;4BACP;wBACJ;;;;;;+BAMO;;;;;;;;8BAQD;;;;;;;;;2BASH;;;;;;;UAQV,MAAA;oBACG;oBACA;qBACC;qBACA;uBACE;mBACJ;;;;;;qBAME;kBACH,cAAc;yBACP;;6BAEI;;0BAEH;;qBAEL;;;;;;;;;iBASJ,wBAAwB,iBAAiB,QAAQ;;kBAEhD,eAAe,QAAQ;;;;;;;;iBASzB,YAAA,UAAsB,sBAAsB;;iBAuW5C,yCAAA,CAAA"}

package/dist/facade.js

@@ -0,0 +1,265 @@
+import { createConflictPipeline } from "./conflict/pipeline.js";
+import "./conflict/index.js";
+import { createProviderWorkflowInducer } from "./consolidator/phases/induce.js";
+import { createConsolidator } from "./consolidator/runtime.js";
+import { createConsolidatorPlaceholder } from "./consolidator/index.js";
+import { enLocalePack } from "./context-engine/locale-packs/en.js";
+import "./context-engine/locale-packs/index.js";
+import { resolveLocalePack } from "./context-engine/locale-packs/resolver.js";
+import { gatherMemoryMetadata, renderMetadataBlock } from "./context-engine/metadata.js";
+import { partition } from "./context-engine/privacy-filter.js";
+import { composeLayer1 } from "./context-engine/templates/composer.js";
+import { createContextEngine } from "./context-engine/engine.js";
+import { EntityResolver } from "./graph/entity-resolver.js";
+import { bindEmbedder } from "./internal/embedder-binding.js";
+import { createProviderRetrievalGrader } from "./search/iterative.js";
+import { createProviderQueryTransformer } from "./search/query-transform.js";
+import { RRFReranker } from "./search/rrf.js";
+import { EpisodicMemory } from "./tiers/episodic-memory.js";
+import { InsightMemory } from "./tiers/insight-memory.js";
+import { ProceduralMemory } from "./tiers/procedural-memory.js";
+import { SemanticMemory } from "./tiers/semantic-memory.js";
+import { SessionMemory } from "./tiers/session-memory.js";
+import { SharedMemory } from "./tiers/shared-memory.js";
+import { WorkingMemory } from "./tiers/working-memory.js";
+import { buildMemoryTools } from "./tools/index.js";
+import { NOOP_TRACER } from "@graphorin/core";
+
+//#region src/facade.ts
+/**
+* Wire every memory subsystem in one call. Returns the typed
+* `Memory` facade ready to be passed into `createAgent({...})`.
+*
+* @stable
+*/
+function createMemory(options) {
+	const tracer = options.tracer ?? NOOP_TRACER;
+	const reranker = options.reranker ?? new RRFReranker();
+	const resolveScope = options.resolveScope ?? (() => {
+		throw new TypeError("[graphorin/memory] memory tool invoked without a scope resolver. Pass `resolveScope` to createMemory({...}) — the agent runtime supplies one in Phase 12.");
+	});
+	let activeEmbedderId = null;
+	if (options.embedder !== void 0) activeEmbedderId = bindEmbedder(options.embedder, options.embeddings);
+	const embedder = options.embedder ?? null;
+	const embedderIdProvider = () => activeEmbedderId;
+	const working = new WorkingMemory({
+		store: options.store,
+		tracer
+	});
+	for (const block of options.workingBlocks ?? []) working.define(block);
+	const session = new SessionMemory({
+		store: options.store,
+		tracer
+	});
+	const episodic = new EpisodicMemory({
+		store: options.store,
+		tracer,
+		embedder,
+		embedderIdProvider
+	});
+	const conflictPipeline = createConflictPipeline(options.conflictPipeline ?? {});
+	const queryTransformer = options.queryTransform !== void 0 ? createProviderQueryTransformer(options.queryTransform.provider, {
+		...options.queryTransform.maxVariants !== void 0 ? { maxVariants: options.queryTransform.maxVariants } : {},
+		...options.queryTransform.maxTokens !== void 0 ? { maxTokens: options.queryTransform.maxTokens } : {}
+	}) : null;
+	const graphStore = options.store.graph;
+	const entityResolver = options.graph?.entityResolution === true && graphStore !== void 0 ? new EntityResolver({
+		store: graphStore,
+		embedder,
+		embedderId: embedderIdProvider,
+		...options.graph.provider !== void 0 ? { provider: options.graph.provider } : {},
+		config: {
+			...options.graph.mergeThreshold !== void 0 ? { mergeThreshold: options.graph.mergeThreshold } : {},
+			...options.graph.adjudicateThreshold !== void 0 ? { adjudicateThreshold: options.graph.adjudicateThreshold } : {},
+			...options.graph.llmAdjudication !== void 0 ? { llmAdjudication: options.graph.llmAdjudication } : {}
+		}
+	}) : null;
+	const grader = options.iterativeRetrieval !== void 0 ? createProviderRetrievalGrader(options.iterativeRetrieval.provider, { ...options.iterativeRetrieval.maxTokens !== void 0 ? { maxTokens: options.iterativeRetrieval.maxTokens } : {} }) : null;
+	const semantic = new SemanticMemory({
+		store: options.store,
+		tracer,
+		embedder,
+		embedderIdProvider,
+		reranker,
+		conflictPipeline,
+		...options.contextualRetrieval !== void 0 ? { contextualRetrieval: options.contextualRetrieval } : {},
+		...queryTransformer !== null ? { queryTransformer } : {},
+		...entityResolver !== null ? { entityResolver } : {},
+		...grader !== null ? { grader } : {},
+		...options.iterativeRetrieval?.maxIterations !== void 0 ? { iterativeMaxIterations: options.iterativeRetrieval.maxIterations } : {}
+	});
+	let consolidatorForSpend = null;
+	const inducer = options.procedureInduction !== void 0 ? createProviderWorkflowInducer(options.procedureInduction.provider, {
+		...options.procedureInduction.maxTokens !== void 0 ? { maxTokens: options.procedureInduction.maxTokens } : {},
+		onUsage: (usage) => {
+			consolidatorForSpend?.recordExternalSpend(usage.promptTokens + usage.completionTokens);
+		}
+	}) : null;
+	const procedural = new ProceduralMemory({
+		store: options.store,
+		tracer,
+		...inducer !== null ? { inducer } : {},
+		...options.procedurePromotion?.afterSuccesses !== void 0 ? { promoteAfterSuccesses: options.procedurePromotion.afterSuccesses } : {}
+	});
+	const shared = new SharedMemory({
+		store: options.store,
+		tracer
+	});
+	const insights = new InsightMemory({
+		store: options.store,
+		tracer
+	});
+	const tools = buildMemoryTools({
+		working,
+		session,
+		episodic,
+		semantic,
+		procedural,
+		shared,
+		resolveScope
+	}, { includeDeepRecall: grader !== null });
+	const consolidatorOpts = options.consolidator;
+	const consolidator = buildConsolidator(consolidatorOpts, options.store, semantic, episodic, tracer);
+	consolidatorForSpend = consolidator;
+	const contextEngineConfig = options.contextEngine ?? {};
+	const contextEngine = createContextEngine(contextEngineConfig);
+	const resolved = contextEngine.config();
+	const localePack = contextEngineConfig.locale === void 0 ? enLocalePack : typeof contextEngineConfig.locale === "string" ? contextEngineConfig.locale === enLocalePack.id ? enLocalePack : resolveLocalePack({ id: contextEngineConfig.locale }) : resolveLocalePack(contextEngineConfig.locale);
+	const privacyOptedIn = contextEngineConfig.privacy !== void 0 && (contextEngineConfig.privacy.providerAcceptsSensitivity !== void 0 || contextEngineConfig.privacy.cloudUploadConsent !== void 0 || contextEngineConfig.privacy.providerTrust !== void 0);
+	async function compile(scope, compileOptions = {}) {
+		const out = {};
+		const blocks = await options.store.working.list(scope);
+		const rules = (await options.store.procedural.list(scope)).filter((rule) => rule.status !== "quarantined");
+		const shouldFilter = privacyOptedIn || compileOptions.providerAcceptsSensitivity !== void 0;
+		let blocksKept = blocks;
+		let rulesKept = rules;
+		if (shouldFilter) {
+			const filterContext = {
+				providerTrust: resolved.providerTrust,
+				cloudUploadConsent: resolved.cloudUploadConsent,
+				defaultSensitivity: resolved.defaultSensitivity
+			};
+			if (compileOptions.providerAcceptsSensitivity !== void 0) filterContext.providerAcceptsSensitivity = compileOptions.providerAcceptsSensitivity;
+			blocksKept = partition(blocks, filterContext).kept;
+			rulesKept = partition(rules, filterContext).kept;
+		}
+		const blocksXml = renderWorkingBlocksXml(blocksKept);
+		if (blocksXml.length > 0) out.workingBlocks = blocksXml;
+		if (rulesKept.length > 0) {
+			const lines = ["<memory_rules>"];
+			for (const rule of rulesKept) lines.push(`  <rule priority="${rule.priority}">${escapeXml(rule.text)}</rule>`);
+			lines.push("</memory_rules>");
+			out.rules = lines.join("\n");
+		}
+		if (compileOptions.includeMetadata !== false) out.metadata = renderMetadataBlock(await metadata(scope));
+		out.base = composeLayer1(localePack, resolved.memoryBaseMode);
+		return Object.freeze(out);
+	}
+	async function metadata(scope) {
+		return gatherMemoryMetadata(scope, {
+			store: options.store,
+			consolidator,
+			embedderId: embedderIdProvider,
+			localeId: resolved.localeId
+		});
+	}
+	return Object.freeze({
+		working,
+		session,
+		episodic,
+		semantic,
+		procedural,
+		shared,
+		insights,
+		tools,
+		consolidator,
+		conflictPipeline,
+		contextEngine,
+		embedder,
+		embedderId: embedderIdProvider,
+		compile,
+		metadata
+	});
+}
+function renderWorkingBlocksXml(blocks) {
+	if (blocks.length === 0) return "";
+	const lines = ["<memory_blocks>"];
+	for (const block of blocks) {
+		const description = block.description !== void 0 ? ` description="${escapeXml(block.description)}"` : "";
+		lines.push(`  <block label="${escapeXml(block.label)}"${description}>`);
+		lines.push(`    ${escapeXml(block.value)}`);
+		lines.push("  </block>");
+	}
+	lines.push("</memory_blocks>");
+	return lines.join("\n");
+}
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildConsolidator(opts, store, semantic, episodic, tracer) {
+	if (opts === void 0) return createConsolidatorPlaceholder();
+	if (!shouldEnableConsolidator(opts)) return createConsolidatorPlaceholder({
+		...opts.triggers !== void 0 ? { triggers: opts.triggers } : {},
+		...opts.tier !== void 0 ? { tier: opts.tier } : {}
+	});
+	const consolidator = createConsolidator({
+		store,
+		semantic,
+		episodic,
+		tracer,
+		...opts.provider !== void 0 ? { provider: opts.provider } : {},
+		...opts.now !== void 0 ? { now: opts.now } : {},
+		...opts.randomId !== void 0 ? { randomId: opts.randomId } : {},
+		...opts.triggers !== void 0 ? { triggers: opts.triggers } : {},
+		...opts.tier !== void 0 ? { tier: opts.tier } : {},
+		...opts.phases !== void 0 ? { phases: opts.phases } : {},
+		...opts.ceilings !== void 0 ? { ceilings: opts.ceilings } : {},
+		...opts.onExceed !== void 0 ? { onExceed: opts.onExceed } : {},
+		...opts.cheapProvider !== void 0 ? { cheapProvider: opts.cheapProvider } : {},
+		...opts.deepProvider !== void 0 ? { deepProvider: opts.deepProvider } : {},
+		...opts.cheapModel !== void 0 ? { cheapModel: opts.cheapModel } : {},
+		...opts.deepModel !== void 0 ? { deepModel: opts.deepModel } : {},
+		...opts.noiseFilters !== void 0 ? { noiseFilters: opts.noiseFilters } : {},
+		...opts.lockWaitMs !== void 0 ? { lockWaitMs: opts.lockWaitMs } : {},
+		...opts.decayTauDays !== void 0 ? { decayTauDays: opts.decayTauDays } : {},
+		...opts.decayArchiveThreshold !== void 0 ? { decayArchiveThreshold: opts.decayArchiveThreshold } : {},
+		...opts.decayCapacity !== void 0 ? { decayCapacity: opts.decayCapacity } : {},
+		...opts.salienceWeights !== void 0 ? { salienceWeights: opts.salienceWeights } : {},
+		...opts.maxStandardBatchSize !== void 0 ? { maxStandardBatchSize: opts.maxStandardBatchSize } : {},
+		...opts.maxDeepConflictsPerRun !== void 0 ? { maxDeepConflictsPerRun: opts.maxDeepConflictsPerRun } : {},
+		...opts.dlqMaxRetries !== void 0 ? { dlqMaxRetries: opts.dlqMaxRetries } : {},
+		...opts.dlqBaseBackoffMs !== void 0 ? { dlqBaseBackoffMs: opts.dlqBaseBackoffMs } : {},
+		...opts.dlqMaxBackoffMs !== void 0 ? { dlqMaxBackoffMs: opts.dlqMaxBackoffMs } : {},
+		...opts.formEpisodes !== void 0 ? { formEpisodes: opts.formEpisodes } : {},
+		...opts.importanceScoring !== void 0 ? { importanceScoring: opts.importanceScoring } : {},
+		...opts.autoPromoteExtraction !== void 0 ? { autoPromoteExtraction: opts.autoPromoteExtraction } : {},
+		...opts.reflection !== void 0 ? { reflection: opts.reflection } : {},
+		...opts.importanceThreshold !== void 0 ? { importanceThreshold: opts.importanceThreshold } : {},
+		...opts.reflectionMaxQuestions !== void 0 ? { reflectionMaxQuestions: opts.reflectionMaxQuestions } : {},
+		...opts.contextualRetrieval !== void 0 ? { contextualRetrieval: opts.contextualRetrieval } : {},
+		...opts.defaultScope !== void 0 ? { defaultScope: opts.defaultScope } : {}
+	});
+	if (opts.onPhaseFinished !== void 0) consolidator.onPhaseFinished(opts.onPhaseFinished);
+	return consolidator;
+}
+let consolidatorConfigIgnoredWarned = false;
+/** @internal — test seam for the one-time disabled-config warning. */
+function _resetConsolidatorConfigWarningForTesting() {
+	consolidatorConfigIgnoredWarned = false;
+}
+function shouldEnableConsolidator(opts) {
+	const keys = Object.keys(opts).filter((k) => k !== "enabled" && opts[k] !== void 0);
+	if (opts.enabled === false) {
+		if (keys.length > 0 && !consolidatorConfigIgnoredWarned) {
+			consolidatorConfigIgnoredWarned = true;
+			process.stderr.write(`[graphorin/memory] consolidator config (${keys.join(", ")}) was supplied together with enabled: false — the settings are ignored until the consolidator is enabled.\n`);
+		}
+		return false;
+	}
+	if (opts.enabled === true) return true;
+	return keys.length > 0;
+}
+
+//#endregion
+export { _resetConsolidatorConfigWarningForTesting, createMemory };
+//# sourceMappingURL=facade.js.map

package/dist/facade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade.js","names":["reranker: ReRanker","resolveScope: ScopeResolver","activeEmbedderId: string | null","consolidatorForSpend: Consolidator | null","consolidator: Consolidator","contextEngine: ContextEngine","out: { -readonly [K in keyof MemoryContextBlocks]: MemoryContextBlocks[K] }","blocksKept: ReadonlyArray<(typeof blocks)[number]>","rulesKept: ReadonlyArray<(typeof rules)[number]>","filterContext: Parameters<typeof partitionBySensitivity>[1]","partitionBySensitivity"],"sources":["../src/facade.ts"],"sourcesContent":["/**\n * `createMemory()` — the facade that wires every tier sub-module (the\n * seven-tier system) + the eleven (+1 gated) memory tools + the search\n * reranker + the context engine\n * stubs + the consolidator placeholder.\n *\n * @packageDocumentation\n */\n\nimport type {\n  EmbedderProvider,\n  MemoryMetadata,\n  Provider,\n  SessionScope,\n  Tool,\n  Tracer,\n} from '@graphorin/core';\nimport { NOOP_TRACER } from '@graphorin/core';\nimport {\n  type ConflictPipeline,\n  type ConflictPipelineOptions,\n  createConflictPipeline,\n} from './conflict/index.js';\nimport {\n  type Consolidator,\n  type ConsolidatorCeilings,\n  type ConsolidatorPhase,\n  type ConsolidatorTier,\n  type ConsolidatorTriggerSpec,\n  createConsolidator,\n  createConsolidatorPlaceholder,\n  createProviderWorkflowInducer,\n  type OnBudgetExceed,\n  type PhaseListener,\n  type SalienceWeights,\n} from './consolidator/index.js';\nimport { createContextEngine } from './context-engine/engine.js';\nimport type {\n  CompileOptions,\n  CompileScope,\n  ContextEngine,\n  ContextEngineConfig,\n  MemoryContextBlocks,\n} from './context-engine/index.js';\nimport { enLocalePack } from './context-engine/locale-packs/index.js';\nimport { resolveLocalePack } from './context-engine/locale-packs/resolver.js';\nimport { gatherMemoryMetadata, renderMetadataBlock } from './context-engine/metadata.js';\nimport { partition as partitionBySensitivity } from './context-engine/privacy-filter.js';\nimport { composeLayer1 } from './context-engine/templates/composer.js';\nimport { type EntityResolutionConfig, EntityResolver } from './graph/entity-resolver.js';\nimport type { ContextualRetrievalMode } from './internal/contextualize.js';\nimport { bindEmbedder } from './internal/embedder-binding.js';\nimport type { EmbeddingMetaRegistryLike, MemoryStoreAdapter } from './internal/storage-adapter.js';\nimport { createProviderRetrievalGrader } from './search/iterative.js';\nimport { createProviderQueryTransformer } from './search/query-transform.js';\nimport { RRFReranker } from './search/rrf.js';\nimport type { ReRanker } from './search/types.js';\nimport { EpisodicMemory } from './tiers/episodic-memory.js';\nimport { InsightMemory } from './tiers/insight-memory.js';\nimport { ProceduralMemory } from './tiers/procedural-memory.js';\nimport { SemanticMemory } from './tiers/semantic-memory.js';\nimport { SessionMemory } from './tiers/session-memory.js';\nimport { SharedMemory } from './tiers/shared-memory.js';\nimport { type BlockDefinition, WorkingMemory } from './tiers/working-memory.js';\nimport { buildMemoryTools, type ScopeResolver } from './tools/index.js';\n\n/**\n * Options accepted by {@link createMemory}.\n *\n * @stable\n */\nexport interface CreateMemoryOptions {\n  /** Storage adapter (default: `@graphorin/store-sqlite`'s `MemoryStore`). */\n  readonly store: MemoryStoreAdapter;\n  /** Embedder registry. The default sqlite store exposes one as `sqlite.embeddings`. */\n  readonly embeddings: EmbeddingMetaRegistryLike;\n  /** Embedder provider (default: none — vector search is disabled). */\n  readonly embedder?: EmbedderProvider;\n  /** Pre-declared working blocks (idempotent — re-defining is a no-op). */\n  readonly workingBlocks?: ReadonlyArray<BlockDefinition>;\n  /**\n   * Tracer used for every `memory.*` span. Defaults to the no-op\n   * tracer from `@graphorin/core` so unit tests do not need to wire\n   * the observability stack.\n   */\n  readonly tracer?: Tracer;\n  /** Override the reranker used by `SemanticMemory.search`. */\n  readonly reranker?: ReRanker;\n  /**\n   * Contextual-retrieval mode for the write path (P1-3). `'late-chunk'`\n   * (default) prepends a deterministic, offline situating context\n   * (entities / timeframe / topics, derived from the fact's own\n   * structured fields) to the text that is embedded + FTS-indexed, so a\n   * terse fact stays findable; the canonical `text` is preserved. `'off'`\n   * indexes the bare text. The `'llm'` enrichment is **not** available on\n   * the hot path — it is a consolidator-only opt-in configured via\n   * `consolidator: { contextualRetrieval: 'llm' }`.\n   */\n  readonly contextualRetrieval?: 'off' | 'late-chunk';\n  /**\n   * Query transformation for retrieval (P2-3, opt-in). When supplied,\n   * `SemanticMemory.search(..., { multiQuery })` fans the query into\n   * reworded variants (multi-query / RAG-Fusion) and `{ hyde }` adds a\n   * hypothetical-answer embedding — both via one cheap LLM call on the\n   * given provider, fused through the existing RRF reranker. Omitted (the\n   * default) ⇒ search stays **offline + single-shot** and the\n   * `multiQuery` / `hyde` search options become silent no-ops. Reserve it\n   * for retrieval-heavy recall, not every search (it adds provider\n   * latency).\n   */\n  readonly queryTransform?: {\n    /** Cheap provider used to rewrite the query / write the HyDE passage. */\n    readonly provider: Provider;\n    /** Hard ceiling on reworded variants requested per call. Default 5. */\n    readonly maxVariants?: number;\n    /** Output-token ceiling per transform call. Default 256. */\n    readonly maxTokens?: number;\n  };\n  /**\n   * Relation-graph entity resolution (P2-1). When `entityResolution` is\n   * `true` **and** the storage adapter exposes a `graph` surface (the\n   * default `@graphorin/store-sqlite` does), `remember(...)` resolves a\n   * fact's subject / object to canonical entities and links them, so\n   * `search(..., { expandHops: 1 })` can traverse relationships. Omitted\n   * (the default) ⇒ facts still carry s/p/o but form no entity links and\n   * the write path stays offline + unchanged. Dedup is lexical +\n   * embedding (offline, via the configured embedder); LLM adjudication of\n   * ambiguous merges is a further opt-in that needs `provider`.\n   */\n  readonly graph?: EntityResolutionConfig & {\n    /** Enable entity resolution + linking on write. Default `false`. */\n    readonly entityResolution?: boolean;\n    /** Provider for opt-in LLM adjudication of ambiguous merges. */\n    readonly provider?: Provider;\n  };\n  /**\n   * Agentic / iterative retrieval (P2-4, opt-in). When supplied,\n   * `SemanticMemory.searchIterative(...)` and the gated `deep_recall`\n   * tool can grade a retrieved set on the given provider and, for queries\n   * judged hard, reformulate + retrieve again (widening to one-hop graph\n   * expansion) up to `maxIterations`, abstaining instead of confabulating\n   * when memory is insufficient. Omitted (the default) ⇒ `searchIterative`\n   * stays a single difficulty-gated pass with **no provider call**, and\n   * `deep_recall` is **not** registered (the tool surface stays at the\n   * canonical eleven). Reserve it for hard multi-hop / temporal recall —\n   * it adds provider latency per pass.\n   */\n  readonly iterativeRetrieval?: {\n    /** Cheap provider used to grade retrieved memories + reformulate. */\n    readonly provider: Provider;\n    /** Default total-pass cap (clamped to `[1, 5]`). Default 3. */\n    readonly maxIterations?: number;\n    /** Output-token ceiling per grade call. Default 256. */\n    readonly maxTokens?: number;\n  };\n  /**\n   * Opt-in workflow induction (P2-2). When set, `ProceduralMemory.induce(...)`\n   * distils a reusable, value-abstracted procedure from a successful agent\n   * trajectory and stores it **quarantined** + `provenance: 'induction'`.\n   * Omitted (the default) ⇒ `induce(...)` throws\n   * {@link ProcedureInductionNotConfiguredError} and the procedural tier\n   * stays pure offline CRUD — no provider call.\n   */\n  readonly procedureInduction?: {\n    /** Provider used to abstract trajectory values into a procedure. */\n    readonly provider: Provider;\n    /** Output-token ceiling per induction call. Default 512. */\n    readonly maxTokens?: number;\n  };\n  /**\n   * Promotion-by-demonstrated-success for quarantined induced\n   * procedures (MCON-2 part 4). Fully offline — orthogonal to\n   * `procedureInduction` (no provider needed). When configured,\n   * `procedural.recordOutcome(scope, id, true)` increments the rule's\n   * persistent success counter and promotes it into `activate()` once\n   * `afterSuccesses` verified reuses accumulate; the injection gate\n   * still refuses flagged texts. Omitted ⇒ outcomes are counted but\n   * nothing auto-promotes.\n   */\n  readonly procedurePromotion?: {\n    /** Successful demonstrated reuses required before promotion (≥ 1). */\n    readonly afterSuccesses: number;\n  };\n  /**\n   * Resolver that produces the live {@link SessionScope} for each\n   * memory-tool invocation. Defaults to a closure that throws — the\n   * agent runtime overrides it in Phase 12.\n   */\n  readonly resolveScope?: ScopeResolver;\n  /**\n   * Consolidator configuration. When omitted, empty, or\n   * `enabled: false`, the facade installs the Phase 10a no-op\n   * placeholder so consumers can still type their interactions without\n   * paying the runtime cost. ANY other setting — including offline\n   * knobs like `decayCapacity` or `contextualRetrieval` — implicitly\n   * enables the production runtime (MST-4); `enabled: false` together\n   * with other settings warns once and keeps the placeholder.\n   */\n  readonly consolidator?: {\n    readonly enabled?: boolean;\n    readonly triggers?: ReadonlyArray<ConsolidatorTriggerSpec>;\n    readonly tier?: ConsolidatorTier;\n    readonly phases?: ReadonlyArray<ConsolidatorPhase>;\n    readonly ceilings?: Partial<ConsolidatorCeilings>;\n    readonly onExceed?: OnBudgetExceed;\n    /** Provider routed to the standard phase when set (MCON-7); falls back to `provider`. */\n    readonly cheapProvider?: Provider | null;\n    /** Provider routed to the deep + reflection passes when set (MCON-7). */\n    readonly deepProvider?: Provider | null;\n    readonly cheapModel?: string | null;\n    readonly deepModel?: string | null;\n    readonly noiseFilters?: ReadonlyArray<'default' | 'minimal' | 'none'>;\n    readonly lockWaitMs?: number;\n    readonly decayTauDays?: number;\n    readonly decayArchiveThreshold?: number;\n    /** Capacity-bounded eviction target for the light phase (X-1). Default unbounded. */\n    readonly decayCapacity?: number | null;\n    /** Weights for the multi-signal salience score (X-1). */\n    readonly salienceWeights?: SalienceWeights;\n    readonly maxStandardBatchSize?: number;\n    readonly maxDeepConflictsPerRun?: number;\n    readonly dlqMaxRetries?: number;\n    readonly dlqBaseBackoffMs?: number;\n    readonly dlqMaxBackoffMs?: number;\n    /** Auto-form quarantined episodes from processed slices (P1-2). Per-tier default. */\n    readonly formEpisodes?: boolean;\n    /** Score episode importance via the consolidator LLM (P1-2). Per-tier default. */\n    readonly importanceScoring?: boolean;\n    /** Opt in to auto-promotion of injection-clean extraction facts (MCON-2). Default off. */\n    readonly autoPromoteExtraction?: boolean;\n    /** Run the deep-phase reflection pass synthesizing cited insights (P1-1). Per-tier default. */\n    readonly reflection?: boolean;\n    /** Accumulated-importance threshold at which reflection fires (P1-1). */\n    readonly importanceThreshold?: number;\n    /** Upper bound on salient questions reflection asks per pass (P1-1). */\n    readonly reflectionMaxQuestions?: number;\n    /**\n     * Contextual retrieval for standard-phase fact writes (P1-3).\n     * `'llm'` opts into one budgeted cheap-model call per write to author\n     * a situating prefix (consolidator-only); `'late-chunk'` (default)\n     * and `'off'` defer to the write-path mode. Per-tier default.\n     */\n    readonly contextualRetrieval?: ContextualRetrievalMode;\n    readonly defaultScope?: SessionScope;\n    readonly provider?: Provider | null;\n    /** Override the wall clock — used by tests. */\n    readonly now?: () => number;\n    /** Stable id seed — used by tests. */\n    readonly randomId?: () => string;\n    /** Subscribe to phase-finished events. */\n    readonly onPhaseFinished?: PhaseListener;\n  };\n  /**\n   * Conflict pipeline configuration (Phase 10b). Default: enabled,\n   * English locale pack, thresholds `0.95 / 0.85 / 0.4`. Pass\n   * `{ mode: 'off' }` to bypass the pipeline entirely (logs a one-shot\n   * WARN per process per the spec).\n   */\n  readonly conflictPipeline?: ConflictPipelineOptions;\n  /**\n   * Context engine configuration (Phase 10d). The engine assembles\n   * the layered six-layer system prompt; `memory.compile(scope)`\n   * delegates to it for the working blocks + rules + metadata\n   * fragments. When omitted, a default engine is created (English\n   * locale; `'full'` base mode; no auto-recall; conservative\n   * `'public-tls'` provider trust).\n   */\n  readonly contextEngine?: ContextEngineConfig;\n}\n\n/**\n * The facade returned by {@link createMemory}.\n *\n * @stable\n */\nexport interface Memory {\n  readonly working: WorkingMemory;\n  readonly session: SessionMemory;\n  readonly episodic: EpisodicMemory;\n  readonly semantic: SemanticMemory;\n  readonly procedural: ProceduralMemory;\n  readonly shared: SharedMemory;\n  /**\n   * Read surface over reflection insights (P1-1). A no-op (returns\n   * empty) when the storage adapter does not expose the optional\n   * insight surface.\n   */\n  readonly insights: InsightMemory;\n  readonly tools: ReadonlyArray<Tool>;\n  readonly consolidator: Consolidator;\n  /** The configured conflict pipeline. Surfaced for tests + CLI tooling. */\n  readonly conflictPipeline: ConflictPipeline;\n  /** The configured context engine (Phase 10d). */\n  readonly contextEngine: ContextEngine;\n  /** The active embedder, when configured. `null` otherwise. */\n  readonly embedder: EmbedderProvider | null;\n  /** The canonical id of the active embedder, when configured. */\n  embedderId(): string | null;\n  /**\n   * Compile a system-prompt block bundle. The bundle carries the\n   * static fragments per memory tier; the agent runtime consumes\n   * the {@link ContextEngine} surface (`memory.contextEngine`)\n   * directly for the full six-layer assembly.\n   */\n  compile(scope: CompileScope, options?: CompileOptions): Promise<MemoryContextBlocks>;\n  /** Counter snapshot consumed by Phase 10d's metadata layer. */\n  metadata(scope: SessionScope): Promise<MemoryMetadata>;\n}\n\n/**\n * Wire every memory subsystem in one call. Returns the typed\n * `Memory` facade ready to be passed into `createAgent({...})`.\n *\n * @stable\n */\nexport function createMemory(options: CreateMemoryOptions): Memory {\n  const tracer = options.tracer ?? NOOP_TRACER;\n  const reranker: ReRanker = options.reranker ?? new RRFReranker();\n  const resolveScope: ScopeResolver =\n    options.resolveScope ??\n    (() => {\n      throw new TypeError(\n        '[graphorin/memory] memory tool invoked without a scope resolver. ' +\n          'Pass `resolveScope` to createMemory({...}) — the agent runtime supplies one in Phase 12.',\n      );\n    });\n\n  let activeEmbedderId: string | null = null;\n  if (options.embedder !== undefined) {\n    activeEmbedderId = bindEmbedder(options.embedder, options.embeddings);\n  }\n  const embedder = options.embedder ?? null;\n  const embedderIdProvider = (): string | null => activeEmbedderId;\n\n  const working = new WorkingMemory({ store: options.store, tracer });\n  for (const block of options.workingBlocks ?? []) {\n    working.define(block);\n  }\n  const session = new SessionMemory({ store: options.store, tracer });\n  const episodic = new EpisodicMemory({\n    store: options.store,\n    tracer,\n    embedder,\n    embedderIdProvider,\n  });\n  const conflictPipeline = createConflictPipeline(options.conflictPipeline ?? {});\n  // P2-3: build the (opt-in) query transformer from the supplied provider.\n  // Absent ⇒ `null` ⇒ search stays offline + single-shot.\n  const queryTransformer =\n    options.queryTransform !== undefined\n      ? createProviderQueryTransformer(options.queryTransform.provider, {\n          ...(options.queryTransform.maxVariants !== undefined\n            ? { maxVariants: options.queryTransform.maxVariants }\n            : {}),\n          ...(options.queryTransform.maxTokens !== undefined\n            ? { maxTokens: options.queryTransform.maxTokens }\n            : {}),\n        })\n      : null;\n  // P2-1: build the (opt-in) entity resolver. Requires `graph.entityResolution`\n  // *and* a graph-capable adapter; absent ⇒ `null` ⇒ writes carry s/p/o but\n  // form no entity links and the write path stays offline + unchanged.\n  const graphStore = options.store.graph;\n  const entityResolver =\n    options.graph?.entityResolution === true && graphStore !== undefined\n      ? new EntityResolver({\n          store: graphStore,\n          embedder,\n          embedderId: embedderIdProvider,\n          ...(options.graph.provider !== undefined ? { provider: options.graph.provider } : {}),\n          config: {\n            ...(options.graph.mergeThreshold !== undefined\n              ? { mergeThreshold: options.graph.mergeThreshold }\n              : {}),\n            ...(options.graph.adjudicateThreshold !== undefined\n              ? { adjudicateThreshold: options.graph.adjudicateThreshold }\n              : {}),\n            ...(options.graph.llmAdjudication !== undefined\n              ? { llmAdjudication: options.graph.llmAdjudication }\n              : {}),\n          },\n        })\n      : null;\n  // P2-4: build the (opt-in) retrieval grader. Absent ⇒ `null` ⇒\n  // `searchIterative` runs a single difficulty-gated pass (no provider\n  // call) and the `deep_recall` tool is not registered.\n  const grader =\n    options.iterativeRetrieval !== undefined\n      ? createProviderRetrievalGrader(options.iterativeRetrieval.provider, {\n          ...(options.iterativeRetrieval.maxTokens !== undefined\n            ? { maxTokens: options.iterativeRetrieval.maxTokens }\n            : {}),\n        })\n      : null;\n  const semantic = new SemanticMemory({\n    store: options.store,\n    tracer,\n    embedder,\n    embedderIdProvider,\n    reranker,\n    conflictPipeline,\n    ...(options.contextualRetrieval !== undefined\n      ? { contextualRetrieval: options.contextualRetrieval }\n      : {}),\n    ...(queryTransformer !== null ? { queryTransformer } : {}),\n    ...(entityResolver !== null ? { entityResolver } : {}),\n    ...(grader !== null ? { grader } : {}),\n    ...(options.iterativeRetrieval?.maxIterations !== undefined\n      ? { iterativeMaxIterations: options.iterativeRetrieval.maxIterations }\n      : {}),\n  });\n  // P2-2: build the (opt-in) workflow inducer. Absent ⇒ `null` ⇒\n  // `ProceduralMemory.induce(...)` throws and the tier stays offline CRUD.\n  // MCON-15: induction spend is recorded into the consolidator budget —\n  // the consolidator is constructed AFTER the inducer, so the callback\n  // routes through a slot filled below (placeholder ⇒ no-op).\n  let consolidatorForSpend: Consolidator | null = null;\n  const inducer =\n    options.procedureInduction !== undefined\n      ? createProviderWorkflowInducer(options.procedureInduction.provider, {\n          ...(options.procedureInduction.maxTokens !== undefined\n            ? { maxTokens: options.procedureInduction.maxTokens }\n            : {}),\n          onUsage: (usage) => {\n            consolidatorForSpend?.recordExternalSpend(usage.promptTokens + usage.completionTokens);\n          },\n        })\n      : null;\n  const procedural = new ProceduralMemory({\n    store: options.store,\n    tracer,\n    ...(inducer !== null ? { inducer } : {}),\n    // MCON-2 part 4: opt-in promotion-by-demonstrated-success.\n    ...(options.procedurePromotion?.afterSuccesses !== undefined\n      ? { promoteAfterSuccesses: options.procedurePromotion.afterSuccesses }\n      : {}),\n  });\n  const shared = new SharedMemory({ store: options.store, tracer });\n  const insights = new InsightMemory({ store: options.store, tracer });\n\n  const tools = buildMemoryTools(\n    {\n      working,\n      session,\n      episodic,\n      semantic,\n      procedural,\n      shared,\n      resolveScope,\n    },\n    // P2-4: the gated `deep_recall` tool is registered only when a grader\n    // is configured — the offline default stays at exactly eleven tools.\n    { includeDeepRecall: grader !== null },\n  );\n\n  const consolidatorOpts = options.consolidator;\n  const consolidator: Consolidator = buildConsolidator(\n    consolidatorOpts,\n    options.store,\n    semantic,\n    episodic,\n    tracer,\n  );\n  consolidatorForSpend = consolidator;\n  const contextEngineConfig = options.contextEngine ?? {};\n  const contextEngine: ContextEngine = createContextEngine(contextEngineConfig);\n  const resolved = contextEngine.config();\n  const localePack =\n    contextEngineConfig.locale === undefined\n      ? enLocalePack\n      : typeof contextEngineConfig.locale === 'string'\n        ? contextEngineConfig.locale === enLocalePack.id\n          ? enLocalePack\n          : resolveLocalePack({ id: contextEngineConfig.locale })\n        : resolveLocalePack(contextEngineConfig.locale);\n\n  // The facade's `compile(...)` is the static-fragment surface\n  // consumed by callers that do not know the active provider yet\n  // (the agent runtime calls `memory.contextEngine.assemble(...)`\n  // with full provider context when `autoAssembleContext` is\n  // enabled). The privacy filter only fires\n  // when the caller explicitly passes `providerAcceptsSensitivity`\n  // OR the operator opted into the engine's `privacy` block.\n  const privacyOptedIn =\n    contextEngineConfig.privacy !== undefined &&\n    (contextEngineConfig.privacy.providerAcceptsSensitivity !== undefined ||\n      contextEngineConfig.privacy.cloudUploadConsent !== undefined ||\n      contextEngineConfig.privacy.providerTrust !== undefined);\n\n  async function compile(\n    scope: CompileScope,\n    compileOptions: CompileOptions = {},\n  ): Promise<MemoryContextBlocks> {\n    const out: { -readonly [K in keyof MemoryContextBlocks]: MemoryContextBlocks[K] } = {};\n    const blocks = await options.store.working.list(scope);\n    // Quarantined (e.g. P2-2-induced) procedures are provisional and must not\n    // reach the system prompt — `activate()` already excludes them, and\n    // compile() (public `@stable`) must agree or a compile()-based prompt\n    // builder ingests unvalidated induction procedures (MST-3).\n    const rules = (await options.store.procedural.list(scope)).filter(\n      (rule) => rule.status !== 'quarantined',\n    );\n    const shouldFilter = privacyOptedIn || compileOptions.providerAcceptsSensitivity !== undefined;\n    let blocksKept: ReadonlyArray<(typeof blocks)[number]> = blocks;\n    let rulesKept: ReadonlyArray<(typeof rules)[number]> = rules;\n    if (shouldFilter) {\n      const filterContext: Parameters<typeof partitionBySensitivity>[1] = {\n        providerTrust: resolved.providerTrust,\n        cloudUploadConsent: resolved.cloudUploadConsent,\n        defaultSensitivity: resolved.defaultSensitivity,\n      };\n      if (compileOptions.providerAcceptsSensitivity !== undefined) {\n        (\n          filterContext as {\n            providerAcceptsSensitivity?: ReadonlyArray<'public' | 'internal' | 'secret'>;\n          }\n        ).providerAcceptsSensitivity = compileOptions.providerAcceptsSensitivity;\n      }\n      blocksKept = partitionBySensitivity(blocks, filterContext).kept;\n      rulesKept = partitionBySensitivity(rules, filterContext).kept;\n    }\n    const blocksXml = renderWorkingBlocksXml(blocksKept);\n    if (blocksXml.length > 0) {\n      out.workingBlocks = blocksXml;\n    }\n    if (rulesKept.length > 0) {\n      const lines = ['<memory_rules>'];\n      for (const rule of rulesKept) {\n        lines.push(`  <rule priority=\"${rule.priority}\">${escapeXml(rule.text)}</rule>`);\n      }\n      lines.push('</memory_rules>');\n      out.rules = lines.join('\\n');\n    }\n    if (compileOptions.includeMetadata !== false) {\n      const meta = await metadata(scope);\n      out.metadata = renderMetadataBlock(meta);\n    }\n    out.base = composeLayer1(localePack, resolved.memoryBaseMode);\n    return Object.freeze(out);\n  }\n\n  async function metadata(scope: SessionScope): Promise<MemoryMetadata> {\n    return gatherMemoryMetadata(scope, {\n      store: options.store,\n      consolidator,\n      embedderId: embedderIdProvider,\n      localeId: resolved.localeId,\n    });\n  }\n\n  return Object.freeze({\n    working,\n    session,\n    episodic,\n    semantic,\n    procedural,\n    shared,\n    insights,\n    tools,\n    consolidator,\n    conflictPipeline,\n    contextEngine,\n    embedder,\n    embedderId: embedderIdProvider,\n    compile,\n    metadata,\n  });\n}\n\nfunction renderWorkingBlocksXml(\n  blocks: ReadonlyArray<{\n    readonly label: string;\n    readonly value: string;\n    readonly description?: string;\n  }>,\n): string {\n  if (blocks.length === 0) return '';\n  const lines = ['<memory_blocks>'];\n  for (const block of blocks) {\n    const description =\n      block.description !== undefined ? ` description=\"${escapeXml(block.description)}\"` : '';\n    lines.push(`  <block label=\"${escapeXml(block.label)}\"${description}>`);\n    lines.push(`    ${escapeXml(block.value)}`);\n    lines.push('  </block>');\n  }\n  lines.push('</memory_blocks>');\n  return lines.join('\\n');\n}\n\nfunction escapeXml(value: string): string {\n  return value\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;');\n}\n\nfunction buildConsolidator(\n  opts: CreateMemoryOptions['consolidator'],\n  store: CreateMemoryOptions['store'],\n  semantic: SemanticMemory,\n  episodic: EpisodicMemory,\n  tracer: Tracer,\n): Consolidator {\n  if (opts === undefined) {\n    return createConsolidatorPlaceholder();\n  }\n  const enabled = shouldEnableConsolidator(opts);\n  if (!enabled) {\n    return createConsolidatorPlaceholder({\n      ...(opts.triggers !== undefined ? { triggers: opts.triggers } : {}),\n      ...(opts.tier !== undefined ? { tier: opts.tier } : {}),\n    });\n  }\n  const consolidator = createConsolidator({\n    store,\n    semantic,\n    episodic,\n    tracer,\n    ...(opts.provider !== undefined ? { provider: opts.provider } : {}),\n    ...(opts.now !== undefined ? { now: opts.now } : {}),\n    ...(opts.randomId !== undefined ? { randomId: opts.randomId } : {}),\n    ...(opts.triggers !== undefined ? { triggers: opts.triggers } : {}),\n    ...(opts.tier !== undefined ? { tier: opts.tier } : {}),\n    ...(opts.phases !== undefined ? { phases: opts.phases } : {}),\n    ...(opts.ceilings !== undefined ? { ceilings: opts.ceilings } : {}),\n    ...(opts.onExceed !== undefined ? { onExceed: opts.onExceed } : {}),\n    ...(opts.cheapProvider !== undefined ? { cheapProvider: opts.cheapProvider } : {}),\n    ...(opts.deepProvider !== undefined ? { deepProvider: opts.deepProvider } : {}),\n    ...(opts.cheapModel !== undefined ? { cheapModel: opts.cheapModel } : {}),\n    ...(opts.deepModel !== undefined ? { deepModel: opts.deepModel } : {}),\n    ...(opts.noiseFilters !== undefined ? { noiseFilters: opts.noiseFilters } : {}),\n    ...(opts.lockWaitMs !== undefined ? { lockWaitMs: opts.lockWaitMs } : {}),\n    ...(opts.decayTauDays !== undefined ? { decayTauDays: opts.decayTauDays } : {}),\n    ...(opts.decayArchiveThreshold !== undefined\n      ? { decayArchiveThreshold: opts.decayArchiveThreshold }\n      : {}),\n    ...(opts.decayCapacity !== undefined ? { decayCapacity: opts.decayCapacity } : {}),\n    ...(opts.salienceWeights !== undefined ? { salienceWeights: opts.salienceWeights } : {}),\n    ...(opts.maxStandardBatchSize !== undefined\n      ? { maxStandardBatchSize: opts.maxStandardBatchSize }\n      : {}),\n    ...(opts.maxDeepConflictsPerRun !== undefined\n      ? { maxDeepConflictsPerRun: opts.maxDeepConflictsPerRun }\n      : {}),\n    ...(opts.dlqMaxRetries !== undefined ? { dlqMaxRetries: opts.dlqMaxRetries } : {}),\n    ...(opts.dlqBaseBackoffMs !== undefined ? { dlqBaseBackoffMs: opts.dlqBaseBackoffMs } : {}),\n    ...(opts.dlqMaxBackoffMs !== undefined ? { dlqMaxBackoffMs: opts.dlqMaxBackoffMs } : {}),\n    ...(opts.formEpisodes !== undefined ? { formEpisodes: opts.formEpisodes } : {}),\n    ...(opts.importanceScoring !== undefined ? { importanceScoring: opts.importanceScoring } : {}),\n    ...(opts.autoPromoteExtraction !== undefined\n      ? { autoPromoteExtraction: opts.autoPromoteExtraction }\n      : {}),\n    ...(opts.reflection !== undefined ? { reflection: opts.reflection } : {}),\n    ...(opts.importanceThreshold !== undefined\n      ? { importanceThreshold: opts.importanceThreshold }\n      : {}),\n    ...(opts.reflectionMaxQuestions !== undefined\n      ? { reflectionMaxQuestions: opts.reflectionMaxQuestions }\n      : {}),\n    ...(opts.contextualRetrieval !== undefined\n      ? { contextualRetrieval: opts.contextualRetrieval }\n      : {}),\n    ...(opts.defaultScope !== undefined ? { defaultScope: opts.defaultScope } : {}),\n  });\n  if (opts.onPhaseFinished !== undefined) {\n    consolidator.onPhaseFinished(opts.onPhaseFinished);\n  }\n  return consolidator;\n}\n\nlet consolidatorConfigIgnoredWarned = false;\n\n/** @internal — test seam for the one-time disabled-config warning. */\nexport function _resetConsolidatorConfigWarningForTesting(): void {\n  consolidatorConfigIgnoredWarned = false;\n}\n\nfunction shouldEnableConsolidator(opts: NonNullable<CreateMemoryOptions['consolidator']>): boolean {\n  // MST-4: ANY non-empty consolidator config implicitly enables — the old\n  // allow-list silently ignored offline knobs (`decayCapacity`,\n  // `formEpisodes`, `reflection`, `contextualRetrieval`, …): the caller\n  // got a no-op placeholder while believing the feature was on.\n  const keys = Object.keys(opts).filter(\n    (k) => k !== 'enabled' && (opts as Record<string, unknown>)[k] !== undefined,\n  );\n  if (opts.enabled === false) {\n    if (keys.length > 0 && !consolidatorConfigIgnoredWarned) {\n      consolidatorConfigIgnoredWarned = true;\n      process.stderr.write(\n        `[graphorin/memory] consolidator config (${keys.join(', ')}) was supplied together with enabled: false — the settings are ignored until the consolidator is enabled.\\n`,\n      );\n    }\n    return false;\n  }\n  if (opts.enabled === true) return true;\n  return keys.length > 0;\n}\n"],"mappings":"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"}