@jmanuelcorral/openteam 0.1.37 → 0.1.40

package/dist/local/embeddings.d.ts

@@ -0,0 +1,29 @@
+import type { Embedding } from "../memory/types";
+import type { FetchLike } from "./types";
+/**
+ * Adapter **local-first** de embeddings. Aquí vive el I/O: llama al endpoint
+ * OpenAI-compatible `/embeddings` del runtime local. Los vectores se calculan en
+ * la máquina (nunca salen a frontier si `forceLocalOnSensitive`) y no son texto
+ * legible, por lo que pueden persistirse aun con `storeContent=false`.
+ */
+/** Función de embedding inyectable: mapea textos a vectores en el mismo orden. */
+export type Embedder = (texts: readonly string[]) => Promise<Embedding[]>;
+export type EmbedRequest = {
+    baseURL: string;
+    modelID: string;
+    texts: readonly string[];
+};
+export type EmbedDeps = {
+    fetch: FetchLike;
+};
+/** Parsea la respuesta OpenAI-compatible de `/embeddings` a vectores ordenados. */
+export declare function parseEmbeddingsResponse(payload: unknown): Embedding[];
+/**
+ * Ejecuta el embedding contra el runtime local. Devuelve un vector por texto, en
+ * el mismo orden. Lanza si la petición o la respuesta fallan (a diferencia de la
+ * extracción, aquí un fallo es relevante para el recall).
+ */
+export declare function embedTexts(request: EmbedRequest, deps: EmbedDeps): Promise<Embedding[]>;
+/** Construye un `Embedder` que usa el runtime local vía `embedTexts`. */
+export declare function createLocalEmbedder(request: Omit<EmbedRequest, "texts">, deps: EmbedDeps): Embedder;
+//# sourceMappingURL=embeddings.d.ts.map

package/dist/local/embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.d.ts","sourceRoot":"","sources":["../../src/local/embeddings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;GAKG;AAEH,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;AAE1E,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,CAwBrE;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,SAAS,EAAE,CAAC,CAyCtB;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,EACpC,IAAI,EAAE,SAAS,GACd,QAAQ,CAEV"}

package/dist/local/extractClient.d.ts

@@ -0,0 +1,31 @@
+import { type ExtractionContext, type ExtractionMessage } from "../memory/extract";
+import type { MemoryRecord } from "../memory/types";
+import type { FetchLike } from "./types";
+/**
+ * Adapter **local-first** de extracción de memoria. Aquí vive el I/O: llama al
+ * runtime local OpenAI-compatible (`/chat/completions`) y delega el parseo/redacción
+ * a `parseExtraction` (puro). El `router/`/`memory/` core permanece determinista.
+ *
+ * Coste marginal ~0 y los datos no salen de la máquina. Frontier solo como
+ * fallback opt-in (fuera de este adapter, respetando `forceLocalOnSensitive`).
+ */
+export type ExtractRequest = {
+    baseURL: string;
+    modelID: string;
+    messages: readonly ExtractionMessage[];
+    context: ExtractionContext;
+    /** Temperatura; 0 por defecto para maximizar determinismo del extractor. */
+    temperature?: number;
+};
+export type ExtractDeps = {
+    fetch: FetchLike;
+};
+/** Extrae el texto del primer choice de una respuesta OpenAI-compatible. */
+export declare function readChatContent(payload: unknown): string;
+/**
+ * Ejecuta la extracción contra el runtime local. Devuelve `MemoryRecord[]` ya
+ * redactados según `context.storeContent`. Nunca lanza por respuestas vacías o
+ * malformadas: en ese caso devuelve `[]` (tolerante, como el resto del pipeline).
+ */
+export declare function extractMemory(request: ExtractRequest, deps: ExtractDeps): Promise<MemoryRecord[]>;
+//# sourceMappingURL=extractClient.d.ts.map

package/dist/local/extractClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractClient.d.ts","sourceRoot":"","sources":["../../src/local/extractClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;GAOG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACvC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAmBxD;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAsCzB"}

package/dist/local/openai-compatible.d.ts

@@ -2,6 +2,7 @@ import type { FetchLike, LocalModelInfo, LocalRuntimeId, LocalRuntimeSnapshot }
 export declare function normalizeBaseURL(baseURL: string): string;
 export declare function modelsEndpoint(baseURL: string): string;
 export declare function chatCompletionsEndpoint(baseURL: string): string;
