onbuzz 5.0.2 → 5.3.0

package/src/services/embeddings/__tests__/embeddingService.test.js

@@ -64,7 +64,7 @@ function makeService({ tmpDir, providerName = 'azure', dimensions = 4, configExt
   return { svc, stubProvider, apiKeyManager };
 }
 
-describe('EmbeddingService — disabled by default', () => {
+describe('EmbeddingService — enabled-by-default + disabled-state behaviour', () => {
   let tmpDir;
   beforeEach(async () => {
     tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-emb-svc-'));
@@ -73,44 +73,43 @@ describe('EmbeddingService — disabled by default', () => {
     await fsp.rm(tmpDir, { recursive: true, force: true });
   });
 
-  test('no config → disabled', () => {
+  // Disabled state is now OPT-IN (default is local). Build a service with the
+  // provider explicitly disabled to exercise the disabled-state guards.
+  const makeDisabled = () => new EmbeddingService({
+    config: { provider: 'disabled' },
+    apiKeyManager: { getEmbeddingApiKey: () => null },
+    baseUrl: 'https://x',
+    stateDir: tmpDir,
+  });
+
+  test('no config → enabled (local provider is the default)', () => {
     const svc = new EmbeddingService({
       apiKeyManager: { getEmbeddingApiKey: () => null },
       baseUrl: 'https://x',
       stateDir: tmpDir,
     });
-    expect(svc.isEnabled).toBe(false);
+    expect(svc.isEnabled).toBe(true);
+    expect(svc.config.provider).toBe('local');
+  });
+
+  test('explicitly disabled → isEnabled false', () => {
+    expect(makeDisabled().isEnabled).toBe(false);
   });
 
   test('disabled state: embedQuery throws NOT_INITIALIZED', async () => {
-    const svc = new EmbeddingService({
-      apiKeyManager: { getEmbeddingApiKey: () => null },
-      baseUrl: 'https://x',
-      stateDir: tmpDir,
-    });
-    await expect(svc.embedQuery('hi')).rejects.toMatchObject({
+    await expect(makeDisabled().embedQuery('hi')).rejects.toMatchObject({
       code: EMBEDDING_ERROR_CODES.NOT_INITIALIZED,
     });
   });
 
   test('disabled state: health() returns ok:false with reason', async () => {
-    const svc = new EmbeddingService({
-      apiKeyManager: { getEmbeddingApiKey: () => null },
-      baseUrl: 'https://x',
-      stateDir: tmpDir,
-    });
-    const h = await svc.health();
+    const h = await makeDisabled().health();
     expect(h.ok).toBe(false);
     expect(h.reason).toMatch(/disabled/i);
   });
 
   test('disabled state: getStore throws', async () => {
-    const svc = new EmbeddingService({
-      apiKeyManager: { getEmbeddingApiKey: () => null },
-      baseUrl: 'https://x',
-      stateDir: tmpDir,
-    });
-    await expect(svc.getStore({ agentId: 'a1', surface: 'memory' })).rejects.toThrow(/disabled/i);
+    await expect(makeDisabled().getStore({ agentId: 'a1', surface: 'memory' })).rejects.toThrow(/disabled/i);
   });
 });
 
@@ -335,7 +334,10 @@ describe('EmbeddingService — warmup', () => {
   });
 
   test('warmup is a no-op when disabled', async () => {
+    // Must pass provider:'disabled' explicitly now that local is the default —
+    // otherwise warmup would try to load the real model (slow + flaky).
     const svc = new EmbeddingService({
+      config: { provider: 'disabled' },
       apiKeyManager: { getEmbeddingApiKey: () => null },
       baseUrl: 'https://x',
       stateDir: tmpDir,
@@ -364,7 +366,7 @@ describe('EmbeddingService — config persistence (Settings UI path)', () => {
     expect(first.config.provider).toBe('azure');
 
     const second = makeSvc();
-    expect(second.config.provider).toBe('disabled');     // default before load
+    expect(second.config.provider).toBe('local');        // default before load
     const loaded = await second.loadPersistedConfig();
     expect(loaded).toBe(true);
     expect(second.config.provider).toBe('azure');
@@ -378,14 +380,14 @@ describe('EmbeddingService — config persistence (Settings UI path)', () => {
     const second = makeSvc();
     const loaded = await second.loadPersistedConfig();
     expect(loaded).toBe(false);                              // nothing on disk
-    expect(second.config.provider).toBe('disabled');
+    expect(second.config.provider).toBe('local');           // falls back to the default
   });
 
   test('loadPersistedConfig is graceful when the file is missing', async () => {
     const svc = makeSvc();
     const loaded = await svc.loadPersistedConfig();
     expect(loaded).toBe(false);
-    expect(svc.config.provider).toBe('disabled');
+    expect(svc.config.provider).toBe('local');
   });
 
   test('loadPersistedConfig is graceful with corrupt JSON', async () => {
@@ -395,7 +397,7 @@ describe('EmbeddingService — config persistence (Settings UI path)', () => {
     const svc = makeSvc();
     const loaded = await svc.loadPersistedConfig();
     expect(loaded).toBe(false);                              // ignored
-    expect(svc.config.provider).toBe('disabled');            // safe default
+    expect(svc.config.provider).toBe('local');               // safe default
   });
 
   test('persist uses atomic .tmp + rename (no partial file on disk after success)', async () => {
@@ -415,3 +417,146 @@ describe('EmbeddingService — config persistence (Settings UI path)', () => {
     await expect(fsp.access(file)).rejects.toMatchObject({ code: 'ENOENT' });
   });
 });
+
+describe('EmbeddingService — memory-activity hub (live memory-path view)', () => {
+  let tmpDir;
+  beforeEach(async () => { tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-emb-mem-')); });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  const stats = { considered: 5, passed: 3, injected: 2, tokens: 120 };
+
+  test('recordRecallActivity caches per-agent entry and emits "recall"', () => {
+    const { svc } = makeService({ tmpDir });
+    const seen = [];
+    svc.memoryActivity.on('recall', (e) => seen.push(e));
+    const entry = svc.recordRecallActivity('a1', stats, [{ id: 'm1', title: 't', score: 0.9 }]);
+    expect(entry).toMatchObject({ agentId: 'a1', considered: 5, passed: 3, injected: 2, tokens: 120 });
+    expect(entry.items).toHaveLength(1);
+    expect(typeof entry.at).toBe('string');
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toBe(entry);
+  });
+
+  test('recordRecallActivity returns null on invalid input', () => {
+    const { svc } = makeService({ tmpDir });
+    expect(svc.recordRecallActivity('', stats)).toBeNull();
+    expect(svc.recordRecallActivity('a1', null)).toBeNull();
+    expect(svc.recordRecallActivity('a1', 'nope')).toBeNull();
+  });
+
+  test('recordRecallActivity coerces missing/non-numeric stats to 0 and caps items', () => {
+    const { svc } = makeService({ tmpDir });
+    const many = Array.from({ length: 25 }, (_, i) => ({ id: `m${i}` }));
+    const entry = svc.recordRecallActivity('a1', { considered: 'x' }, many);
+    expect(entry).toMatchObject({ considered: 0, passed: 0, injected: 0, tokens: 0 });
+    expect(entry.items).toHaveLength(10); // capped
+  });
+
+  test('non-array injected → empty items', () => {
+    const { svc } = makeService({ tmpDir });
+    const entry = svc.recordRecallActivity('a1', stats, 'not-an-array');
+    expect(entry.items).toEqual([]);
+  });
+
+  test('a listener that throws does not propagate', () => {
+    const { svc } = makeService({ tmpDir });
+    svc.memoryActivity.on('recall', () => { throw new Error('boom'); });
+    expect(() => svc.recordRecallActivity('a1', stats)).not.toThrow();
+  });
+
+  test('cache is bounded (oldest agent evicted past cap)', () => {
+    const { svc } = makeService({ tmpDir });
+    for (let i = 0; i < 510; i++) svc.recordRecallActivity(`agent-${i}`, stats);
+    expect(svc._lastRecallByAgent.size).toBeLessThanOrEqual(500);
+    expect(svc._lastRecallByAgent.has('agent-0')).toBe(false); // oldest gone
+    expect(svc._lastRecallByAgent.has('agent-509')).toBe(true);
+  });
+
+  test('getMemoryStatus (enabled): embeddings info + per-surface counts + lastRecall', async () => {
+    const { svc } = makeService({ tmpDir });
+    // Seed one document-surface vector so a count is non-zero.
+    const store = await svc.getStore({ agentId: 'a1', surface: 'memory' });
+    await store.upsert('m1', Float32Array.from([0.1, 0.2, 0.3, 0.4]), { text: 'hi' });
+    svc.recordRecallActivity('a1', stats);
+
+    const status = await svc.getMemoryStatus('a1');
+    expect(status.embeddings.enabled).toBe(true);
+    expect(status.embeddings.model).toBe('stub-model');
+    expect(status.embeddings.dimensions).toBe(4);
+    expect(status.surfaces.memory).toBe(1);
+    expect(status.surfaces.reminisce).toBe(0);
+    expect(status.surfaces.documents).toBe(0);
+    expect(status.lastRecall).toMatchObject({ agentId: 'a1', injected: 2 });
+  });
+
+  test('getMemoryStatus (disabled): reports disabled, no surfaces, null lastRecall', async () => {
+    const svc = new EmbeddingService({
+      config: { provider: 'disabled' },
+      apiKeyManager: { getEmbeddingApiKey: () => null },
+      baseUrl: 'https://x', stateDir: tmpDir,
+    });
+    const status = await svc.getMemoryStatus('a1');
+    expect(status.embeddings.enabled).toBe(false);
+    expect(status.surfaces).toEqual({});
+    expect(status.lastRecall).toBeNull();
+  });
+
+  test('getMemoryStatus (no agentId): no surface reads', async () => {
+    const { svc } = makeService({ tmpDir });
+    const status = await svc.getMemoryStatus('');
+    expect(status.surfaces).toEqual({});
+  });
+
+  test('getMemoryStatus surfaces provider getInfo failure without throwing', async () => {
+    const { svc, stubProvider } = makeService({ tmpDir });
+    stubProvider.getInfo = () => { throw new Error('info-fail'); };
+    const status = await svc.getMemoryStatus('a1');
+    expect(status.embeddings.error).toMatch(/info-fail/);
+  });
+});
+
+describe('EmbeddingService — warmupInBackground (auto pre-load)', () => {
+  let tmpDir;
+  beforeEach(async () => { tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-emb-warm-')); });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  function makeLocal({ providerImpl } = {}) {
+    const provider = providerImpl || { getInfo: () => ({ name: 'local', modelId: 'm', dimensions: 4 }), getModelFingerprint: () => 'local:fp', warmup: vi => {} };
+    return new EmbeddingService({
+      config: { provider: 'local' },
+      apiKeyManager: { getEmbeddingApiKey: () => null },
+      baseUrl: 'https://x', stateDir: tmpDir,
+      providerOverrides: { local: () => provider },
+    });
+  }
+
+  test('local provider → calls provider.warmup()', async () => {
+    const warmup = jest.fn(async () => {});
+    const provider = { getInfo: () => ({ name: 'local', modelId: 'm', dimensions: 4 }), getModelFingerprint: () => 'fp', warmup };
+    const svc = makeLocal({ providerImpl: provider });
+    await svc.warmupInBackground();
+    expect(warmup).toHaveBeenCalledTimes(1);
+  });
+
+  test('non-local provider → no-op (no provider build)', async () => {
+    const { svc, stubProvider } = makeService({ tmpDir, providerName: 'azure' });
+    stubProvider.warmup = jest.fn(async () => {});
+    await svc.warmupInBackground();
+    expect(stubProvider.warmup).not.toHaveBeenCalled();
+  });
+
+  test('disabled → no-op', async () => {
+    const svc = new EmbeddingService({
+      config: { provider: 'disabled' },
+      apiKeyManager: { getEmbeddingApiKey: () => null },
+      baseUrl: 'https://x', stateDir: tmpDir,
+    });
+    await expect(svc.warmupInBackground()).resolves.toBeUndefined();
+  });
+
+  test('never rejects even if warmup throws (best-effort)', async () => {
+    const provider = { getInfo: () => ({ name: 'local', modelId: 'm', dimensions: 4 }), getModelFingerprint: () => 'fp', warmup: async () => { throw new Error('load failed'); } };
+    const svc = makeLocal({ providerImpl: provider });
+    await expect(svc.warmupInBackground()).resolves.toBeUndefined();
+  });
+});

package/src/services/embeddings/__tests__/embeddingsConfig.test.js

@@ -14,14 +14,31 @@ import {
 } from '../embeddingsConfig.js';
 
 describe('DEFAULT_CONFIG', () => {
-  test('starts disabled', () => {
-    expect(DEFAULT_CONFIG.provider).toBe('disabled');
+  test('defaults to the local provider (embeddings on, no key/cost)', () => {
+    expect(DEFAULT_CONFIG.provider).toBe('local');
+  });
+
+  test('a user can still disable embeddings in settings', () => {
+    expect(mergeConfig({ provider: 'disabled' }).provider).toBe('disabled');
   });
 
   test('default local model is nomic-embed-text-v1 (the anonymously-fetchable nomic-ai namespace)', () => {
     expect(DEFAULT_CONFIG.local.modelId).toBe('nomic-ai/nomic-embed-text-v1');
   });
 
+  test('auto-recall is ON by default and includes the documents surface', () => {
+    expect(DEFAULT_CONFIG.autoRecall.enabled).toBe(true);
+    expect(DEFAULT_CONFIG.autoRecall.surfaces).toEqual(
+      expect.arrayContaining(['memory', 'reminisce', 'documents']),
+    );
+  });
+
+  test('a user can disable auto-recall in settings (override wins over the default)', () => {
+    const merged = mergeConfig({ autoRecall: { enabled: false } });
+    expect(merged.autoRecall.enabled).toBe(false);          // explicit false survives the merge
+    expect(merged.autoRecall.surfaces).toContain('documents'); // unrelated defaults preserved
+  });
+
   test('default cloud model is text-embedding-3-small (both providers)', () => {
     expect(DEFAULT_CONFIG.azure.modelId).toBe('text-embedding-3-small');
     expect(DEFAULT_CONFIG.openai.modelId).toBe('text-embedding-3-small');
@@ -82,7 +99,7 @@ describe('mergeConfig / validateConfig — azure-custom', () => {
 
 describe('mergeConfig', () => {
   test('null user config → defaults', () => {
-    expect(mergeConfig(null).provider).toBe('disabled');
+    expect(mergeConfig(null).provider).toBe('local');
     expect(mergeConfig(undefined).local.modelId).toBe('nomic-ai/nomic-embed-text-v1');
   });
 
@@ -123,7 +140,7 @@ describe('mergeConfig', () => {
     const m = mergeConfig({});
     expect(() => { m.provider = 'azure'; }).not.toThrow();
     // The frozen DEFAULT_CONFIG must NOT be mutated through the merge.
-    expect(DEFAULT_CONFIG.provider).toBe('disabled');
+    expect(DEFAULT_CONFIG.provider).toBe('local');
   });
 });
 
@@ -198,3 +215,16 @@ describe('estimateTokens', () => {
     expect(estimateTokens('a'.repeat(5))).toBe(2);
   });
 });
+
+describe('DEFAULT_CONFIG — autoRecall threshold (Q→fact recall calibration)', () => {
+  test('default recall threshold is 0.5 (lowered from 0.78; measured nomic Q→fact ~0.5)', () => {
+    // Regression pin: a question vs the statement that answers it scores ~0.5
+    // with nomic, so the gate must sit below that. If this default changes,
+    // make it deliberate.
+    expect(DEFAULT_CONFIG.autoRecall.threshold).toBe(0.5);
+  });
+
+  test('a user-supplied threshold still overrides the default', () => {
+    expect(mergeConfig({ autoRecall: { threshold: 0.7 } }).autoRecall.threshold).toBe(0.7);
+  });
+});

package/src/services/embeddings/__tests__/inMemoryJsonStore.test.js

@@ -166,6 +166,51 @@ describe('InMemoryJsonStore — substring matches', () => {
   });
 });
 
+// AR3: raw cosine exposed as `similarity` independently of the ranking score.
+describe('InMemoryJsonStore — similarity (raw cosine) exposure', () => {
+  let tmpDir, store;
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-vec-sim-'));
+    store = new InMemoryJsonStore({
+      filePath: path.join(tmpDir, 'store.vec.json'),
+      dimensions: 2, modelFingerprint: 'test:fp',
+    });
+    await store.load();
+  });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('query() exposes similarity = raw cosine; equals score when no scoring', async () => {
+    await store.upsert('a', Float32Array.from([1, 0]), { text: 'x' });
+    const [hit] = await store.query(Float32Array.from([1, 0]), { topK: 1 });
+    expect(hit.similarity).toBeCloseTo(1, 6);
+    expect(hit.similarity).toBe(hit.score); // identity scorer → equal
+  });
+
+  test('query() keeps raw similarity even when scoring damps the score', async () => {
+    await store.upsert('a', Float32Array.from([1, 0]), { text: 'x' });
+    const halve = (base) => base * 0.5; // stand-in for recency damping
+    const [hit] = await store.query(Float32Array.from([1, 0]), { topK: 1, scoring: halve });
+    expect(hit.similarity).toBeCloseTo(1, 6); // raw cosine preserved
+    expect(hit.score).toBeCloseTo(0.5, 6);    // ranking score damped
+  });
+
+  test('hybridQuery() carries raw similarity through fusion (high for aligned, ~0 for orthogonal)', async () => {
+    await store.upsertBatch([
+      { id: 'sem', vector: Float32Array.from([1, 0]), metadata: { text: 'unrelated' } },
+      { id: 'sub', vector: Float32Array.from([0, 1]), metadata: { text: 'apple pie' } },
+    ]);
+    // Query aligns with 'sem' (cosine 1) and text-matches 'sub' only.
+    const hits = await store.hybridQuery(Float32Array.from([1, 0]), 'apple');
+    const sem = hits.find(h => h.id === 'sem');
+    const sub = hits.find(h => h.id === 'sub');
+    expect(sem.similarity).toBeCloseTo(1, 6);
+    // 'sub' is orthogonal (cosine 0) — it IS in the semantic candidate set, so
+    // its similarity is 0, not undefined. A row absent from the semantic set
+    // would be undefined; here both rows are scored semantically.
+    expect(sub.similarity).toBeCloseTo(0, 6);
+  });
+});
+
 describe('InMemoryJsonStore — drift recovery', () => {
   let tmpDir, filePath;
 

package/src/services/embeddings/autoRecall.js

@@ -72,7 +72,9 @@ import { estimateTokens } from './embeddingsConfig.js';
  *        last K turns concatenated — caller's choice).
  * @param {object} [opts]            - Config overrides; merged over
  *        the org default `autoRecall` block. Useful for per-agent overrides.
- * @returns {Promise<{enabled: boolean, items: RecallItem[], reason?: string}>}
+ * @returns {Promise<{enabled: boolean, items: RecallItem[], reason?: string,
+ *   stats?: {considered: number, passed: number, injected: number, tokens: number}}>}
+ *   `stats` is present on the enabled path (telemetry for the memory-path view).
  */
 export async function recallForPrompt(deps, agentId, recentText, opts = {}) {
   if (!deps || typeof deps.getIndexers !== 'function' || typeof deps.getConfig !== 'function') {
@@ -88,11 +90,11 @@ export async function recallForPrompt(deps, agentId, recentText, opts = {}) {
     return { enabled: false, items: [], reason: 'disabled' };
   }
 
-  const threshold = Number.isFinite(autoCfg.threshold) ? autoCfg.threshold : 0.78;
+  const threshold = Number.isFinite(autoCfg.threshold) ? autoCfg.threshold : 0.5;
   const topK = Number.isInteger(autoCfg.topK) && autoCfg.topK > 0 ? autoCfg.topK : 3;
   const maxTokens = Number.isFinite(autoCfg.maxTokens) && autoCfg.maxTokens > 0 ? autoCfg.maxTokens : 400;
   const surfaces = Array.isArray(autoCfg.surfaces) && autoCfg.surfaces.length > 0
-    ? autoCfg.surfaces : ['memory', 'reminisce'];
+    ? autoCfg.surfaces : ['memory', 'reminisce', 'documents'];
 
   const indexers = deps.getIndexers() || {};
 
@@ -113,11 +115,24 @@ export async function recallForPrompt(deps, agentId, recentText, opts = {}) {
     }
   }
 
-  if (candidates.length === 0) return { enabled: true, items: [] };
+  if (candidates.length === 0) {
+    return { enabled: true, items: [], stats: { considered: 0, passed: 0, injected: 0, tokens: 0 } };
+  }
 
-  // Threshold + sort + dedup-by-id + token-budget trim.
+  // Gate on RELEVANCE, rank on the SCORE.
+  //   - relevance = raw cosine (`similarity`). This is what the 0.78 cutoff
+  //     was calibrated against. Gating here (not on `score`) means an
+  //     old-but-relevant item that recency has damped, OR a hybrid hit whose
+  //     `score` is an RRF rank-fusion value on a different scale, still
+  //     surfaces when it's genuinely on-topic. This is what lets the far past
+  //     auto-resurface (AR3).
+  //   - ranking = `score` (recency/access-adjusted or RRF-fused) decides ORDER
+  //     among the survivors, so fresher/more-used items lead.
+  //   - back-compat: callers that only set `score` (cosine-scale, no hybrid)
+  //     fall back to gating on `score`.
+  const relevanceOf = (c) => (Number.isFinite(c.similarity) ? c.similarity : c.score);
   const passing = candidates
-    .filter(c => Number.isFinite(c.score) && c.score >= threshold)
+    .filter(c => Number.isFinite(relevanceOf(c)) && relevanceOf(c) >= threshold)
     .sort((a, b) => b.score - a.score);
 
   const seen = new Set();
@@ -143,7 +158,17 @@ export async function recallForPrompt(deps, agentId, recentText, opts = {}) {
     if (items.length >= topK) break;
   }
 
-  return { enabled: true, items };
+  // Telemetry (data already computed) for the live memory-path view. The
+  // shape mirrors the funnel: how many candidates were considered, how many
+  // cleared the relevance gate, how many were actually injected, and the
+  // token cost. Surfaced by aiService → embeddingService → web-ui.
+  const stats = {
+    considered: candidates.length,
+    passed: passing.length,
+    injected: items.length,
+    tokens: usedTokens,
+  };
+  return { enabled: true, items, stats };
 }
 
 /**
@@ -185,10 +210,23 @@ export function formatRecallSection(items) {
 function _normalizeHit(hit, source) {
   // MemoryIndexer hits: { id, score, metadata: {title, text, createdAt, ...} }
   // ReminisceIndexer hits: { messageId, score, chunkIndex, chunkText, metadata: {role, createdAt, text, ...} }
+  // DocumentIndexer hits: { docId, source(url), title, chunkIndex, lineStart, lineEnd, score, text } (flat)
+  if (source === 'documents') {
+    return {
+      id: `${hit.docId}#${hit.chunkIndex ?? 0}`,
+      score: hit.score,
+      similarity: hit.similarity,
+      source,
+      text: hit.text || '',
+      title: hit.title || hit.source || '',  // page title, else the URL
+      createdAt: hit.indexedAt,
+    };
+  }
   if (source === 'reminisce') {
     return {
       id: hit.messageId || hit.id,
       score: hit.score,
+      similarity: hit.similarity,
       source,
       text: hit.chunkText || hit.metadata?.text || '',
       role: hit.metadata?.role,
@@ -198,6 +236,7 @@ function _normalizeHit(hit, source) {
   return {
     id: hit.id,
     score: hit.score,
+    similarity: hit.similarity,
     source,
     text: hit.metadata?.text || hit.metadata?.title || '',
     title: hit.metadata?.title,

package/src/services/embeddings/embeddingService.js

@@ -26,6 +26,7 @@
 
 import path from 'path';
 import fsp from 'fs/promises';
+import { EventEmitter } from 'events';
 import {
   EmbeddingError,
   EMBEDDING_ERROR_CODES,
@@ -73,6 +74,15 @@ export class EmbeddingService {
       lastCallAt:   null,
     };
 
+    // Live memory-path telemetry hub. aiService publishes the per-turn
+    // auto-recall funnel here (`recordRecallActivity`); webServer subscribes
+    // and rebroadcasts to the web-ui over the existing websocket. Data is
+    // only ever PUBLISHED (never computed) here, so this adds no hot-path cost.
+    this.memoryActivity = new EventEmitter();
+    this.memoryActivity.setMaxListeners(0); // avoid the 10-listener warning
+    /** @type {Map<string, object>} agentId -> last recall entry (bounded). */
+    this._lastRecallByAgent = new Map();
+
     const v = validateConfig(this._config);
     if (!v.ok) {
       this._logger?.warn?.('[EmbeddingService] invalid config; using safe defaults', { errors: v.errors });
@@ -209,6 +219,22 @@ export class EmbeddingService {
     }
   }
 
+  /**
+   * Fire-and-forget warmup for app startup — loads the LOCAL model in the
+   * background so the user never has to click "pre-load model". No-op for
+   * cloud providers (nothing heavy to load) and when disabled. Never throws
+   * (errors are logged), and never blocks: callers should NOT await it.
+   *
+   * @returns {Promise<void>} resolves when warmup settles (exposed for tests).
+   */
+  warmupInBackground() {
+    if (!this.isEnabled || this._config.provider !== 'local') return Promise.resolve();
+    return Promise.resolve()
+      .then(() => this.warmup())
+      .then(() => this._logger?.info?.('[EmbeddingService] local embedding model pre-warmed'))
+      .catch((err) => this._logger?.warn?.('[EmbeddingService] background warmup failed', { error: err?.message }));
+  }
+
   /** Embed a single query. */
   async embedQuery(text) {
     this._assertEnabled();
@@ -351,6 +377,80 @@ export class EmbeddingService {
     return path.join(this._stateDir, 'embeddings', 'embeddings-config.json');
   }
 
+  /**
+   * Publish a per-turn auto-recall funnel for the live memory-path view.
+   * Caches the latest entry per agent (so the pull endpoint can show it
+   * without waiting for the next turn) and emits it for websocket rebroadcast.
+   * Best-effort: a listener throwing never propagates to the caller (the
+   * agent's turn must not be affected by telemetry).
+   *
+   * @param {string} agentId
+   * @param {{considered:number,passed:number,injected:number,tokens:number}} stats
+   * @param {Array<{id:string,title?:string,source?:string,score?:number}>} [injected]
+   * @returns {object|null} the recorded entry (null on invalid input).
+   */
+  recordRecallActivity(agentId, stats, injected = []) {
+    if (!agentId || !stats || typeof stats !== 'object') return null;
+    const entry = {
+      agentId,
+      considered: Number(stats.considered) || 0,
+      passed: Number(stats.passed) || 0,
+      injected: Number(stats.injected) || 0,
+      tokens: Number(stats.tokens) || 0,
+      items: Array.isArray(injected) ? injected.slice(0, 10) : [],
+      at: new Date().toISOString(),
+    };
+    // Bounded cache (insertion-ordered Map): drop the oldest agent past cap.
+    this._lastRecallByAgent.set(agentId, entry);
+    if (this._lastRecallByAgent.size > 500) {
+      const oldest = this._lastRecallByAgent.keys().next().value;
+      this._lastRecallByAgent.delete(oldest);
+    }
+    try {
+      this.memoryActivity.emit('recall', entry);
+    } catch (err) {
+      this._logger?.warn?.('[EmbeddingService] memoryActivity listener threw', { error: err?.message });
+    }
+    return entry;
+  }
+
+  /**
+   * Snapshot of the agent's memory path for the live Health/Activity strip:
+   * embeddings status, per-surface index sizes, and the last recall funnel.
+   * Cheap: store counts are O(1) in-memory reads (getInfo doesn't load the
+   * model; stores are cached after first use). Pull-path only — never on the
+   * agent's hot path.
+   *
+   * @param {string} agentId
+   * @returns {Promise<{embeddings: object, surfaces: object, lastRecall: object|null}>}
+   */
+  async getMemoryStatus(agentId) {
+    const embeddings = { enabled: this.isEnabled, provider: this._config.provider };
+    const surfaces = {};
+    if (this.isEnabled && agentId) {
+      try {
+        const info = this.getProvider().getInfo();
+        embeddings.model = info?.modelId;
+        embeddings.dimensions = info?.dimensions;
+      } catch (err) {
+        embeddings.error = err?.message;
+      }
+      for (const surface of ['memory', 'reminisce', 'documents']) {
+        try {
+          const store = await this.getStore({ agentId, surface });
+          surfaces[surface] = (await store.stats())?.count ?? 0;
+        } catch {
+          surfaces[surface] = null; // surface unavailable — don't fail the whole call
+        }
+      }
+    }
+    return {
+      embeddings,
+      surfaces,
+      lastRecall: this._lastRecallByAgent.get(agentId) || null,
+    };
+  }
+
   /** Read-only telemetry snapshot for the Settings cost dashboard. */
   getTelemetry() {
     const todayKey = isoDateKey(new Date());

package/src/services/embeddings/embeddingsConfig.js

@@ -24,7 +24,11 @@ import { DEFAULT_LOCAL_MODEL, LOCAL_MODELS } from './providers/localProvider.js'
 export const PROVIDERS = Object.freeze(['local', 'azure', 'openai', 'azure-custom', 'disabled']);
 
 export const DEFAULT_CONFIG = Object.freeze({
-  provider: 'disabled',
+  // Embeddings ON by default, using the LOCAL provider (no API key, no cost,
+  // private). The default local model is the highest-dimension / best-fit
+  // option (nomic-embed-text-v1, 768-dim, 8K context — vs 384-dim BGE/MiniLM).
+  // Lazy-loaded on first embed; users can switch provider/model in Settings.
+  provider: 'local',
 
   local: Object.freeze({
     modelId: DEFAULT_LOCAL_MODEL,
@@ -77,11 +81,17 @@ export const DEFAULT_CONFIG = Object.freeze({
   // budget — see the Phase 6 design document and the Mem0 / ChatGPT
   // memory reference shapes.
   autoRecall: Object.freeze({
-    enabled: false,         // opt-in; the explicit semantic-search action remains the primary path
-    threshold: 0.78,        // cosine cutoff — items below this are not injected
+    enabled: true,          // proactive recall ON by default; users can disable in Settings (the explicit semantic-search action also remains available)
+    // Cosine cutoff — items below this are not injected. Lowered from 0.78:
+    // measured nomic scores for a question vs the statement that answers it
+    // (e.g. "what's my name?" vs "My name is Daniel.") land ~0.5, well below
+    // 0.78, so the old gate blocked legitimate Q→fact recall. 0.5 clears that
+    // while staying far above the unrelated-noise floor (~0.28). Tunable.
+    threshold: 0.5,
     topK: 3,                // max items per turn
     maxTokens: 400,         // hard cap on total recalled token budget per turn
-    surfaces: Object.freeze(['memory', 'reminisce']),  // which pools to recall from
+    surfaces: Object.freeze(['memory', 'reminisce', 'documents']),  // pools to recall from (documents = offloaded web/file content)
+    sharedUserMemory: false, // when true, every agent ALSO recalls a single shared user-memory store (facts about the user, saved via memory.add { shared: true }); off = each agent isolated
   }),
 });
 

package/src/services/embeddings/indexers/__tests__/agentIndexer.test.js

@@ -48,7 +48,7 @@ class StubProvider extends EmbeddingProvider {
 function makeIndexer({ tmpDir, enabled = true } = {}) {
   const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
   if (!enabled) {
-    const svc = new EmbeddingService({ apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir });
+    const svc = new EmbeddingService({ config: { provider: 'disabled' }, apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir });
     return { indexer: new AgentIndexer({ embeddingService: svc }), svc };
   }
   const provider = new StubProvider();

package/src/services/embeddings/indexers/__tests__/composioIndexer.test.js

@@ -51,7 +51,7 @@ class StubProvider extends EmbeddingProvider {
 function makeIndexer({ tmpDir, enabled = true } = {}) {
   const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
   if (!enabled) {
-    const svc = new EmbeddingService({ apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir });
+    const svc = new EmbeddingService({ config: { provider: 'disabled' }, apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir });
     return { indexer: new ComposioIndexer({ embeddingService: svc }), svc };
   }
   const provider = new StubProvider();