onbuzz 5.0.2 → 5.1.0

package/src/core/agentScheduler.js

@@ -35,6 +35,13 @@ import {
   getActiveAgents,
   shouldSkipIteration
 } from '../services/agentActivityService.js';
+import { DocumentStore } from '../services/documents/documentStore.js';
+import { DocumentMemory } from '../services/documents/documentMemory.js';
+import { DocumentIndexer } from '../services/embeddings/indexers/documentIndexer.js';
+import {
+  maybeOffloadToolResult,
+  DEFAULT_TOOL_OUTPUT_OFFLOAD_THRESHOLD,
+} from './toolResultOffload.js';
 
 /**
  * True iff `text` contains the digit sequence `code` not flanked by other
@@ -173,6 +180,62 @@ class AgentScheduler {
     // Configuration from constants (no magic numbers)
     this.iterationDelayMs = SCHEDULER_CONFIG.ITERATION_DELAY_MS;
     this.maxIterationsPerCycle = SCHEDULER_CONFIG.MAX_ITERATIONS_PER_CYCLE;
+
+    // Large-tool-output offload. The web tool already externalizes big fetched
+    // pages inside itself; this handles every OTHER tool's oversized result at
+    // the single point they're rendered into the `[Tool Results]` feedback
+    // message. Lazily built (the embedding service is attached to aiService
+    // after construction). Set the threshold to Infinity to disable.
+    this.toolOutputOffloadThreshold = DEFAULT_TOOL_OUTPUT_OFFLOAD_THRESHOLD;
+    this._toolOutputDocumentMemory = null;
+  }
+
+  /**
+   * Lazy accessor for the DocumentMemory used to externalize large tool
+   * outputs. Mirrors webTool._getDocumentMemory: the DocumentStore persists
+   * regardless of embeddings; the indexer no-ops when embeddings are
+   * missing/disabled, so content is always saved (just not semantically
+   * searchable until an embeddings provider is configured).
+   * @returns {DocumentMemory}
+   * @private
+   */
+  _getToolOutputDocumentMemory() {
+    if (this._toolOutputDocumentMemory) return this._toolOutputDocumentMemory;
+    const svc = this.aiService?.getEmbeddingService?.() || null;
+    const store = new DocumentStore({ logger: this.logger });
+    const indexer = new DocumentIndexer({ embeddingService: svc, logger: this.logger });
+    this._toolOutputDocumentMemory = new DocumentMemory({ store, indexer, logger: this.logger });
+    return this._toolOutputDocumentMemory;
+  }
+
+  /**
+   * Externalize any oversized results in `results` in place before they are
+   * rendered into a tool-results feedback message. Best-effort: any failure
+   * leaves the result inline so the agent never loses its output.
+   * @param {string} agentId
+   * @param {Array<object>} results  Tool-result message objects.
+   * @private
+   */
+  async _maybeOffloadToolResults(agentId, results) {
+    if (!Array.isArray(results) || results.length === 0) return;
+    let mem;
+    try {
+      mem = this._getToolOutputDocumentMemory();
+    } catch {
+      return; // no document memory available → leave everything inline
+    }
+    for (const toolResult of results) {
+      try {
+        await maybeOffloadToolResult({
+          documentMemory: mem,
+          agentId,
+          toolResult,
+          threshold: this.toolOutputOffloadThreshold,
+        });
+      } catch {
+        /* best-effort; never block tool-result assembly */
+      }
+    }
   }
 
   /**
@@ -1031,6 +1094,7 @@ class AgentScheduler {
     const hasNewMessages = (queues.userMessages?.length > 0) || (queues.interAgentMessages?.length > 0);
     if (agent.autonomousWorkComplete && queues.toolResults?.length > 0 && hasNewMessages) {
       const staleCount = queues.toolResults.length;
+      await this._maybeOffloadToolResults(agentId, queues.toolResults);
       let boundaryContent = '[Previous Task — Final Tool Results]\n';
       queues.toolResults.forEach(msg => {
         boundaryContent += `${this.formatToolResult(msg)}\n`;
@@ -1100,6 +1164,12 @@ class AgentScheduler {
     const toolResults = allMessages.filter(m => m.queueType === 'toolResults');
     let toolResultContent = '';
     if (toolResults.length > 0) {
+      // Externalize oversized results (terminal/filesystem/office/etc.) before
+      // rendering, mirroring the web tool's own offload. Keeps giant raw dumps
+      // out of the conversation so the agent reads less, remembers more, and
+      // compacts less often.
+      await this._maybeOffloadToolResults(agentId, toolResults);
+
       // Group results by responseTurnId (the AI message that triggered them)
       const turnGroups = new Map();
       for (const msg of toolResults) {
@@ -1306,6 +1376,15 @@ class AgentScheduler {
     agent.conversations.full.messages.push(formattedMessage);
     agent.conversations.full.lastUpdated = new Date().toISOString();
 
+    // Auto-index the conversation into the reminisce surface so the agent can
+    // semantically recall past messages. Incremental + idempotent + best-effort
+    // (fire-and-forget, never blocks the turn). Reconciles the whole history
+    // against a high-water mark, so it also catches messages appended by other
+    // paths on the next call.
+    if (this.aiService?.autoIndexReminisce) {
+      Promise.resolve(this.aiService.autoIndexReminisce(agent)).catch(() => {});
+    }
+
     // Add to current model conversation if exists
     if (agent.currentModel && agent.conversations[agent.currentModel]) {
       agent.conversations[agent.currentModel].messages.push(formattedMessage);
@@ -2196,6 +2275,38 @@ class AgentScheduler {
         });
       }
 
+      // ── Auto-inject SHARED user memory as ABOUT THE USER ───────────
+      // When sharedUserMemory is enabled, inject a lean, always-on block of
+      // facts about the user (e.g. their name) from the shared store — every
+      // agent, every turn, NO similarity gate. This is the reliable
+      // cross-agent path: a question rarely scores close enough to the answer
+      // for similarity recall, so identity facts live here as a persistent
+      // profile (like ChatGPT's). Best-effort; embeddings-independent (plain
+      // file read). Mirrors the plan-injection block above.
+      try {
+        const sharedOn = this.aiService?.getEmbeddingService?.()?.config?.autoRecall?.sharedUserMemory;
+        if (sharedOn) {
+          const { getMemoryService, SHARED_MEMORY_SCOPE } = await import('../services/memoryService.js');
+          const memoryService = getMemoryService(this.logger);
+          await memoryService.initialize();
+          const sharedMemories = await memoryService.loadMemories(SHARED_MEMORY_SCOPE);
+          if (sharedMemories.length > 0) {
+            const { buildUserProfileBlock } = await import('../utilities/userProfileInjection.js');
+            const { block } = buildUserProfileBlock(sharedMemories);
+            if (block) enhancedSystemPrompt = (enhancedSystemPrompt || '') + block;
+          }
+          // Formation nudge (one concise line — not a data dump): so the model
+          // actually populates the shared store as it learns things about the
+          // user. This is the natural, model-driven formation path.
+          enhancedSystemPrompt = (enhancedSystemPrompt || '') +
+            '\n\n[Shared user-memory is ON: when you learn a durable fact about the USER (e.g. their name or a stable preference), save it with the memory tool using { shared: true } so every one of the user\'s agents knows it.]';
+        }
+      } catch (profileErr) {
+        this.logger.warn(`User-profile injection failed for agent ${agentId} (continuing without)`, {
+          error: profileErr?.message,
+        });
+      }
+
       // ── Auto-inject CURRENT TASK LIST every turn ───────────────────
       // The task list lives in `agent.taskList.tasks` — durable, never
       // affected by compaction. But the conversation messages that
@@ -2336,15 +2447,18 @@ class AgentScheduler {
       // explicit primitive; this is the silent supplement. Lit-aligned
       // with the ChatGPT / Anthropic Memory shape — see Phase 6 design.
       //
-      // Best-effort: failures NEVER block the turn. Gated by:
-      //   - agent has 'memory' capability (no point recalling for an
-      //     agent that can't read/write memories)
+      // Best-effort: failures NEVER block the turn. Gated only by:
       //   - aiService.augmentSystemPrompt is present (older builds
       //     without Phase 6d skip cleanly)
       //   - the helper itself short-circuits on disabled/empty config
+      //
+      // NOTE: this is intentionally NOT gated on the 'memory' capability.
+      // Recalling an agent's OWN past conversation (the reminisce surface) is a
+      // baseline behavior every agent should have — the 'memory' capability is
+      // about the explicit memory *tool*, which is a different concern. Gating
+      // recall on it meant memory-less agents indexed their conversation but
+      // never recalled it (so they "forgot" things they were just told).
       if (
-        Array.isArray(agent.capabilities) &&
-        agent.capabilities.includes('memory') &&
         typeof this.aiService?.augmentSystemPrompt === 'function'
       ) {
         try {

package/src/core/toolResultOffload.js

@@ -0,0 +1,131 @@
+/**
+ * Generic large-tool-output offload.
+ *
+ * The web tool already externalizes large fetched pages into the per-agent
+ * DocumentStore (see webTool._maybeOffload) so a 200 KB article never enters
+ * the conversation. But EVERY other tool — terminal, filesystem, office,
+ * desktop/foundry, etc. — still dumps its raw result verbatim into the
+ * `[Tool Results — …]` feedback message (agentScheduler.processAgentQueues →
+ * formatToolResult). A single `cat` of a big file or a chatty build log can
+ * add tens of thousands of tokens that then ride along in context every turn
+ * and force premature compaction.
+ *
+ * This module applies the SAME externalize-and-handle treatment generically,
+ * at the one chokepoint all tool results pass through. For any completed result
+ * whose serialized body exceeds a threshold, it persists the full body to the
+ * agent's DocumentStore and replaces the body with a compact preview + a
+ * recall handle. The agent can recall passages semantically or read exact
+ * lines via code-map — without the full body surviving in the conversation.
+ *
+ * Web results that the web tool already externalized are skipped (no double
+ * offload). Failed/short results are left untouched.
+ */
+
+/** Default body size (chars) above which a tool result is externalized. */
+export const DEFAULT_TOOL_OUTPUT_OFFLOAD_THRESHOLD = 6000;
+/** How many leading chars of the body to keep inline as a preview. */
+export const DEFAULT_TOOL_OUTPUT_PREVIEW_CHARS = 1500;
+
+/**
+ * Reproduce the large-content branches of agentScheduler.formatToolResult so
+ * the threshold reflects the actual text cost the body would add to context.
+ * Only `completed` results carry potentially-large bodies; failed/other
+ * statuses render to short strings and are never worth externalizing.
+ *
+ * @param {object} toolResult
+ * @returns {string|null} the serialized body, or null if not offload-eligible.
+ */
+export function serializeToolResultBody(toolResult) {
+  if (!toolResult || toolResult.status !== 'completed') return null;
+  const r = toolResult.result;
+  if (r === undefined || r === null) return null;
+  if (typeof r === 'object') {
+    try {
+      return JSON.stringify(r, null, 2);
+    } catch {
+      return null; // circular / non-serializable → leave it to formatToolResult
+    }
+  }
+  return String(r);
+}
+
+/**
+ * Externalize a single large tool result in place. No-op (returns unchanged)
+ * when there's no document memory / agent context, the body is below
+ * threshold, the result was already externalized by its producing tool, or
+ * persistence fails. Mutates `toolResult.result` to a compact handle when it
+ * does externalize.
+ *
+ * @param {object} args
+ * @param {object} args.documentMemory  DocumentMemory instance (remember()).
+ * @param {string} args.agentId
+ * @param {object} args.toolResult       Mutated in place when externalized.
+ * @param {number} [args.threshold]
+ * @param {number} [args.previewChars]
+ * @returns {Promise<{externalized: boolean, toolResult: object}>}
+ */
+export async function maybeOffloadToolResult({
+  documentMemory,
+  agentId,
+  toolResult,
+  threshold = DEFAULT_TOOL_OUTPUT_OFFLOAD_THRESHOLD,
+  previewChars = DEFAULT_TOOL_OUTPUT_PREVIEW_CHARS,
+} = {}) {
+  if (!documentMemory || !agentId || !toolResult) {
+    return { externalized: false, toolResult };
+  }
+
+  // Skip results a producing tool already externalized (e.g. webTool sets
+  // contentExternalized; our own handle sets toolOutputExternalized).
+  const existing = toolResult.result;
+  if (
+    existing &&
+    typeof existing === 'object' &&
+    (existing.contentExternalized || existing.toolOutputExternalized)
+  ) {
+    return { externalized: false, toolResult };
+  }
+
+  const body = serializeToolResultBody(toolResult);
+  if (!body || body.length < threshold) {
+    return { externalized: false, toolResult };
+  }
+
+  const toolId = toolResult.toolId || 'tool';
+  const source = `tool://${toolId}/${toolResult.id || 'result'}`;
+
+  let handle;
+  try {
+    handle = await documentMemory.remember(agentId, {
+      source,
+      title: `${toolId} output`,
+      content: body,
+    });
+  } catch {
+    // Best-effort: a persistence failure must never drop the result — keep it
+    // inline so the agent still sees its output this turn.
+    return { externalized: false, toolResult };
+  }
+
+  toolResult.result = {
+    toolOutputExternalized: true,
+    tool: toolId,
+    preview: body.slice(0, previewChars),
+    omittedChars: Math.max(0, body.length - previewChars),
+    document: {
+      docId: handle.docId,
+      lines: handle.lines,
+      bytes: handle.bytes,
+      chunkCount: handle.chunkCount,
+      indexed: handle.indexed,
+      embeddingsEnabled: handle.embeddingsEnabled,
+    },
+    recallHint: handle.embeddingsEnabled
+      ? `Full ${toolId} output saved as document ${handle.docId} (${handle.lines} lines). Recall relevant passages semantically over your saved documents, or read exact lines with code-map read-range on the saved file.`
+      : `Full ${toolId} output saved as document ${handle.docId} (${handle.lines} lines); semantic recall is OFF (set an embeddings provider in Settings to enable search). You can still read it with code-map read-range.`,
+  };
+
+  return { externalized: true, toolResult };
+}
+
+export default { serializeToolResultBody, maybeOffloadToolResult };