+export declare function embeddingsEndpoint(baseURL: string): string;
 export declare function errorMessage(error: unknown): string;
 export declare function listOpenAICompatibleModels(baseURL: string, fetch: FetchLike): Promise<LocalModelInfo[]>;
 export declare function parseOpenAIModels(payload: unknown): LocalModelInfo[];

package/dist/local/openai-compatible.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../src/local/openai-compatible.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,cAAc,EACd,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMnD;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,EAAE,CAAC,CAkB3B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,EAAE,CAMpE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,EAAE,EAAE,cAAc,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,oBAAoB,CASvB;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE;IACxD,EAAE,EAAE,cAAc,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmBhC;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiDnB"}
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../src/local/openai-compatible.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,cAAc,EACd,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMnD;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,cAAc,EAAE,CAAC,CAkB3B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,EAAE,CAMpE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,EAAE,EAAE,cAAc,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,oBAAoB,CASvB;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE;IACxD,EAAE,EAAE,cAAc,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmBhC;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiDnB"}

package/dist/mcp/semanticRecall.d.ts

@@ -0,0 +1,25 @@
+import type { Embedder } from "../local/embeddings";
+import type { RankSignals } from "../memory/rank";
+import type { MemoryIndex } from "../storage/index/memoryIndex";
+import type { SemanticRecall } from "./server";
+/**
+ * Compone un `SemanticRecall` (para el servidor MCP) a partir del índice de
+ * memoria, un `Embedder` local y la política de scope/temporal. Aísla el wiring
+ * del recall semántico para que `cli.ts` sea un caller fino y esto quede cubierto
+ * por tests.
+ */
+export type SemanticRecallPolicy = {
+    ownerKey: string;
+    asOf?: number | null;
+    minSimilarity: number;
+    includeShared: boolean;
+};
+export type SemanticRecallDeps = {
+    index: MemoryIndex;
+    embedder: Embedder;
+    /** Reloj inyectado (epoch ms) para el `asOf` "ahora". */
+    now: () => number;
+    signals?: Omit<RankSignals, "now">;
+};
+export declare function buildSemanticRecall(deps: SemanticRecallDeps, policy: SemanticRecallPolicy): SemanticRecall;
+//# sourceMappingURL=semanticRecall.d.ts.map

package/dist/mcp/semanticRecall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semanticRecall.d.ts","sourceRoot":"","sources":["../../src/mcp/semanticRecall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;GAKG;AAEH,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,yDAAyD;IACzD,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;CACpC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,oBAAoB,GAC3B,cAAc,CAqBhB"}

package/dist/mcp/server.d.ts

@@ -1,3 +1,4 @@
+import type { MemoryKind, RecallResult } from "../memory/types";
 import { type TeamMemory } from "./teamMemory";
 /**
  * Servidor MCP **de solo lectura** que expone la memoria del equipo
@@ -7,6 +8,11 @@ import { type TeamMemory } from "./teamMemory";
  *
  * `handleMcpMessage` es puro salvo por `deps.readMemory` (inyectado): no expone
  * prompts crudos, solo el estado ya redactado por la agregación.
+ *
+ * Si se inyecta `deps.recallSemantic` (memoria semántica opt-in, M4), se exponen
+ * además tools de recall (`recall_facts`/`recall_preferences`/`similar_tasks`).
+ * El contenido devuelto es el ya redactado en el store (`storeContent=false` por
+ * defecto): la tool nunca reconstruye texto crudo.
  */
 export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
 export type JsonRpcId = string | number | null;
@@ -30,9 +36,21 @@ export type McpServerInfo = {
     name: string;
     version: string;
 };
