onbuzz 5.0.2 → 5.3.0

package/src/interfaces/webServer.js

@@ -33,6 +33,13 @@ import composioService from '../services/composioService.js';
 import { getUserDataPaths } from '../utilities/userDataDir.js';
 import { projectActiveRuns } from '../utilities/flowRunFilters.js';
 import { recordOAuthResult, recordResolvedUser, projectAuthStatus, isAuthExpired } from '../utilities/authCache.js';
+import { registerTranscribeRoute } from './transcribeRoute.js';
+import { registerScheduleRoutes } from './scheduleRoutes.js';
+import { registerAttachmentRoutes } from './attachmentRoutes.js';
+import { AttachmentIngestionService } from '../services/attachments/attachmentIngestionService.js';
+import { DocumentStore } from '../services/documents/documentStore.js';
+import { DocumentMemory } from '../services/documents/documentMemory.js';
+import { DocumentIndexer } from '../services/embeddings/indexers/documentIndexer.js';
 import AuthCacheStore from '../services/authCacheStore.js';
 import { createAccountRouter } from './accountRoutes.js';
 import { createMarketplaceRouter } from './marketplaceRoutes.js';
@@ -63,6 +70,8 @@ import { FlowVersionStore } from '../core/flowVersionStore.js';
 import { registerSchedulerRoutes } from './schedulerRoutes.js';
 // Agent memory + context-snapshot routes — power the Memory tab in AgentEditModal.
 import { registerAgentContextRoutes } from './agentContextRoutes.js';
+import { registerMemoryStatusRoute } from './memoryStatusRoutes.js';
+import { registerMonitorRoutes } from './monitorRoutes.js';
 import { getMemoryService } from '../services/memoryService.js';
 
 const __filename = resolveModuleFilename(import.meta.url);
@@ -1840,6 +1849,16 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // Speech-to-text proxy → remote /llm/transcribe (Azure AI Foundry STT).
+    // Powers web-ui dictation, especially in the Electron build where the
+    // browser's webkitSpeechRecognition has no working backend. Extracted to
+    // transcribeRoute.js so the key-resolution ladder is unit-testable.
+    registerTranscribeRoute(this.app, {
+      getApiKeyManager: () => this.apiKeyManager,
+      config: this.config,
+      logger: this.logger,
+    });
+
     // LLM Models endpoint - proxy to Loxia Azure backend
     this.app.get('/api/llm/models', async (req, res) => {
       try {
@@ -3855,6 +3874,19 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       logger: this.logger,
     });
 
+    // Live per-agent memory-path snapshot (embeddings status + index sizes +
+    // last auto-recall funnel). Thunk: embeddingService attaches post-startup.
+    registerMemoryStatusRoute(this.app, {
+      getEmbeddingService: () => this.embeddingService,
+      logger: this.logger,
+    });
+
+    // Settings → Monitor App: recent logs/errors (time + agent + level).
+    registerMonitorRoutes(this.app, {
+      getLogger: () => this.logger,
+      logger: this.logger,
+    });
+
     // ============================================
     // Artifacts API Endpoint
     // ============================================
@@ -5148,9 +5180,11 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
           );
           duplicatedAgent.conversations.full.lastUpdated = new Date().toISOString();
 
-          // Save the updated state
+          // Save the updated state. (The StateManager method is
+          // persistAgentState(agent, projectDir) — `saveAgentState` never
+          // existed, which crashed duplication when keepConversation=true.)
           const projectDir = this.orchestrator.config.project?.directory || process.cwd();
-          await this.orchestrator.stateManager.saveAgentState(duplicatedAgent, projectDir);
+          await this.orchestrator.stateManager.persistAgentState(duplicatedAgent, projectDir);
         }
 
         // Broadcast agent created event via WebSocket
@@ -6429,129 +6463,41 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // =====================================================
     // Scheduled Tasks API
     // =====================================================