package/src/index.js

@@ -50,8 +50,6 @@ import WebTool from './tools/webTool.js';
 import VisualEditorTool from './tools/visualEditorTool.js';
 import PdfTool from './tools/pdfTool.js';
 import HelpTool from './tools/helpTool.js';
-import DocxTool from './tools/docxTool.js';
-import ExcelTool from './tools/excelTool.js';
 import OfficeTool from './tools/officeTool.js';
 import MemoryTool from './tools/memoryTool.js';
 import ComposioTool from './tools/composioTool.js';
@@ -65,6 +63,8 @@ import { DesktopTool } from './tools/desktop/DesktopTool.js';
 import ScheduleService from './services/scheduleService.js';
 import AsyncToolManager from './tools/asyncToolManager.js';
 import WebServer from './interfaces/webServer.js';
+import { wireMemoryActivityBroadcast } from './interfaces/memoryStatusRoutes.js';
+import { wireMonitorBroadcast } from './interfaces/monitorRoutes.js';
 
 import {
   SYSTEM_VERSION,
@@ -353,6 +353,22 @@ class LoxiaApplication {
       provider: this.embeddingService.config.provider,
       enabled: this.embeddingService.isEnabled,
     });
+    // Pre-load the local embedding model in the background so the user never
+    // has to click "pre-load model". Fire-and-forget — does not block startup.
+    this.embeddingService.warmupInBackground();
+
+    // Give the shared MemoryService a memory indexer so EVERY memory write
+    // (agent tool, Settings/UI add, etc.) keeps the vector surface in sync, and
+    // it can reconcile any pre-existing un-indexed memories on first load.
+    try {
+      const { getMemoryService } = await import('./services/memoryService.js');
+      const { MemoryIndexer } = await import('./services/embeddings/indexers/memoryIndexer.js');
+      getMemoryService(this.logger).setMemoryIndexer(
+        new MemoryIndexer({ embeddingService: this.embeddingService, logger: this.logger }),
+      );
+    } catch (err) {
+      this.logger.warn('[Loxia] Failed to wire memory indexer', { error: err?.message });
+    }
     
     // Initialize Model Routing Services
     this.benchmarkService = new BenchmarkService(this.config, this.logger);
