agent-working-memory 0.11.0 → 0.12.3

package/src/core/embeddings.ts

@@ -19,6 +19,7 @@
 
 import { pipeline, type FeatureExtractionPipeline } from '@huggingface/transformers';
 import { dispatchEmbed, registerInProcessHandlers } from './ml-worker.js';
+import { noteModelLoad } from './write-telemetry.js';
 
 const MODEL_ID = process.env.AWM_EMBED_MODEL ?? 'Xenova/bge-small-en-v1.5';
 const DIMENSIONS = parseInt(process.env.AWM_EMBED_DIMS ?? '384', 10);
@@ -32,9 +33,11 @@ let inProcessInitPromise: Promise<FeatureExtractionPipeline> | null = null;
 async function loadInProcess(): Promise<FeatureExtractionPipeline> {
   if (inProcessInstance) return inProcessInstance;
   if (inProcessInitPromise) return inProcessInitPromise;
+  const tLoadStart = performance.now();
   inProcessInitPromise = pipeline('feature-extraction', MODEL_ID, { dtype: 'fp32' }).then(pipe => {
     inProcessInstance = pipe;
-    console.log(`Embedding model loaded in-process: ${MODEL_ID} (${DIMENSIONS}d)`);
+    noteModelLoad(performance.now() - tLoadStart);
+    console.error(`Embedding model loaded in-process: ${MODEL_ID} (${DIMENSIONS}d)`);
     return pipe;
   });
   return inProcessInitPromise;

package/src/core/entity-extract.ts

@@ -0,0 +1,47 @@
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Entity extraction for the entity inverted index (D9, 2026-07-30).
+ *
+ * v1 is deliberately conservative for precision: entities come ONLY from
+ * structured sources — prefix tags (`person=Seetha`, `ticket=18999`) and
+ * auto-tagger `entity:` tags — never from free-text guessing. Each entity is
+ * normalized to `key:value` lowercase so lookups are exact.
+ *
+ * This is pure write-time bookkeeping. Retrieval behavior is unchanged until
+ * D11 re-tests the graph features against the index (per the 2026-06-16
+ * entity-centric retrieval roadmap).
+ */
+
+/** Prefix-tag keys whose values denote entities worth indexing. */
+const ENTITY_KEYS = new Set([
+  'person', 'ticket', 'member', 'horse', 'usef', 'event', 'proj', 'project',
+  'skill', 'about', 'file', 'sp', 'table', 'agent', 'version', 'org',
+]);
+
+/** Extract normalized `key:value` entities from a tag list. Deduped, order-stable. */
+export function extractEntitiesFromTags(tags: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of tags ?? []) {
+    const tag = String(raw).trim();
+    let entity: string | null = null;
+    const eq = tag.indexOf('=');
+    if (eq > 0) {
+      const key = tag.slice(0, eq).toLowerCase();
+      const value = tag.slice(eq + 1).trim().toLowerCase();
+      if (ENTITY_KEYS.has(key) && value.length > 0 && value.length <= 120) {
+        entity = `${key === 'project' ? 'proj' : key}:${value}`;
+      }
+    } else if (tag.toLowerCase().startsWith('entity:')) {
+      const value = tag.slice('entity:'.length).trim().toLowerCase();
+      if (value.length > 0 && value.length <= 120) entity = `entity:${value}`;
+    }
+    if (entity && !seen.has(entity)) {
+      seen.add(entity);
+      out.push(entity);
+    }
+  }
+  return out;
+}

package/src/core/format-recall.ts

@@ -0,0 +1,25 @@
+import type { ActivationResult } from '../types/engram.js';
+
+/**
+ * Formats one memory_recall result line for the MCP text response.
+ *
+ * Extracted out of the inline closure in mcp.ts (0.12.1) so the format itself
+ * — specifically, that every result carries its engram id — can be unit
+ * tested without booting the MCP server (mcp.ts has a top-level `await` and
+ * opens the store as a side effect of import, so it cannot be imported by a
+ * test directly).
+ *
+ * The id is placed right after the score, not at the end of the line: result
+ * bodies can be long, and a consumer scanning for `[id: ...]` shouldn't have
+ * to read past a paragraph of content to find it.
+ */
+export function formatRecallResultLine(r: ActivationResult, index: number): string {
+  const body = r.summary ?? r.engram.content;
+  const chain = r.engram.supersededBy
+    ? ` ⚠ SUPERSEDED by ${r.engram.supersededBy} — treat as historical; recall/fetch the successor before relying on this.`
+    : '';
+  const validity = r.engram.validTo
+    ? ` [valid until ${r.engram.validTo}]`
+    : '';
+  return `${index + 1}. **${r.engram.concept}** (${r.score.toFixed(3)}) [id: ${r.engram.id}]${validity}: ${body}${chain}`;
+}

package/src/core/query-expander.ts

@@ -30,7 +30,7 @@ async function loadInProcess(): Promise<Text2TextGenerationPipeline> {
   if (inProcessInitPromise) return inProcessInitPromise;
   inProcessInitPromise = pipeline('text2text-generation', MODEL_ID, { dtype: 'fp32' }).then(pipe => {
     inProcessInstance = pipe as Text2TextGenerationPipeline;
-    console.log(`Query expander loaded in-process: ${MODEL_ID}`);
+    console.error(`Query expander loaded in-process: ${MODEL_ID}`);
     return inProcessInstance;
   });
   return inProcessInitPromise;

package/src/core/reranker.ts

@@ -35,7 +35,7 @@ async function ensureLoaded(): Promise<void> {
   initPromise = (async () => {
     tokenizer = await AutoTokenizer.from_pretrained(MODEL_ID);
     model = await AutoModelForSequenceClassification.from_pretrained(MODEL_ID, { dtype: 'fp32' });
-    console.log(`Re-ranker model loaded in-process: ${MODEL_ID}`);
+    console.error(`Re-ranker model loaded in-process: ${MODEL_ID}`);
   })();
   return initPromise;
 }