onbuzz 4.9.0 → 4.9.1

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

@@ -0,0 +1,265 @@
+/**
+ * ComposioIndexer tests.
+ *
+ * Same pattern as memory/reminisce indexer tests: real EmbeddingService
+ * + InMemoryJsonStore against a tmp dir with a stub provider.
+ *
+ * Pins:
+ *   - GLOBAL scope (one shared store, not per-agent)
+ *   - composioActionToText pack order: displayName → description → [toolkit/slug]
+ *   - indexCatalog batches every (toolkit, action) pair into ONE embed call
+ *   - Re-running indexCatalog DROPS the prior index (full rebuild semantics)
+ *   - search filter by toolkitSlug narrows results
+ *   - search returns hits with metadata.inputSchema for downstream execute()
+ *   - Failures (fetch throws on one toolkit) increment failedToolkits, others succeed
+ *   - Disabled path returns clean structured results
+ */
+
+import { describe, test, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import os from 'os';
+import fsp from 'fs/promises';
+import path from 'path';
+import { ComposioIndexer, composioActionToText } from '../composioIndexer.js';
+import { EmbeddingService } from '../../embeddingService.js';
+import { EmbeddingProvider } from '../../providerInterface.js';
+
+class StubProvider extends EmbeddingProvider {
+  constructor(dimensions = 8) {
+    super();
+    this._dimensions = dimensions;
+    this.calls = [];
+  }
+  getInfo() {
+    return {
+      name: 'azure', modelId: 'stub-composio', dimensions: this._dimensions,
+      maxBatchSize: 64, maxTokensPerText: 1000,
+      distinguishesQueryAndDocument: false, isLocal: false,
+    };
+  }
+  getModelFingerprint() { return 'stub-composio:v1'; }
+  async _embed(texts) {
+    this.calls.push({ texts: [...texts] });
+    return texts.map(t => {
+      const vec = Array(this._dimensions).fill(0);
+      vec[(t.charCodeAt(0) || 0) % this._dimensions] = 1;
+      vec[(t.charCodeAt(t.length - 1) || 0) % this._dimensions] += 0.5;
+      return vec;
+    });
+  }
+}
+
+function makeIndexer({ tmpDir, enabled = true } = {}) {
+  const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
+  if (!enabled) {
+    const svc = new EmbeddingService({ apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir });
+    return { indexer: new ComposioIndexer({ embeddingService: svc }), svc };
+  }
+  const provider = new StubProvider();
+  const svc = new EmbeddingService({
+    config: { provider: 'azure' },
+    apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir,
+    providerOverrides: { azure: () => provider },
+  });
+  return { indexer: new ComposioIndexer({ embeddingService: svc }), svc, provider };
+}
+
+const slackToolkit  = { slug: 'slack',  name: 'Slack'  };
+const githubToolkit = { slug: 'github', name: 'GitHub' };
+const notionToolkit = { slug: 'notion', name: 'Notion' };
+
+const slackActions = [
+  { slug: 'SLACK_SEND_MESSAGE',         displayName: 'Send a message',     description: 'Post a message to a channel.',     inputSchema: { type: 'object', properties: {} } },
+  { slug: 'SLACK_SEND_DM',              displayName: 'Send a direct message', description: 'Direct-message a Slack user.', inputSchema: { type: 'object', properties: {} } },
+  { slug: 'SLACK_LIST_CHANNELS',        displayName: 'List channels',      description: 'List all channels in the workspace.', inputSchema: { type: 'object', properties: {} } },
+];
+const githubActions = [
+  { slug: 'GITHUB_CREATE_ISSUE',        displayName: 'Create issue',       description: 'Open a new issue on a repository.',     inputSchema: {} },
+  { slug: 'GITHUB_LIST_REPOS',          displayName: 'List repositories',  description: 'List repositories owned by the authenticated user.', inputSchema: {} },
+];
+const notionActions = [
+  { slug: 'NOTION_CREATE_PAGE',         displayName: 'Create a page',      description: 'Create a new Notion page.', inputSchema: {} },
+];
+
+function makeFetcher() {
+  return jest.fn(async (toolkitSlug) => {
+    if (toolkitSlug === 'slack')  return slackActions;
+    if (toolkitSlug === 'github') return githubActions;
+    if (toolkitSlug === 'notion') return notionActions;
+    return [];
+  });
+}
+
+describe('composioActionToText', () => {
+  test('pack order: displayName → description → [toolkit/slug]', () => {
+    const text = composioActionToText('slack', slackActions[0]);
+    const di = text.indexOf('Send a message');
+    const de = text.indexOf('Post a message');
+    const tag = text.indexOf('[slack/SLACK_SEND_MESSAGE]');
+    expect(di).toBeGreaterThanOrEqual(0);
+    expect(de).toBeGreaterThan(di);
+    expect(tag).toBeGreaterThan(de);
+  });
+
+  test('skips missing fields without leaving blank lines', () => {
+    const text = composioActionToText('slack', { slug: 'X' });
+    expect(text).toBe('[slack/X]');
+  });
+
+  test('null action → empty string', () => {
+    expect(composioActionToText('slack', null)).toBe('');
+  });
+});
+
+describe('ComposioIndexer — disabled path', () => {
+  let tmpDir;
+  beforeEach(async () => { tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-cidx-')); });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('indexCatalog returns ok:false / reason:"disabled"', async () => {
+    const { indexer } = makeIndexer({ tmpDir, enabled: false });
+    const r = await indexer.indexCatalog([slackToolkit], makeFetcher());
+    expect(r).toEqual({
+      ok: false, reason: 'disabled',
+      indexedActions: 0, indexedToolkits: 0, failedToolkits: 0, skipped: 0,
+    });
+  });
+
+  test('search returns enabled:false', async () => {
+    const { indexer } = makeIndexer({ tmpDir, enabled: false });
+    const r = await indexer.search('hello');
+    expect(r).toEqual({ enabled: false, hits: [] });
+  });
+
+  test('stats returns enabled:false / count:0', async () => {
+    const { indexer } = makeIndexer({ tmpDir, enabled: false });
+    expect(await indexer.stats()).toEqual({ count: 0, enabled: false });
+  });
+});
+
+describe('ComposioIndexer — indexCatalog', () => {
+  let tmpDir, indexer, provider;
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-cidx-'));
+    ({ indexer, provider } = makeIndexer({ tmpDir }));
+  });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('walks all toolkits, batches every action into ONE embed call', async () => {
+    const r = await indexer.indexCatalog([slackToolkit, githubToolkit, notionToolkit], makeFetcher());
+    expect(r.ok).toBe(true);
+    expect(r.indexedActions).toBe(6);   // 3 + 2 + 1
+    expect(r.indexedToolkits).toBe(3);
+    expect(provider.calls).toHaveLength(1);
+    expect(provider.calls[0].texts).toHaveLength(6);
+  });
+
+  test('toolkit fetch failure counts as failed, others succeed', async () => {
+    const fetcher = jest.fn(async (slug) => {
+      if (slug === 'github') throw new Error('rate-limited');
+      if (slug === 'slack')  return slackActions;
+      if (slug === 'notion') return notionActions;
+      return [];
+    });
+    const r = await indexer.indexCatalog([slackToolkit, githubToolkit, notionToolkit], fetcher);
+    expect(r.ok).toBe(true);
+    expect(r.indexedActions).toBe(slackActions.length + notionActions.length);
+    expect(r.indexedToolkits).toBe(2);
+    expect(r.failedToolkits).toBe(1);
+  });
+
+  test('empty toolkit list → reason:"no-toolkits"', async () => {
+    const r = await indexer.indexCatalog([], makeFetcher());
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe('no-toolkits');
+  });
+
+  test('invalid fetcher → reason:"invalid-input"', async () => {
+    const r = await indexer.indexCatalog([slackToolkit], 'not-a-function');
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe('invalid-input');
+  });
+
+  test('full rebuild: re-indexing drops the prior store first', async () => {
+    await indexer.indexCatalog([slackToolkit, githubToolkit], makeFetcher());
+    const beforeCount = (await indexer.stats()).count;
+    expect(beforeCount).toBeGreaterThan(0);
+
+    // Re-index with only Slack; expect github actions to be gone.
+    await indexer.indexCatalog([slackToolkit], makeFetcher());
+    const afterCount = (await indexer.stats()).count;
+    expect(afterCount).toBe(slackActions.length);
+
+    const ghHit = await indexer.search('Create issue', { topK: 5 });
+    expect(ghHit.hits.find(h => h.actionSlug === 'GITHUB_CREATE_ISSUE')).toBeUndefined();
+  });
+
+  test('empty actions in every toolkit → indexes nothing but drops stale index', async () => {
+    // Seed something first.
+    await indexer.indexCatalog([slackToolkit], makeFetcher());
+    expect((await indexer.stats()).count).toBeGreaterThan(0);
+    // Now re-index with toolkits that return no actions.
+    const emptyFetcher = jest.fn(async () => []);
+    const r = await indexer.indexCatalog([slackToolkit], emptyFetcher);
+    expect(r.ok).toBe(true);
+    expect(r.indexedActions).toBe(0);
+    expect((await indexer.stats()).count).toBe(0);
+  });
+
+  test('embed batch failure → ok:false with error surfaced', async () => {
+    const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
+    class FailingProvider extends StubProvider {
+      async _embed() { throw new Error('rate-limited'); }
+    }
+    const svc = new EmbeddingService({
+      config: { provider: 'azure' },
+      apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir,
+      providerOverrides: { azure: () => new FailingProvider() },
+    });
+    const idx = new ComposioIndexer({ embeddingService: svc });
+    const r = await idx.indexCatalog([slackToolkit], makeFetcher());
+    expect(r.ok).toBe(false);
+    expect(r.error).toMatch(/rate-limited/);
+  });
+});
+
+describe('ComposioIndexer — search', () => {
+  let tmpDir, indexer;
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-cidx-'));
+    ({ indexer } = makeIndexer({ tmpDir }));
+    await indexer.indexCatalog([slackToolkit, githubToolkit, notionToolkit], makeFetcher());
+  });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('returns hits with toolkitSlug + actionSlug + displayName + description', async () => {
+    const r = await indexer.search('Send a direct message in Slack', { topK: 5 });
+    expect(r.enabled).toBe(true);
+    expect(r.hits.length).toBeGreaterThan(0);
+    const first = r.hits[0];
+    expect(first.toolkitSlug).toBeTruthy();
+    expect(first.actionSlug).toBeTruthy();
+    expect(first.displayName).toBeTruthy();
+    expect(first.metadata.inputSchema).toBeDefined();
+  });
+
+  test('toolkitSlug filter narrows scope to one toolkit', async () => {
+    const r = await indexer.search('list', { toolkitSlug: 'slack', topK: 10 });
+    expect(r.hits.every(h => h.toolkitSlug === 'slack')).toBe(true);
+  });
+
+  test('topK respected', async () => {
+    const r = await indexer.search('send message', { topK: 2 });
+    expect(r.hits).toHaveLength(2);
+  });
+
+  test('hybrid search surfaces substring-only hits', async () => {
+    // Query an action slug verbatim — hybrid should pull it via substring.
+    const r = await indexer.search('NOTION_CREATE_PAGE', { topK: 5 });
+    expect(r.hits.some(h => h.actionSlug === 'NOTION_CREATE_PAGE')).toBe(true);
+  });
+
+  test('empty query returns empty hits without throwing', async () => {
+    const r = await indexer.search('');
+    expect(r.hits).toEqual([]);
+  });
+});

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