+/**
+ * Recall semántico inyectado (M4). La política de scope (`ownerKey`), `asOf` y
+ * `minSimilarity` la decide el wiring; la tool solo pasa el texto, los `kinds` y
+ * el `limit`. Devuelve records ya redactados por el store.
+ */
+export type SemanticRecall = (input: {
+    queryText: string;
+    kinds: MemoryKind[];
+    limit: number;
+}) => Promise<RecallResult[]>;
 export type McpServerDeps = {
     /** Lee la memoria del equipo bajo demanda (I/O inyectado). */
     readMemory: () => Promise<TeamMemory>;
+    /** Recall semántico opt-in; si está ausente, las tools de memoria no se exponen. */
+    recallSemantic?: SemanticRecall;
     serverInfo?: McpServerInfo;
 };
 type ToolDef = {
@@ -41,6 +59,10 @@ type ToolDef = {
     inputSchema: Record<string, unknown>;
 };
 export declare const MCP_TOOLS: ToolDef[];
+/** Tools de memoria semántica (M4). Solo se exponen si hay `recallSemantic`. */
+export declare const MEMORY_TOOLS: ToolDef[];
+/** Tools disponibles según los deps (las de memoria son opt-in). */
+export declare function availableTools(deps: McpServerDeps): ToolDef[];
 /**
  * Procesa un mensaje JSON-RPC del cliente MCP. Devuelve la respuesta, o `null`
  * para notificaciones (mensajes sin `id`, p. ej. `notifications/initialized`).

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG;IAC1B,8DAA8D;IAC9D,UAAU,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACtC,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B,CAAC;AAOF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAUF,eAAO,MAAM,SAAS,EAAE,OAAO,EAgC9B,CAAC;AAoEF;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwCjC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAKL,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,8DAA8D;IAC9D,UAAU,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACtC,oFAAoF;IACpF,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B,CAAC;AAOF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAUF,eAAO,MAAM,SAAS,EAAE,OAAO,EAgC9B,CAAC;AAUF,gFAAgF;AAChF,eAAO,MAAM,YAAY,EAAE,OAAO,EA+BjC,CAAC;AAEF,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,EAAE,CAI7D;AAwID;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwCjC"}

package/dist/memory/consolidate.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryRecord } from "./types";
+export type DecayParams = {
+    /** Vida media de la confianza (ms). A mayor edad sin refuerzo, menor confianza. */
+    halfLifeMs: number;
+    /** Umbral por debajo del cual el record se olvida (soft-invalidate). */
+    forgetThreshold: number;
+};
+export declare const DEFAULT_DECAY_PARAMS: DecayParams;
+/**
+ * Confianza decaída del record en `now`: `confidence * 0.5 ** (edad / vidaMedia)`.
+ * A edad 0 devuelve la confianza original; nunca crece con el tiempo.
+ */
+export declare function decayedConfidence(record: MemoryRecord, now: number, params?: DecayParams): number;
+/**
+ * Genera los tombstones para los records **transaction-activos** cuya confianza
+ * decaída cae por debajo de `forgetThreshold`. Cada tombstone conserva el `id`
+ * del record y marca `invalidatedAt = now` (olvido por decay, sin `supersededBy`:
+ * no es una supersesión). Los records ya invalidados se ignoran (idempotente).
+ */
+export declare function consolidate(records: readonly MemoryRecord[], now: number, params?: DecayParams): MemoryRecord[];
+//# sourceMappingURL=consolidate.d.ts.map

package/dist/memory/consolidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidate.d.ts","sourceRoot":"","sources":["../../src/memory/consolidate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAkB5C,MAAM,MAAM,WAAW,GAAG;IACxB,mFAAmF;IACnF,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,WAGlC,CAAC;AAUF;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,WAAkC,GACzC,MAAM,CAGR;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,WAAkC,GACzC,YAAY,EAAE,CAWhB"}