-
-    // List all schedules
-    this.app.get('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, schedules: [] });
-        }
-        const schedules = this.scheduleService.listSchedules();
-        res.json({ success: true, schedules });
-      } catch (error) {
-        this.logger.error('Failed to list schedules', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get cron presets
-    this.app.get('/api/schedules/presets', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, presets: {} });
-        }
-        res.json({ success: true, presets: this.scheduleService.getPresets() });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Create a schedule
-    this.app.post('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.createSchedule(req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to create schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get a single schedule
-    this.app.get('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(404).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Update a schedule
-    this.app.put('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to update schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Delete a schedule
-    this.app.delete('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        await this.scheduleService.deleteSchedule(req.params.id);
-        res.json({ success: true });
-      } catch (error) {
-        this.logger.error('Failed to delete schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Force-trigger a schedule immediately (used by CLI trigger-schedule command)
-    this.app.post('/api/schedules/:id/trigger', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        // Execute immediately regardless of cron timing
-        await this.scheduleService._executeSchedule(schedule);
-        schedule.lastRun = new Date().toISOString();
-        schedule.runCount++;
-        schedule.updatedAt = new Date().toISOString();
-        await this.scheduleService._saveSchedules();
-        res.json({ success: true, scheduleName: schedule.name, lastRunStatus: schedule.lastRunStatus });
-      } catch (error) {
-        this.logger.error('Failed to trigger schedule', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
+    // Extracted to scheduleRoutes.js so the whole surface is unit-testable.
+    // scheduleService is passed via a thunk: the orchestrator attaches it
+    // after routes are registered at boot.
+    registerScheduleRoutes(this.app, {
+      getScheduleService: () => this.scheduleService,
+      logger: this.logger,
     });
 
-    // Toggle schedule enabled/disabled
-    this.app.post('/api/schedules/:id/toggle', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const current = this.scheduleService.getSchedule(req.params.id);
-        if (!current) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
+    // =====================================================
+    // Chat attachment ingest (binary-safe). The ingestion service is built
+    // lazily from the orchestrator's FileAttachmentService (wired post-boot).
+    // =====================================================
+    registerAttachmentRoutes(this.app, {
+      getIngestionService: () => {
+        const fas = this.orchestrator?.fileAttachmentService;
+        if (!fas) return null;
+        if (!this._attachmentIngestion || this._attachmentIngestion.fileAttachmentService !== fas) {
+          // DocumentMemory lets large text/PDF attachments be indexed for
+          // semantic recall (shares the on-disk store with the agent scheduler's
+          // recall). Best-effort: if embeddings aren't configured the store
+          // still saves and the builder falls back to inline content.
+          let documentMemory = null;
+          try {
+            const embed = this.orchestrator?.aiService?.getEmbeddingService?.() || null;
+            documentMemory = new DocumentMemory({
+              store: new DocumentStore({ logger: this.logger }),
+              indexer: new DocumentIndexer({ embeddingService: embed, logger: this.logger }),
+              logger: this.logger,
+            });
+          } catch { documentMemory = null; }
+          this._attachmentIngestion = new AttachmentIngestionService({ fileAttachmentService: fas, documentMemory, logger: this.logger });
         }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, { enabled: !current.enabled });
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(400).json({ success: false, error: error.message });
-      }
+        return this._attachmentIngestion;
+      },
+      logger: this.logger,
     });
 
     // =====================================================

package/src/services/__tests__/aiService.editImage.test.js

@@ -0,0 +1,69 @@
+/**
+ * aiService.editImage — request payload assembly.
+ *
+ * Covers the single vs multi-reference image edit: imagesBase64[] is included
+ * only when more than one source is supplied; the first image is always sent
+ * positionally as imageBase64 (so an older backend degrades to a single-image
+ * edit). Also locks the endpoint + bearer + response mapping.
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import AIService from '../aiService.js';
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+function svc() {
+  return new AIService({ backend: { baseUrl: 'https://test.example' }, timeout: 1000 }, logger, null, null);
+}
+const bodyOf = (call) => JSON.parse(call[1].body);
+
+let fetchMock;
+beforeEach(() => {
+  fetchMock = jest.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    json: async () => ({ images: [{ b64_json: 'edited' }], model: 'gpt-image-1.5' }),
+  });
+  global.fetch = fetchMock;
+});
+afterEach(() => { delete global.fetch; });
+
+describe('editImage payload', () => {
+  test('single source → imageBase64 set, no imagesBase64', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toBeUndefined();
+  });
+
+  test('multiple sources → imagesBase64 array forwarded, first also positional', async () => {
+    await svc().editImage('compose', 'AAA', { apiKey: 'k', imagesBase64: ['AAA', 'BBB', 'CCC'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toEqual(['AAA', 'BBB', 'CCC']);
+  });
+
+  test('a single-element imagesBase64 is NOT forwarded (legacy single path)', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', imagesBase64: ['AAA'] });
+    expect(bodyOf(fetchMock.mock.calls[0]).imagesBase64).toBeUndefined();
+  });
+
+  test('forwards the mask when provided', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', maskBase64: 'MASK', imagesBase64: ['AAA', 'BBB'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.maskBase64).toBe('MASK');
+    expect(body.imagesBase64).toHaveLength(2);
+  });
+
+  test('POSTs to /llm/edit-image with a bearer token and returns the b64_json', async () => {
+    const res = await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toContain('/llm/edit-image');
+    expect(init.method).toBe('POST');
+    expect(init.headers.Authorization).toBe('Bearer k');
+    expect(res.b64_json).toBe('edited');
+  });
+
+  test('rejects when no source image is supplied', async () => {
+    await expect(svc().editImage('edit', '', { apiKey: 'k' })).rejects.toThrow(/requires a source image/i);
+  });
+});

package/src/services/__tests__/aiService.embed.test.js

@@ -16,6 +16,7 @@
 
 import { describe, test, expect, jest, beforeEach } from '@jest/globals';
 import { default as AIService } from '../aiService.js';
+import { SHARED_MEMORY_SCOPE } from '../memoryService.js';
 
 function makeService() {
   // Bare-minimum config; aiService falls back to defaults for anything missing.
@@ -28,6 +29,7 @@ function makeStubEmbeddingService() {
     embedQuery: jest.fn(async () => new Float32Array([1, 0, 0, 0])),
     embedDocuments: jest.fn(async (texts) =>
       texts.map(() => new Float32Array([0.5, 0.5, 0, 0]))),
+    recordRecallActivity: jest.fn(),
   };
 }
 
@@ -169,4 +171,157 @@ describe('aiService — augmentSystemPrompt (auto-recall integration)', () => {
     const out = await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'query', { threshold: 0.8 });
     expect(out).toBe('SYSTEM');
   });
+
+  test('publishes the recall funnel to embeddingService.recordRecallActivity', async () => {
+    aiService.setEmbeddingService(stub);
+    aiService._memoryIndexerForRecall = {
+      isEnabled: true,
+      search: jest.fn(async () => ({
+        enabled: true,
+        hits: [{ id: 'm1', score: 0.9, similarity: 0.9, metadata: { text: 'remembered', title: 'Note' } }],
+      })),
+    };
+    aiService._reminisceIndexerForRecall = { isEnabled: true, search: jest.fn(async () => ({ enabled: true, hits: [] })) };
+
+    await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'tell me');
+    expect(stub.recordRecallActivity).toHaveBeenCalledTimes(1);
+    const [agentId, stats, injected] = stub.recordRecallActivity.mock.calls[0];
+    expect(agentId).toBe('agent-1');
+    expect(stats).toMatchObject({ considered: 1, passed: 1, injected: 1 });
+    expect(injected[0]).toMatchObject({ id: 'm1', title: 'Note' });
+  });
+
+  test('publishes even when nothing is injected (ran, found 0)', async () => {
+    aiService.setEmbeddingService(stub);
+    aiService._memoryIndexerForRecall = {
+      isEnabled: true,
+      search: jest.fn(async () => ({ enabled: true, hits: [{ id: 'm1', score: 0.1, similarity: 0.1, metadata: { text: 'irrelevant' } }] })),
+    };
+    aiService._reminisceIndexerForRecall = { isEnabled: true, search: jest.fn(async () => ({ enabled: true, hits: [] })) };
+
+    const out = await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'query');
+    expect(out).toBe('SYSTEM'); // nothing appended
+    expect(stub.recordRecallActivity).toHaveBeenCalledTimes(1);
+    expect(stub.recordRecallActivity.mock.calls[0][1]).toMatchObject({ passed: 0, injected: 0 });
+  });
+
+  test('a throwing recordRecallActivity never breaks augmentation', async () => {
+    stub.recordRecallActivity = jest.fn(() => { throw new Error('telemetry boom'); });
+    aiService.setEmbeddingService(stub);
+    aiService._memoryIndexerForRecall = {
+      isEnabled: true,
+      search: jest.fn(async () => ({ enabled: true, hits: [{ id: 'm1', score: 0.9, similarity: 0.9, metadata: { text: 'remembered', title: 'N' } }] })),
+    };
+    aiService._reminisceIndexerForRecall = { isEnabled: true, search: jest.fn(async () => ({ enabled: true, hits: [] })) };
+    const out = await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'tell me');
+    expect(out).toContain('remembered'); // augmentation still succeeded
+  });
+});
+
+describe('aiService — autoIndexReminisce (conversation auto-indexing)', () => {
+  let aiService, indexer;
+  const mkAgent = (count, n) => ({
+    id: 'a1',
+    reminisceIndexedCount: count,
+    conversations: { full: { messages: Array.from({ length: n }, (_, i) => ({ id: `m${i}` })) } },
+  });
+
+  beforeEach(() => {
+    aiService = makeService();
+    aiService.setEmbeddingService({ isEnabled: true });
+    indexer = { isEnabled: true, indexMany: jest.fn(async () => ({ indexedMessages: 1, error: undefined })) };
+    aiService._reminisceIndexerForRecall = indexer; // _buildReminisceIndexer returns the cached one
+  });
+
+  test('indexes only messages past the high-water mark and advances it', async () => {
+    const agent = mkAgent(1, 3); // m0 already indexed; m1,m2 new
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany).toHaveBeenCalledTimes(1);
+    const [agentId, msgs] = indexer.indexMany.mock.calls[0];
+    expect(agentId).toBe('a1');
+    expect(msgs.map(m => m.id)).toEqual(['m1', 'm2']);
+    expect(agent.reminisceIndexedCount).toBe(3);
+  });
+
+  test('backlog: no prior count → indexes everything once, sets the mark', async () => {
+    const agent = mkAgent(undefined, 5);
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany.mock.calls[0][1]).toHaveLength(5);
+    expect(agent.reminisceIndexedCount).toBe(5);
+  });
+
+  test('nothing new → does not call the indexer', async () => {
+    const agent = mkAgent(4, 4);
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany).not.toHaveBeenCalled();
+  });
+
+  test('history shrank (cleared) → mark resets and re-indexes from start', async () => {
+    const agent = mkAgent(10, 2); // mark beyond current length
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany.mock.calls[0][1]).toHaveLength(2);
+    expect(agent.reminisceIndexedCount).toBe(2);
+  });
+
+  test('disabled embeddings → no-op', async () => {
+    aiService.setEmbeddingService({ isEnabled: false });
+    await aiService.autoIndexReminisce(mkAgent(0, 3));
+    expect(indexer.indexMany).not.toHaveBeenCalled();
+  });
+
+  test('batch embed error → mark is NOT advanced (retries next turn)', async () => {
+    indexer.indexMany = jest.fn(async () => ({ indexedMessages: 0, failed: 3, error: 'embed down' }));
+    const agent = mkAgent(0, 3);
+    await aiService.autoIndexReminisce(agent);
+    expect(agent.reminisceIndexedCount).toBe(0); // unchanged → retries next turn
+  });
+
+  test('indexer throwing never propagates', async () => {
+    indexer.indexMany = jest.fn(async () => { throw new Error('boom'); });
+    const agent = mkAgent(0, 2);
+    await expect(aiService.autoIndexReminisce(agent)).resolves.toBeUndefined();
+    expect(agent.reminisceIndexedCount).toBe(0); // unchanged
+  });
+
+  test('empty conversation → no-op', async () => {
+    const agent = mkAgent(0, 0);
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany).not.toHaveBeenCalled();
+  });
+
+  test('reminisce indexer disabled → no-op', async () => {
+    indexer.isEnabled = false;
+    const agent = mkAgent(0, 3);
+    await aiService.autoIndexReminisce(agent);
+    expect(indexer.indexMany).not.toHaveBeenCalled();
+    expect(agent.reminisceIndexedCount).toBe(0);
+  });
+});
+
+describe('aiService — shared user-memory recall surface', () => {
+  let aiService, stub, memSearch;
+  beforeEach(() => {
+    aiService = makeService();
+    stub = makeStubEmbeddingService();
+    stub.config = { autoRecall: { enabled: true, threshold: 0.5, topK: 3, maxTokens: 400, surfaces: ['memory', 'reminisce'], sharedUserMemory: true } };
+    aiService.setEmbeddingService(stub);
+    memSearch = jest.fn(async () => ({ enabled: true, hits: [] }));
+    aiService._memoryIndexerForRecall = { isEnabled: true, search: memSearch };
+    aiService._reminisceIndexerForRecall = { isEnabled: true, search: jest.fn(async () => ({ enabled: true, hits: [] })) };
+    aiService._documentIndexerForRecall = { isEnabled: true, search: jest.fn(async () => ({ enabled: true, hits: [] })) };
+  });
+
+  test('sharedUserMemory ON → memory indexer is also searched at the shared scope', async () => {
+    await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'whats my name?');
+    const scopes = memSearch.mock.calls.map(c => c[0]);
+    expect(scopes).toContain(SHARED_MEMORY_SCOPE); // shared-memory surface
+    expect(scopes).toContain('agent-1');           // the agent's own memory surface
+  });
+
+  test('sharedUserMemory OFF → the shared scope is NOT searched', async () => {
+    stub.config.autoRecall.sharedUserMemory = false;
+    await aiService.augmentSystemPrompt('SYSTEM', 'agent-1', 'whats my name?');
+    const scopes = memSearch.mock.calls.map(c => c[0]);
+    expect(scopes).not.toContain(SHARED_MEMORY_SCOPE);
+  });
 });

package/src/services/__tests__/fileAttachmentService.test.js

@@ -121,9 +121,26 @@ describe('FileAttachmentService', () => {
     expect(result.fileId).toBe('test-uuid-1234');
     expect(result.agentId).toBe('agent-1');
     expect(result.mode).toBe('content');
+    expect(result.scope).toBe('agent'); // default scope
+    expect(result.conversationId).toBeNull();
     expect(service.index.attachments['test-uuid-1234']).toBeDefined();
   });
 
+  test('uploadFile records conversation scope when requested', async () => {
+    service.index = { attachments: {}, agentRefs: {} };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.getFileStats.mockResolvedValue({ size: 512, modified: new Date() });
+    mockFileProcessor.processFile.mockResolvedValue({ content: 'text content' });
+    mockValidator.validate.mockReturnValue({ valid: true, errors: [], warnings: [], sizeLevel: 'small' });
+
+    const result = await service.uploadFile({
+      agentId: 'agent-1', filePath: '/path/to/file.txt', mode: 'content',
+      scope: 'conversation', conversationId: 'conv-9',
+    });
+    expect(result.scope).toBe('conversation');
+    expect(result.conversationId).toBe('conv-9');
+  });
+
   test('uploadFile throws for non-existent file', async () => {
     service.index = { attachments: {}, agentRefs: {} };
     mockFileProcessor.fileExists.mockResolvedValueOnce(false);
@@ -275,4 +292,20 @@ describe('FileAttachmentService', () => {
     const preview = await service.getAttachmentPreview('f1');
     expect(preview).toBe('[Image content - base64 encoded]');
   });
+
+  test('updateAttachment persists docId + indexed (DocumentStore link)', async () => {
+    service.index = { attachments: { f1: { agentId: 'a1', fileName: 'big.txt', active: true } }, agentRefs: {} };
+    const metadata = { fileId: 'f1', agentId: 'a1', fileName: 'big.txt', active: true };
+    mockFileProcessor.fileExists.mockResolvedValue(true);
+    mockFileProcessor.readFile.mockResolvedValueOnce(JSON.stringify(metadata));
+
+    const updated = await service.updateAttachment('f1', { docId: 'doc-1', indexed: true, fileName: 'renamed.txt' });
+
+    expect(updated.docId).toBe('doc-1');
+    expect(updated.indexed).toBe(true);
+    expect(updated.fileName).toBe('renamed.txt');
+    const written = mockFileProcessor.writeFile.mock.calls.find((c) => String(c[0]).endsWith('metadata.json'));
+    expect(written[1]).toContain('"docId": "doc-1"');
+    expect(written[1]).toContain('"indexed": true');
+  });
 });

package/src/services/__tests__/memoryService.test.js

@@ -24,7 +24,8 @@ jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
   ensureUserDataDirs: mockEnsureUserDataDirs
 }));
 
-const { MemoryService } = await import('../../services/memoryService.js');
+const { MemoryService, SHARED_MEMORY_SCOPE } = await import('../../services/memoryService.js');
+const { buildUserProfileBlock } = await import('../../utilities/userProfileInjection.js');
 
 describe('MemoryService', () => {
   let service;
@@ -170,6 +171,14 @@ describe('MemoryService', () => {
     expect(memory.expiration.type).toBe('date');
   });
 
+  test('addMemory defaults pinned:false; pinned:true is honoured', async () => {
+    mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    const plain = await service.addMemory('agent-1', { title: 'a', content: 'x' });
+    expect(plain.pinned).toBe(false);
+    const pinned = await service.addMemory('agent-1', { title: 'b', content: 'y', pinned: true });
+    expect(pinned.pinned).toBe(true);
+  });
+
   // ── _parseExpiration ──
   test('_parseExpiration returns never for null/undefined', () => {
     expect(service._parseExpiration(null)).toEqual({ type: 'never', value: null });
@@ -222,6 +231,13 @@ describe('MemoryService', () => {
     expect(mockWriteFile).toHaveBeenCalled();
   });
 
+  test('updateMemory toggles the pinned flag', async () => {
+    const memories = [{ id: 'mem-1', title: 'T', description: '', content: '', updatedAt: '' }];
+    mockReadFile.mockResolvedValue(JSON.stringify({ memories }));
+    const result = await service.updateMemory('agent-1', 'mem-1', { pinned: true });
+    expect(result.pinned).toBe(true);
+  });
+
   test('updateMemory returns null for non-existent memory', async () => {
     mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
 
@@ -519,3 +535,100 @@ describe('MemoryService', () => {
     });
   });
 });
+
+describe('MemoryService — vector indexing', () => {
+  let service, logger, idx;
+  beforeEach(() => {
+    logger = createMockLogger();
+    service = new MemoryService(logger);
+    jest.clearAllMocks();
+    idx = { isEnabled: true, indexOne: jest.fn(), deleteOne: jest.fn(), indexMany: jest.fn() };
+  });
+
+  const mem = (id, over = {}) => ({ id, title: `t-${id}`, content: 'c', expiration: { type: 'never', value: null }, ...over });
+
+  test('addMemory indexes the new memory (indexOne)', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' }); // fresh agent
+    service.setMemoryIndexer(idx);
+    const m = await service.addMemory('a1', { title: 'T', content: 'C' });
+    expect(idx.indexOne).toHaveBeenCalledWith('a1', m);
+  });
+
+  test('updateMemory re-indexes (indexOne with the updated memory)', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({ memories: [mem('m1')] }));
+    service.setMemoryIndexer(idx);
+    const updated = await service.updateMemory('a1', 'm1', { content: 'new' });
+    expect(updated.content).toBe('new');
+    expect(idx.indexOne).toHaveBeenCalledWith('a1', expect.objectContaining({ id: 'm1', content: 'new' }));
+  });
+
+  test('deleteMemory removes the memory from the index (deleteOne)', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({ memories: [mem('m1')] }));
+    service.setMemoryIndexer(idx);
+    await service.deleteMemory('a1', 'm1');
+    expect(idx.deleteOne).toHaveBeenCalledWith('a1', 'm1');
+  });
+
+  test('loadMemories reconciles the index ONCE per agent (indexMany)', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({ memories: [mem('m1'), mem('m2')] }));
+    service.setMemoryIndexer(idx);
+    await service.loadMemories('a1');
+    expect(idx.indexMany).toHaveBeenCalledTimes(1);
+    expect(idx.indexMany).toHaveBeenCalledWith('a1', expect.arrayContaining([
+      expect.objectContaining({ id: 'm1' }), expect.objectContaining({ id: 'm2' }),
+    ]));
+    await service.loadMemories('a1'); // cache hit → gated, no re-reconcile
+    expect(idx.indexMany).toHaveBeenCalledTimes(1);
+  });
+
+  test('reconcile is a no-op for an empty memory list', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+    service.setMemoryIndexer(idx);
+    await service.loadMemories('a1');
+    expect(idx.indexMany).not.toHaveBeenCalled();
+  });
+
+  test('no indexer attached → writes still succeed, no throw', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+    await expect(service.addMemory('a1', { title: 'x', content: 'y' })).resolves.toBeDefined();
+  });
+
+  test('disabled indexer → no index calls', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+    service.setMemoryIndexer({ ...idx, isEnabled: false });
+    await service.addMemory('a1', { title: 'x', content: 'y' });
+    expect(idx.indexOne).not.toHaveBeenCalled();
+  });
+
+  test('a throwing indexer never breaks the memory write', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+    service.setMemoryIndexer({ isEnabled: true, indexOne: jest.fn(() => { throw new Error('boom'); }), deleteOne: jest.fn(), indexMany: jest.fn() });
+    await expect(service.addMemory('a1', { title: 'x', content: 'y' })).resolves.toBeDefined();
+  });
+});
+
+describe('Lever B data path — shared memory → ABOUT THE USER profile', () => {
+  let service, logger;
+  beforeEach(() => { logger = createMockLogger(); service = new MemoryService(logger); jest.clearAllMocks(); });
+
+  test('a fact saved to the SHARED scope appears in the injected profile block', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' }); // fresh shared store
+    await service.addMemory(SHARED_MEMORY_SCOPE, { title: 'name', content: 'Daniel' });
+
+    // loadMemories(SHARED) → the always-on profile block (what agentScheduler injects)
+    const shared = await service.loadMemories(SHARED_MEMORY_SCOPE);
+    const { block } = buildUserProfileBlock(shared);
+
+    expect(block).toContain('ABOUT THE USER');
+    expect(block).toContain('• name: Daniel');
+  });
+
+  test('per-agent memory does NOT leak into the shared profile', async () => {
+    mockReadFile.mockRejectedValue({ code: 'ENOENT' });
+    await service.addMemory('agent-x', { title: 'secret', content: 'agent-x private note' });
+
+    const shared = await service.loadMemories(SHARED_MEMORY_SCOPE); // different scope → empty
+    const { block } = buildUserProfileBlock(shared);
+    expect(block).toBe('');
+  });
+});