@@ -0,0 +1,418 @@
+/**
+ * MemoryIndexer tests.
+ *
+ * Strategy: build a small EmbeddingService against the real VectorStore
+ * (in temp dir) with a stub provider that produces deterministic vectors
+ * based on text contents. Lets us exercise the FULL indexer path
+ * (embed → upsert → query → hybrid fusion) without any HTTP or ONNX.
+ *
+ * Pins:
+ *   - isEnabled reflects the underlying service
+ *   - indexOne / deleteOne / indexMany / backfill / search round-trip
+ *   - Failures from the underlying embed call are swallowed with a warn
+ *     (best-effort policy — memory writes never break)
+ *   - memoryToText packing order: title → description → content
+ *   - Empty / invalid memories are skipped (not failed)
+ *   - hybrid:true is the default and surfaces substring-only matches
+ */
+
+import { describe, test, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import os from 'os';
+import fsp from 'fs/promises';
+import path from 'path';
+import { MemoryIndexer, memoryToText } from '../memoryIndexer.js';
+import { EmbeddingService } from '../../embeddingService.js';
+import { EmbeddingProvider } from '../../providerInterface.js';
+
+/**
+ * Stub provider that produces deterministic, recognisable vectors so we
+ * can assert ordering by content. Each text gets a vector dominated by
+ * a "fingerprint" position derived from the text — different texts get
+ * different fingerprints so the inner-product ordering matches text
+ * identity.
+ */
+class StubProvider extends EmbeddingProvider {
+  constructor(dimensions = 8) {
+    super();
+    this._dimensions = dimensions;
+    this.calls = [];
+  }
+  getInfo() {
+    return {
+      name: 'azure',
+      modelId: 'stub-mem',
+      dimensions: this._dimensions,
+      maxBatchSize: 16,
+      maxTokensPerText: 1000,
+      distinguishesQueryAndDocument: false,
+      isLocal: false,
+    };
+  }
+  getModelFingerprint() { return 'stub-mem:v1'; }
+  async _embed(texts, kind) {
+    this.calls.push({ texts: [...texts], kind });
+    return texts.map(t => {
+      // Lay one nonzero element per text — position derived from the
+      // alphabetic content. Mixed-content texts get a unique fingerprint.
+      const idx = (t.charCodeAt(0) || 0) % this._dimensions;
+      const vec = Array(this._dimensions).fill(0);
+      vec[idx] = 1;
+      // Add a small tail so identical first-chars still differ.
+      vec[(idx + 1) % this._dimensions] = (t.length % 7) * 0.1;
+      return vec;
+    });
+  }
+}
+
+function makeIndexer({ tmpDir, enabled = true } = {}) {
+  const apiKeyManager = { getEmbeddingApiKey: jest.fn(() => 'stub-key') };
+  if (!enabled) {
+    const svc = new EmbeddingService({
+      apiKeyManager,
+      baseUrl: 'https://x',
+      stateDir: tmpDir,
+    });
+    return new MemoryIndexer({ embeddingService: svc });
+  }
+  const provider = new StubProvider();
+  const svc = new EmbeddingService({
+    config: { provider: 'azure' },
+    apiKeyManager,
+    baseUrl: 'https://x',
+    stateDir: tmpDir,
+    providerOverrides: { azure: () => provider },
+  });
+  return { indexer: new MemoryIndexer({ embeddingService: svc }), svc, provider };
+}
+
+describe('memoryToText', () => {
+  test('packs title → description → content', () => {
+    const t = memoryToText({ title: 'T', description: 'D', content: 'C' });
+    expect(t).toBe('T\n\nD\n\nC');
+  });
+
+  test('drops empty fields (no double newlines from missing pieces)', () => {
+    expect(memoryToText({ title: 'T', content: 'C' })).toBe('T\n\nC');
+    expect(memoryToText({ content: 'C' })).toBe('C');
+    expect(memoryToText({})).toBe('');
+    expect(memoryToText(null)).toBe('');
+  });
+});
+
+describe('MemoryIndexer — disabled path', () => {
+  let tmpDir;
+  beforeEach(async () => { tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-memidx-')); });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('isEnabled is false when service is disabled', () => {
+    const idx = makeIndexer({ tmpDir, enabled: false });
+    expect(idx.isEnabled).toBe(false);
+  });
+
+  test('indexOne returns {indexed:false, reason:"disabled"}', async () => {
+    const idx = makeIndexer({ tmpDir, enabled: false });
+    const r = await idx.indexOne('a1', { id: 'm1', title: 'hi' });
+    expect(r).toEqual({ indexed: false, reason: 'disabled' });
+  });
+
+  test('search returns {enabled:false, hits:[]}', async () => {
+    const idx = makeIndexer({ tmpDir, enabled: false });
+    const r = await idx.search('a1', 'hello');
+    expect(r).toEqual({ enabled: false, hits: [] });
+  });
+
+  test('backfill returns {ok:false, reason:"disabled"}', async () => {
+    const idx = makeIndexer({ tmpDir, enabled: false });
+    const r = await idx.backfill('a1', [{ id: 'm', title: 't', content: 'c' }]);
+    expect(r).toEqual({ ok: false, reason: 'disabled' });
+  });
+});
+
+describe('MemoryIndexer — round-trip', () => {
+  let tmpDir, indexer, svc, provider;
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-memidx-'));
+    ({ indexer, svc, provider } = makeIndexer({ tmpDir }));
+  });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('indexOne + search: the inserted memory becomes findable', async () => {
+    await indexer.indexOne('a1', {
+      id: 'm1', title: 'Telegram dedup', content: 'message floods', createdAt: '2026-05-25T12:00:00Z',
+    });
+    const r = await indexer.search('a1', 'Telegram dedup');
+    expect(r.enabled).toBe(true);
+    expect(r.hits.some(h => h.id === 'm1')).toBe(true);
+  });
+
+  test('indexOne with empty memory returns reason:"empty-text"', async () => {
+    const r = await indexer.indexOne('a1', { id: 'm-empty' });
+    expect(r).toEqual({ indexed: false, reason: 'empty-text' });
+  });
+
+  test('indexOne with invalid input returns reason:"invalid-input"', async () => {
+    expect(await indexer.indexOne(null, { id: 'm' })).toMatchObject({ reason: 'invalid-input' });
+    expect(await indexer.indexOne('a1', null)).toMatchObject({ reason: 'invalid-input' });
+    expect(await indexer.indexOne('a1', {})).toMatchObject({ reason: 'invalid-input' });
+  });
+
+  test('deleteOne removes the memory from the index', async () => {
+    await indexer.indexOne('a1', { id: 'm1', title: 'first', content: 'one' });
+    await indexer.indexOne('a1', { id: 'm2', title: 'second', content: 'two' });
+    const before = await indexer.search('a1', 'first');
+    expect(before.hits.some(h => h.id === 'm1')).toBe(true);
+    await indexer.deleteOne('a1', 'm1');
+    const after = await indexer.search('a1', 'first');
+    expect(after.hits.some(h => h.id === 'm1')).toBe(false);
+  });
+
+  test('indexMany batches memories and counts skipped', async () => {
+    const memories = [
+      { id: 'm1', title: 'alpha', content: 'one' },
+      { id: 'm2', title: 'beta',  content: 'two' },
+      { id: 'm3' },                                  // no text → skip
+      { title: 'no id' },                            // no id  → skip
+    ];
+    const result = await indexer.indexMany('a1', memories);
+    expect(result.indexed).toBe(2);
+    expect(result.skipped).toBe(2);
+    expect(result.failed).toBe(0);
+  });
+
+  test('indexMany sends a single batched embed call', async () => {
+    const memories = Array.from({ length: 5 }, (_, i) => ({
+      id: `m${i}`, title: `t${i}`, content: `c${i}`,
+    }));
+    await indexer.indexMany('a1', memories);
+    expect(provider.calls).toHaveLength(1);   // one batched call
+    expect(provider.calls[0].texts).toHaveLength(5);
+  });
+
+  test('backfill replaces the entire index', async () => {
+    await indexer.indexOne('a1', { id: 'stale', title: 'old', content: 'old' });
+    const replacement = [
+      { id: 'new1', title: 'fresh', content: 'one' },
+      { id: 'new2', title: 'newer', content: 'two' },
+    ];
+    const result = await indexer.backfill('a1', replacement);
+    expect(result.ok).toBe(true);
+    expect(result.indexed).toBe(2);
+
+    const search = await indexer.search('a1', 'fresh');
+    expect(search.hits.some(h => h.id === 'new1')).toBe(true);
+    expect(search.hits.some(h => h.id === 'stale')).toBe(false);
+  });
+
+  test('per-agent isolation: search on a1 does NOT return a2 memories', async () => {
+    await indexer.indexOne('a1', { id: 'm1', title: 'agent1-thing', content: 'x' });
+    await indexer.indexOne('a2', { id: 'm1', title: 'agent2-thing', content: 'y' });
+    const r1 = await indexer.search('a1', 'thing');
+    expect(r1.hits.length).toBeGreaterThan(0);
+    expect(r1.hits.every(h => h.metadata?.title === 'agent1-thing')).toBe(true);
+  });
+
+  test('hybrid search by default surfaces substring-only matches', async () => {
+    // Memory whose semantic vector won't match (stub generates by first char)
+    // but whose substring DOES match the query.
+    await indexer.indexOne('a1', {
+      id: 'm-sub',
+      title: 'arbitrary title',
+      content: 'this body mentions UNIQUE_TOKEN_X explicitly',
+    });
+    const r = await indexer.search('a1', 'UNIQUE_TOKEN_X');
+    expect(r.hits.some(h => h.id === 'm-sub')).toBe(true);
+  });
+
+  test('recency boost ranks fresh memories above stale ones on tie', async () => {
+    // Two memories with the same text → identical cosine. The fresh
+    // one's createdAt should make it rank first by default.
+    await indexer.indexOne('a1', {
+      id: 'fresh', title: 'shared', content: 'shared body',
+      createdAt: new Date(Date.now() - 1 * 24 * 60 * 60 * 1000).toISOString(),
+    });
+    await indexer.indexOne('a1', {
+      id: 'stale', title: 'shared', content: 'shared body',
+      createdAt: new Date(Date.now() - 200 * 24 * 60 * 60 * 1000).toISOString(),
+    });
+    const r = await indexer.search('a1', 'shared body');
+    expect(r.hits.length).toBeGreaterThanOrEqual(2);
+    const freshIdx = r.hits.findIndex(h => h.id === 'fresh');
+    const staleIdx = r.hits.findIndex(h => h.id === 'stale');
+    expect(freshIdx).toBeLessThan(staleIdx);
+  });
+
+  test('boost:false disables recency adjustment (raw cosine ranking)', async () => {
+    await indexer.indexOne('a1', { id: 'fresh', title: 'foo', content: 'foo' });
+    await indexer.indexOne('a1', { id: 'stale', title: 'foo', content: 'foo',
+      createdAt: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString() });
+    // With boost off, identical text → effectively identical scores; the
+    // order may be insertion-dependent but neither should be massively
+    // pulled away by recency.
+    const r = await indexer.search('a1', 'foo', { boost: false });
+    const scores = r.hits.map(h => h.score);
+    expect(Math.max(...scores) - Math.min(...scores)).toBeLessThan(0.05);
+  });
+
+  test('hybrid:false disables substring fusion', async () => {
+    await indexer.indexOne('a1', {
+      id: 'm-sub',
+      title: 'arbitrary',
+      content: 'this body mentions UNIQUE_TOKEN_X',
+    });
+    // Pure-semantic with stub provider and a wildly different query —
+    // we get nothing useful, but the call shouldn't throw.
+    const r = await indexer.search('a1', 'UNIQUE_TOKEN_X', { hybrid: false });
+    expect(r.enabled).toBe(true);
+    expect(Array.isArray(r.hits)).toBe(true);
+  });
+});
+
+describe('MemoryIndexer — team-pool (Phase 6c)', () => {
+  let tmpDir, indexer, svc;
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-memidx-team-'));
+    ({ indexer, svc } = makeIndexer({ tmpDir }));
+  });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('publishToTeam stores under the team scope path', async () => {
+    await indexer.publishToTeam('team-A', {
+      id: 'mem-1', title: 'Useful note', content: 'shared knowledge',
+    }, 'agent-publisher');
+    const store = await svc.getStore({ teamId: 'team-A', surface: 'memory' });
+    expect(store._filePath).toMatch(/[\\/]teams[\\/]team-A[\\/]memory\.vec\.json$/);
+    expect((await store.stats()).count).toBe(1);
+  });
+
+  test('publishToTeam records publishedBy + publishedAt in metadata', async () => {
+    await indexer.publishToTeam('team-A', {
+      id: 'mem-1', title: 't', content: 'c',
+    }, 'agent-publisher');
+    const store = await svc.getStore({ teamId: 'team-A', surface: 'memory' });
+    const row = store._rows[0];
+    expect(row.metadata.publishedBy).toBe('agent-publisher');
+    expect(row.metadata.publishedAt).toBeTruthy();
+    expect(typeof row.metadata.publishedAt).toBe('string');
+  });
+
+  test('disabled service: publishToTeam returns {indexed:false, reason:"disabled"}', async () => {
+    // makeIndexer({enabled:false}) returns the bare indexer (no destructure).
+    const disabled = makeIndexer({ tmpDir, enabled: false });
+    const r = await disabled.publishToTeam('team-A', { id: 'mem-1', title: 't', content: 'c' }, 'agent');
+    expect(r).toEqual({ indexed: false, reason: 'disabled' });
+  });
+
+  test('invalid input (missing teamId or memory.id) → invalid-input', async () => {
+    const r1 = await indexer.publishToTeam(null, { id: 'm', title: 't', content: 'c' }, 'a');
+    const r2 = await indexer.publishToTeam('team-A', {}, 'a');
+    expect(r1.reason).toBe('invalid-input');
+    expect(r2.reason).toBe('invalid-input');
+  });
+
+  test('searchTeam returns hits from the team pool only (per-team isolation)', async () => {
+    await indexer.publishToTeam('team-A', { id: 'a1', title: 'alpha', content: 'foo' }, 'agent');
+    await indexer.publishToTeam('team-B', { id: 'b1', title: 'beta',  content: 'bar' }, 'agent');
+    const rA = await indexer.searchTeam('team-A', 'alpha');
+    const rB = await indexer.searchTeam('team-B', 'beta');
+    expect(rA.hits.some(h => h.id === 'a1')).toBe(true);
+    expect(rA.hits.some(h => h.id === 'b1')).toBe(false);
+    expect(rB.hits.some(h => h.id === 'b1')).toBe(true);
+    expect(rB.hits.some(h => h.id === 'a1')).toBe(false);
+  });
+
+  test('searchTeam respects topK + hybrid + boost flags', async () => {
+    for (let i = 0; i < 5; i++) {
+      await indexer.publishToTeam('team-A', { id: `m${i}`, title: `t${i}`, content: 'shared content' }, 'agent');
+    }
+    const r = await indexer.searchTeam('team-A', 'shared content', { topK: 2 });
+    expect(r.hits.length).toBeLessThanOrEqual(2);
+  });
+
+  test('unpublishFromTeam removes the entry from the team pool', async () => {
+    await indexer.publishToTeam('team-A', { id: 'm1', title: 't', content: 'c' }, 'agent');
+    expect((await indexer.teamStats('team-A')).count).toBe(1);
+    await indexer.unpublishFromTeam('team-A', 'm1');
+    expect((await indexer.teamStats('team-A')).count).toBe(0);
+  });
+
+  test('agent\'s own memory and team pool are SEPARATE stores', async () => {
+    await indexer.indexOne('agent-1', { id: 'mine', title: 'private', content: 'p' });
+    await indexer.publishToTeam('team-A', { id: 'shared', title: 'team', content: 'shared' }, 'agent-1');
+
+    const own = await indexer.search('agent-1', 'private');
+    const team = await indexer.searchTeam('team-A', 'team');
+    expect(own.hits.some(h => h.id === 'mine')).toBe(true);
+    expect(own.hits.some(h => h.id === 'shared')).toBe(false);     // not in personal pool
+    expect(team.hits.some(h => h.id === 'shared')).toBe(true);
+    expect(team.hits.some(h => h.id === 'mine')).toBe(false);     // not in team pool
+  });
+
+  test('teamStats reports count, dimensions, and fingerprint', async () => {
+    await indexer.publishToTeam('team-A', { id: 'a1', title: 't', content: 'c' }, 'agent');
+    const s = await indexer.teamStats('team-A');
+    expect(s.enabled).toBe(true);
+    expect(s.count).toBe(1);
+    expect(s.dimensions).toBe(8);                       // stub dim
+    expect(s.modelFingerprint).toBe('stub-mem:v1');
+  });
+});
+
+describe('MemoryIndexer — failure resilience', () => {
+  let tmpDir;
+  beforeEach(async () => { tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-memidx-')); });
+  afterEach(async () => { await fsp.rm(tmpDir, { recursive: true, force: true }); });
+
+  test('indexOne swallows embed failure (does not throw)', async () => {
+    const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
+    class FailingProvider extends StubProvider {
+      async _embed() { throw new Error('upstream down'); }
+    }
+    const svc = new EmbeddingService({
+      config: { provider: 'azure' },
+      apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir,
+      providerOverrides: { azure: () => new FailingProvider() },
+    });
+    const idx = new MemoryIndexer({ embeddingService: svc });
+    const result = await idx.indexOne('a1', { id: 'm', title: 't', content: 'c' });
+    expect(result.indexed).toBe(false);
+    expect(result.reason).toBe('error');
+    expect(result.error).toMatch(/upstream/);
+  });
+
+  test('indexMany returns failed counts on embed failure', async () => {
+    const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
+    class FailingProvider extends StubProvider {
+      async _embed() { throw new Error('rate-limited'); }
+    }
+    const svc = new EmbeddingService({
+      config: { provider: 'azure' },
+      apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir,
+      providerOverrides: { azure: () => new FailingProvider() },
+    });
+    const idx = new MemoryIndexer({ embeddingService: svc });
+    const result = await idx.indexMany('a1', [
+      { id: 'm1', title: 'a', content: 'x' },
+      { id: 'm2', title: 'b', content: 'y' },
+    ]);
+    expect(result.indexed).toBe(0);
+    expect(result.failed).toBe(2);
+    expect(result.error).toMatch(/rate-limited/);
+  });
+
+  test('search returns enabled:true but empty hits on failure', async () => {
+    const apiKeyManager = { getEmbeddingApiKey: () => 'k' };
+    class FailingProvider extends StubProvider {
+      async _embed() { throw new Error('boom'); }
+    }
+    const svc = new EmbeddingService({
+      config: { provider: 'azure' },
+      apiKeyManager, baseUrl: 'https://x', stateDir: tmpDir,
+      providerOverrides: { azure: () => new FailingProvider() },
+    });
+    const idx = new MemoryIndexer({ embeddingService: svc });
+    const r = await idx.search('a1', 'hello');
+    expect(r.enabled).toBe(true);
+    expect(r.hits).toEqual([]);
+    expect(r.error).toMatch(/boom/);
+  });
+});