@@ -502,16 +518,11 @@ class LoxiaApplication {
     // Register Help Tool (two-layer tool description system)
     await this.toolsRegistry.registerTool(HelpTool);
 
-    // Register Document (DOCX) Tool — legacy; superseded by OfficeTool.
-    // Kept for one release cycle so existing agent configs that reference
-    // toolId "doc" continue to work.
-    await this.toolsRegistry.registerTool(DocxTool);
-
-    // Register Spreadsheet (Excel) Tool — legacy; superseded by OfficeTool.
-    await this.toolsRegistry.registerTool(ExcelTool);
-
     // Register Office Tool — consolidated doc/sheet/pres surface
-    // (Word + Excel + PowerPoint create/read).
+    // (Word + Excel + PowerPoint create/read). Supersedes the former
+    // standalone `doc` (DOCX) and `spreadsheet` (Excel) tools, now removed;
+    // old agent configs referencing those toolIds are migrated to `office`
+    // by agentPool.sanitizeCapabilities.
     await this.toolsRegistry.registerTool(OfficeTool);
 
     // Register Memory Tool
@@ -779,6 +790,21 @@ class LoxiaApplication {
       // read config + telemetry, hot-swap providers, etc.
       webServer.embeddingService = this.embeddingService;
 
+      // Rebroadcast live per-turn auto-recall telemetry to web-ui clients
+      // (the memory-path Health/Activity strip). Best-effort; piggybacks the
+      // existing websocket and emits only data auto-recall already computed.
+      wireMemoryActivityBroadcast({
+        embeddingService: this.embeddingService,
+        broadcast: (message) => webServer.broadcastToSession(null, message),
+        logger: this.logger,
+      });
+
+      // Live-push new warn/error log entries to the Monitor App.
+      wireMonitorBroadcast({
+        logger: this.logger,
+        broadcast: (message) => webServer.broadcastToSession(null, message),
+      });
+
       // Set Credential Vault reference in Web Server
       webServer.setCredentialVault(this.credentialVault);
 

package/src/interfaces/__tests__/memoryStatusRoutes.test.js

@@ -0,0 +1,161 @@
+/**
+ * Tests for memoryStatusRoutes — the live per-agent memory-path view.
+ *
+ * Pure DI: the route registrar is exercised by capturing the handler off a
+ * fake `app.get` and invoking it with mock req/res; the broadcast wiring is
+ * exercised with a real EventEmitter + a capturing broadcast fn.
+ */
+import { describe, test, expect, jest } from '@jest/globals';
+import { EventEmitter } from 'events';
+import { registerMemoryStatusRoute, wireMemoryActivityBroadcast } from '../memoryStatusRoutes.js';
+
+/** Capture the single GET handler the registrar installs. */
+function mountRoute(deps) {
+  let handler = null;
+  const app = { get: jest.fn((path, h) => { if (path.endsWith('/memory-status')) handler = h; }) };
+  registerMemoryStatusRoute(app, deps);
+  return { app, invoke: (agentId) => handler({ params: { agentId } }, makeRes()) };
+}
+
+function makeRes() {
+  const res = {
+    statusCode: 200,
+    body: null,
+    status(code) { this.statusCode = code; return this; },
+    json(payload) { this.body = payload; return this; },
+  };
+  return res;
+}
+
+describe('registerMemoryStatusRoute', () => {
+  test('registers GET /api/agents/:agentId/memory-status', () => {
+    const { app } = mountRoute({ getEmbeddingService: () => null });
+    expect(app.get).toHaveBeenCalledWith('/api/agents/:agentId/memory-status', expect.any(Function));
+  });
+
+  test('returns disabled shape when no embedding service attached', async () => {
+    const res = makeRes();
+    let handler;
+    const app = { get: (_p, h) => { handler = h; } };
+    registerMemoryStatusRoute(app, { getEmbeddingService: () => null });
+    await handler({ params: { agentId: 'a1' } }, res);
+    expect(res.body).toEqual({ embeddings: { enabled: false }, surfaces: {}, lastRecall: null });
+  });
+
+  test('returns disabled shape when service lacks getMemoryStatus', async () => {
+    const res = makeRes();
+    let handler;
+    registerMemoryStatusRoute({ get: (_p, h) => { handler = h; } }, { getEmbeddingService: () => ({}) });
+    await handler({ params: { agentId: 'a1' } }, res);
+    expect(res.body.embeddings.enabled).toBe(false);
+  });
+
+  test('delegates to embeddingService.getMemoryStatus with the agentId', async () => {
+    const status = { embeddings: { enabled: true }, surfaces: { memory: 3 }, lastRecall: null };
+    const svc = { getMemoryStatus: jest.fn(async () => status) };
+    const res = makeRes();
+    let handler;
+    registerMemoryStatusRoute({ get: (_p, h) => { handler = h; } }, { getEmbeddingService: () => svc });
+    await handler({ params: { agentId: 'a7' } }, res);
+    expect(svc.getMemoryStatus).toHaveBeenCalledWith('a7');
+    expect(res.body).toBe(status);
+  });
+
+  test('500 + logs when getMemoryStatus throws', async () => {
+    const logger = { error: jest.fn() };
+    const svc = { getMemoryStatus: async () => { throw new Error('kaboom'); } };
+    const res = makeRes();
+    let handler;
+    registerMemoryStatusRoute({ get: (_p, h) => { handler = h; } }, { getEmbeddingService: () => svc, logger });
+    await handler({ params: { agentId: 'a1' } }, res);
+    expect(res.statusCode).toBe(500);
+    expect(res.body).toEqual({ error: 'kaboom' });
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  test('non-function getEmbeddingService is tolerated (disabled shape)', async () => {
+    const res = makeRes();
+    let handler;
+    registerMemoryStatusRoute({ get: (_p, h) => { handler = h; } }, {});
+    await handler({ params: { agentId: 'a1' } }, res);
+    expect(res.body.embeddings.enabled).toBe(false);
+  });
+
+  test('registrar with no deps arg does not throw (disabled shape)', async () => {
+    const res = makeRes();
+    let handler;
+    registerMemoryStatusRoute({ get: (_p, h) => { handler = h; } }); // no deps
+    await handler({ params: { agentId: 'a1' } }, res);
+    expect(res.body.embeddings.enabled).toBe(false);
+  });
+});
+
+describe('wireMemoryActivityBroadcast', () => {
+  const flush = () => new Promise((r) => setImmediate(r));
+
+  test('does NOT broadcast synchronously (deferred off the emit stack)', () => {
+    const embeddingService = { memoryActivity: new EventEmitter() };
+    const sent = [];
+    wireMemoryActivityBroadcast({ embeddingService, broadcast: (m) => sent.push(m) });
+    embeddingService.memoryActivity.emit('recall', { agentId: 'a1', injected: 2 });
+    expect(sent).toHaveLength(0); // not yet — emit returned immediately
+  });
+
+  test('rebroadcasts recall entries as memory:recall (deferred)', async () => {
+    const embeddingService = { memoryActivity: new EventEmitter() };
+    const sent = [];
+    const off = wireMemoryActivityBroadcast({ embeddingService, broadcast: (m) => sent.push(m) });
+
+    embeddingService.memoryActivity.emit('recall', { agentId: 'a1', injected: 2 });
+    await flush();
+    expect(sent).toEqual([{ type: 'memory:recall', data: { agentId: 'a1', injected: 2 } }]);
+
+    off(); // unsubscribe stops further delivery
+    embeddingService.memoryActivity.emit('recall', { agentId: 'a1', injected: 9 });
+    await flush();
+    expect(sent).toHaveLength(1);
+  });
+
+  test('no-op (returns a safe fn) when there is no emitter', () => {
+    const off = wireMemoryActivityBroadcast({ embeddingService: {}, broadcast: () => {} });
+    expect(typeof off).toBe('function');
+    expect(() => off()).not.toThrow();
+  });
+
+  test('no-op when broadcast is not a function', () => {
+    const embeddingService = { memoryActivity: new EventEmitter() };
+    const off = wireMemoryActivityBroadcast({ embeddingService, broadcast: null });
+    embeddingService.memoryActivity.emit('recall', { agentId: 'a1' }); // must not throw
+    expect(typeof off).toBe('function');
+  });
+
+  test('a throwing broadcast is swallowed and logged (deferred)', async () => {
+    const embeddingService = { memoryActivity: new EventEmitter() };
+    const logger = { warn: jest.fn() };
+    wireMemoryActivityBroadcast({ embeddingService, broadcast: () => { throw new Error('ws down'); }, logger });
+    embeddingService.memoryActivity.emit('recall', { agentId: 'a1' });
+    await flush();
+    expect(logger.warn).toHaveBeenCalled();
+  });
+
+  test('called with no args returns a safe no-op', () => {
+    const off = wireMemoryActivityBroadcast();
+    expect(typeof off).toBe('function');
+    expect(() => off()).not.toThrow();
+  });
+
+  test('falls back to setTimeout when setImmediate is unavailable', async () => {
+    const orig = global.setImmediate;
+    global.setImmediate = undefined;
+    try {
+      const embeddingService = { memoryActivity: new EventEmitter() };
+      const sent = [];
+      wireMemoryActivityBroadcast({ embeddingService, broadcast: (m) => sent.push(m) });
+      embeddingService.memoryActivity.emit('recall', { agentId: 'a1' });
+      await new Promise((r) => setTimeout(r, 0));
+      expect(sent).toHaveLength(1);
+    } finally {
+      global.setImmediate = orig;
+    }
+  });
+});