package/dist/memory/extract.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { MemoryRecord } from "./types";
+/**
+ * Extracción de memoria **pura y determinista**. Construye el prompt de extracción
+ * y parsea la salida JSON del modelo a `MemoryRecord[]`, aplicando la política de
+ * redacción (ADR-5). **Sin I/O, red, reloj ni random**: el instante (`now`), el
+ * `ownerKey`, el `sourceHash` y el `idPrefix` los inyecta el llamante (el adapter
+ * local vive en `src/local/`).
+ *
+ * Privacidad (ADR-5): con `storeContent=false` (default) se conserva la estructura
+ * (subject/predicate/category/type) pero el **valor libre** (object/preference/
+ * canonicalName) se redacta; la trazabilidad queda en `sourceHash`.
+ */
+export declare const REDACTED: "[redacted]";
+export type ExtractionRole = "system" | "user" | "assistant";
+export type ExtractionMessage = {
+    role: ExtractionRole;
+    content: string;
+};
+export type ExtractionContext = {
+    ownerKey: string;
+    /** Epoch ms; se usa como `validFrom` y `createdAt` de cada record. */
+    now: number;
+    /** Hash de los mensajes fuente (provenance). Nunca el prompt crudo. */
+    sourceHash: string;
+    /** Si false (default), redacta el valor libre de cada record. */
+    storeContent: boolean;
+    /** Prefijo determinista para los ids generados. */
+    idPrefix: string;
+};
+export declare const RawExtractionSchema: z.ZodObject<{
+    facts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        subject: z.ZodString;
+        predicate: z.ZodString;
+        object: z.ZodString;
+        category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    preferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        preference: z.ZodString;
+        context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    entities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        canonicalName: z.ZodString;
+        type: z.ZodString;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RawExtraction = z.infer<typeof RawExtractionSchema>;
+/** Construye el prompt de extracción (determinista). */
+export declare function buildExtractionPrompt(messages: readonly ExtractionMessage[]): {
+    system: string;
+    user: string;
+};
+/**
+ * Extrae el primer objeto JSON balanceado del texto (tolera fences ```json y
+ * prosa alrededor). Devuelve `undefined` si no hay ninguno.
+ */
+export declare function extractJsonObject(text: string): unknown;
+/**
+ * Parsea la salida cruda del modelo a records de memoria, aplicando redacción.
+ * Tolerante: si no hay JSON válido o no valida el esquema, devuelve `[]`.
+ */
+export declare function parseExtraction(rawText: string, ctx: ExtractionContext): MemoryRecord[];
+//# sourceMappingURL=extract.d.ts.map

package/dist/memory/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/memory/extract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAgB,YAAY,EAAc,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,QAAQ,EAAG,YAAqB,CAAC;AAE9C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,YAAY,EAAE,OAAO,CAAC;IACtB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyBF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAI9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAchE,wDAAwD;AACxD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GAAG;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAMA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAqCvD;AA2ED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,iBAAiB,GACrB,YAAY,EAAE,CAehB"}

package/dist/memory/fold.d.ts

@@ -0,0 +1,24 @@
+import type { Entity, Fact, MemoryRecord, Preference } from "./types";
+/**
+ * Repliegue **puro** del log de aserciones al estado de memoria vigente. Reproduce
+ * la reconciliación (merge + supersesión no destructiva) en orden, usando el
+ * `createdAt` de cada aserción como instante de merge. El resultado incluye el
+ * histórico invalidado (para recall "as-of"), de modo que el índice SQLite es un
+ * derivado 100% reconstruible desde el log.
+ *
+ * Una aserción con `invalidatedAt !== null` es un **tombstone** de consolidación
+ * (ver `consolidate.ts`): soft-invalida el record con su mismo `id` en lugar de
+ * mergear un valor nuevo. Los writers de M1-M3 siempre afirman records activos,
+ * así que esta rama solo se activa para tombstones.
+ */
+export type MemoryState = {
+    facts: Fact[];
+    preferences: Preference[];
+    entities: Entity[];
+};
+export declare function emptyState(): MemoryState;
+/** Repliega las aserciones (en orden) al estado vigente + histórico. */
+export declare function foldAssertions(assertions: readonly MemoryRecord[]): MemoryState;
+/** Aplana un estado a la lista de todos sus records (facts + prefs + entities). */
+export declare function allRecords(state: MemoryState): MemoryRecord[];
+//# sourceMappingURL=fold.d.ts.map

package/dist/memory/fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/memory/fold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,wBAAgB,UAAU,IAAI,WAAW,CAExC;AAuBD,wEAAwE;AACxE,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,YAAY,EAAE,GAClC,WAAW,CA4Bb;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,EAAE,CAE7D"}

package/dist/memory/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Barrel del núcleo puro de memoria semántica (`src/memory/`). Análogo a
+ * `router/` en pureza: **sin I/O, red, reloj, random ni env vars**. La
+ * persistencia (SQLite derivado), la extracción y los embeddings viven en
+ * adapters inyectados fuera de este módulo.
+ */
+export * from "./consolidate";
+export * from "./extract";
+export * from "./fold";
+export * from "./inject";
+export * from "./log";
+export * from "./merge";
+export * from "./rank";
+export * from "./recall";
+export * from "./temporal";
+export * from "./types";
+export * from "./vector";
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/memory/inject.d.ts

@@ -0,0 +1,29 @@
+import type { MemoryRecord, RecallResult } from "./types";
+/**
+ * Formato **puro** del bloque de contexto de memoria que M6 inyecta (opt-in) en
+ * `chat.message`. Convierte los resultados de recall en un bloque de texto
+ * compacto respetando un **presupuesto de tokens** (aproximado por caracteres),
+ * para no inflar el contexto ni el coste.
+ *
+ * Privacy-first: solo formatea lo que ya está en los records (redactados en
+ * origen si `storeContent=false`). Módulo puro: sin I/O, red, reloj ni random.
+ */
+export type MemoryInjectionParams = {
+    /** Presupuesto máximo del bloque en caracteres (proxy de tokens). */
+    maxChars: number;
+    /** Cabecera del bloque inyectado. */
+    header: string;
+    /** Máximo de líneas (records) a incluir. */
+    maxItems: number;
+};
+export declare const DEFAULT_INJECTION_PARAMS: MemoryInjectionParams;
+/** Formatea un record a una línea compacta y legible según su tipo. */
+export declare function formatRecordLine(record: MemoryRecord): string;
+/**
+ * Construye el bloque de memoria a partir de los resultados de recall (ya
+ * rankeados). Incluye líneas mientras quepan en `maxChars` y no superen
+ * `maxItems`. Devuelve `null` si no hay nada que inyectar (sin resultados o
+ * ninguna línea cabe), para que el hook no toque el prompt.
+ */
+export declare function buildMemoryBlock(results: readonly RecallResult[], params?: MemoryInjectionParams): string | null;
+//# sourceMappingURL=inject.d.ts.map

package/dist/memory/inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../../src/memory/inject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;GAQG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,qBAItC,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAY7D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,GAAE,qBAAgD,GACvD,MAAM,GAAG,IAAI,CAsBf"}

package/dist/memory/log.d.ts

@@ -0,0 +1,16 @@
+import { type MemoryRecord } from "./types";
+/**
+ * Log **append-only** de aserciones de memoria (fuente de verdad, JSONL). Cada
+ * línea es un `MemoryRecord` serializado tal cual se afirmó; el índice SQLite se
+ * **deriva** replegando estas aserciones (ver `fold.ts`). Módulo puro: solo
+ * (de)serializa; el I/O lo hace el `StorageProvider` inyectado.
+ */
+/** Serializa una aserción a su línea JSONL canónica. */
+export declare function serializeAssertion(record: MemoryRecord): string;
+/**
+ * Parsea un log JSONL de aserciones. Ignora líneas vacías, JSON malformado y
+ * records que no validan contra el esquema (tolerante a corrupción, como
+ * `parseEventsJsonl`).
+ */
+export declare function parseMemoryLog(text: string): MemoryRecord[];
+//# sourceMappingURL=log.d.ts.map

package/dist/memory/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/memory/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,SAAS,CAAC;AAEhE;;;;;GAKG;AAEH,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CAmB3D"}

package/dist/memory/merge.d.ts

@@ -0,0 +1,38 @@
+import type { Entity, Fact, Preference } from "./types";
+/** Slot de un hecho: `{subject, predicate, ownerKey}`. Solo un valor activo por slot. */
+export declare function factSlotKey(fact: Fact): string;
+/** Triple exacto: slot + `object`. Idempotente (MERGE key dueño-scoped). */
+export declare function factValueKey(fact: Fact): string;
+/** Slot de una preferencia: `{category, ownerKey}`. */
+export declare function preferenceSlotKey(preference: Preference): string;
+/** Valor exacto de una preferencia: slot + texto. */
+export declare function preferenceValueKey(preference: Preference): string;
+/** Slot de una entidad: `{canonicalName, type, ownerKey}`. */
+export declare function entitySlotKey(entity: Entity): string;
+export type MergeResult<T> = {
+    /** Estado resultante (incluye históricos invalidados). */
+    records: T[];
+    /** Records que este merge dejó superseded (con `invalidatedAt`/`supersededBy`). */
+    superseded: T[];
+};
+/**
+ * Aplica un hecho al estado:
+ * - Si ya existe el **triple exacto activo** -> re-afirmación idempotente (fusiona
+ *   la ventana de validez y sube la confianza; no añade duplicado).
+ * - Si existe otro **valor activo en el mismo slot** -> lo supersede y añade el nuevo.
+ * - En otro caso -> añade el nuevo. Los históricos inactivos se preservan intactos.
+ */
+export declare function applyFact(state: readonly Fact[], incoming: Fact, now: number): MergeResult<Fact>;
+/**
+ * Aplica una preferencia al estado, con la misma semántica de slot que los hechos
+ * (`{category, ownerKey}` admite un valor activo). Al re-afirmar el mismo texto,
+ * conserva el record existente sin duplicar.
+ */
+export declare function applyPreference(state: readonly Preference[], incoming: Preference, now: number): MergeResult<Preference>;
+/**
+ * Aplica una entidad: dedup **idempotente** por slot `{canonicalName, type,
+ * ownerKey}`. Al re-encontrarla, fusiona alias (unión estable) y sube confianza;
+ * no supersede (las entidades no se contradicen, se enriquecen).
+ */
+export declare function applyEntity(state: readonly Entity[], incoming: Entity, now: number): MergeResult<Entity>;
+//# sourceMappingURL=merge.d.ts.map

package/dist/memory/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/memory/merge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAcxD,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE9C;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE/C;AAED,uDAAuD;AACvD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAEhE;AAED,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAEjE;AAED,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,0DAA0D;IAC1D,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,mFAAmF;IACnF,UAAU,EAAE,CAAC,EAAE,CAAC;CACjB,CAAC;AAYF;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,QAAQ,EAAE,IAAI,EACd,GAAG,EAAE,MAAM,GACV,WAAW,CAAC,IAAI,CAAC,CAkCnB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,QAAQ,EAAE,UAAU,EACpB,GAAG,EAAE,MAAM,GACV,WAAW,CAAC,UAAU,CAAC,CAqCzB;AAiBD;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,WAAW,CAAC,MAAM,CAAC,CAsBrB"}

package/dist/memory/rank.d.ts

@@ -0,0 +1,32 @@
+import type { MemoryRecord, RecallCandidate, RecallResult } from "./types";
+/**
+ * Ranking **determinista y auditable** de candidatos de recall. En lugar de un
+ * score opaco, combina señales **explícitas** (similitud semántica, recencia y
+ * refuerzo por acceso) con pesos configurables. Módulo puro: `now` se inyecta.
+ */
+export type RankSignals = {
+    /** Instante de referencia (epoch ms) para la recencia. */
+    now: number;
+    similarityWeight: number;
+    recencyWeight: number;
+    accessWeight: number;
+    /** Vida media de la recencia (ms). A mayor edad, menor score. */
+    recencyHalfLifeMs: number;
+};
+export declare const DEFAULT_RANK_SIGNALS: Omit<RankSignals, "now">;
+/** Score de recencia en `(0, 1]` con decaimiento exponencial por vida media. */
+export declare function recencyScore(record: MemoryRecord, signals: RankSignals): number;
+/**
+ * Score de refuerzo por acceso en `[0, 1)`. Solo las preferencias acumulan
+ * `accessCount`; el resto de records puntúan 0.
+ */
+export declare function accessScore(record: MemoryRecord): number;
+/** Score combinado de un candidato (mayor = más relevante). */
+export declare function scoreCandidate(candidate: RecallCandidate, signals: RankSignals): number;
+/**
+ * Ordena los candidatos por score descendente. Desempate **determinista** por
+ * `record.id` ascendente para que el resultado sea estable e independiente del
+ * orden de entrada.
+ */
+export declare function rankRecall(candidates: readonly RecallCandidate[], signals: RankSignals): RecallResult[];
+//# sourceMappingURL=rank.d.ts.map

package/dist/memory/rank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../src/memory/rank.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE3E;;;;GAIG;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAIF,eAAO,MAAM,oBAAoB,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAKzD,CAAC;AAUF,gFAAgF;AAChF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,WAAW,GACnB,MAAM,CAGR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAKxD;AAED,+DAA+D;AAC/D,wBAAgB,cAAc,CAC5B,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,WAAW,GACnB,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,OAAO,EAAE,WAAW,GACnB,YAAY,EAAE,CAYhB"}

package/dist/memory/recall.d.ts

@@ -0,0 +1,30 @@
+import { type RankSignals } from "./rank";
+import { type Embedding, type MemoryRecord, type RecallQuery, type RecallResult } from "./types";
+/**
+ * Pipeline de recall **puro**: filtra por scope de dueño y ventana bitemporal,
+ * calcula la similitud coseno contra los embeddings provistos y rankea con
+ * señales explícitas. Sin I/O: los embeddings (de los records y de la consulta)
+ * los aporta la capa de embeddings (M3); aquí todo es determinista.
+ */
+/** ¿El record es visible para el `ownerKey` de la consulta? */
+export declare function matchesScope(record: MemoryRecord, query: RecallQuery): boolean;
+export type RecallDeps = {
+    /** Embeddings por `record.id`. Los records sin embedding no son recuperables. */
+    embeddings: ReadonlyMap<string, Embedding>;
+    /** Instante de recall (epoch ms) cuando `query.asOf` es `null`. */
+    now: number;
+    /** Pesos de ranking; por defecto `DEFAULT_RANK_SIGNALS`. */
+    signals?: Omit<RankSignals, "now">;
+};
+/**
+ * Recupera los records más relevantes para `queryEmbedding`, respetando scope,
+ * `kinds`, ventana temporal (`asOf`), umbral `minSimilarity` y `limit`.
+ */
+export declare function recall(records: readonly MemoryRecord[], queryEmbedding: Embedding, query: RecallQuery, deps: RecallDeps): RecallResult[];
+/**
+ * Recall **as-of**: recupera lo que el sistema creía en el instante `asOf`
+ * (transaction-time). Azúcar sobre `recall` fijando `query.asOf`; útil para
+ * auditar el conocimiento histórico ("¿qué sabíamos entonces?").
+ */
+export declare function recallAsOf(records: readonly MemoryRecord[], queryEmbedding: Embedding, query: RecallQuery, asOf: number, deps: RecallDeps): RecallResult[];
+//# sourceMappingURL=recall.d.ts.map

package/dist/memory/recall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall.d.ts","sourceRoot":"","sources":["../../src/memory/recall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,WAAW,EAAc,MAAM,QAAQ,CAAC;AAE5E,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EAEjB,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,SAAS,CAAC;AAGjB;;;;;GAKG;AAEH,+DAA+D;AAC/D,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,WAAW,GACjB,OAAO,CAKT;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,iFAAiF;IACjF,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,OAAO,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,cAAc,EAAE,SAAS,EACzB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,UAAU,GACf,YAAY,EAAE,CAyBhB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,cAAc,EAAE,SAAS,EACzB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,GACf,YAAY,EAAE,CAEhB"}

package/dist/memory/temporal.d.ts

@@ -0,0 +1,39 @@
+import type { MemoryRecord } from "./types";
+/**
+ * Helpers **bitemporales puros** sobre records de memoria. Sin I/O ni reloj: el
+ * instante de referencia (`asOf`, epoch ms) siempre se inyecta.
+ *
+ * Un record es "recuperable" en `asOf` si lo era **según el sistema**
+ * (transaction-time: no invalidado antes o en ese instante) **y** era cierto en
+ * el mundo modelado (valid-time: dentro de su ventana de validez).
+ */
+/**
+ * Transaction-time: el sistema seguía creyendo el record en `asOf` (no había sido
+ * invalidado todavía). Un `invalidatedAt` posterior a `asOf` sí cuenta como activo
+ * (recall "as-of": "qué creíamos entonces").
+ */
+export declare function isTransactionActiveAt(record: MemoryRecord, asOf: number): boolean;
+/**
+ * Valid-time: el record era cierto en `asOf` (`validFrom <= asOf` y, si hay cierre,
+ * `validUntil > asOf`).
+ */
+export declare function isValidAt(record: MemoryRecord, asOf: number): boolean;
+/** Recuperable bitemporalmente en `asOf` (ambas dimensiones activas). */
+export declare function isActiveAt(record: MemoryRecord, asOf: number): boolean;
+/** Filtra los records recuperables en `asOf`. Orden de entrada preservado. */
+export declare function filterActive<T extends MemoryRecord>(records: readonly T[], asOf: number): T[];
+/**
+ * Fusiona dos ventanas de valid-time al re-afirmar un record: se toma el
+ * `validFrom` más temprano y el `validUntil` más amplio (`null` = abierto, gana).
+ */
+export declare function coalesceWindow(a: {
+    validFrom: number;
+    validUntil: number | null;
+}, b: {
+    validFrom: number;
+    validUntil: number | null;
+}): {
+    validFrom: number;
+    validUntil: number | null;
+};
+//# sourceMappingURL=temporal.d.ts.map

package/dist/memory/temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../../src/memory/temporal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;GAOG;AAEH;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAKrE;AAED,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,SAAS,YAAY,EACjD,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,IAAI,EAAE,MAAM,GACX,CAAC,EAAE,CAEL;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACnD,CAAC,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAClD;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAOlD"}