onbuzz 4.8.3 → 4.9.1

package/src/core/agentScheduler.js

@@ -37,6 +37,34 @@ import {
   shouldSkipIteration
 } from '../services/agentActivityService.js';
 
+/**
+ * True iff `text` contains the digit sequence `code` not flanked by other
+ * digits. Used for HTTP status-code detection inside free-text error
+ * messages (e.g. "HTTP 401 Unauthorized" or "got 503 from upstream")
+ * without matching "1401" or "5039".
+ *
+ * Chosen over the regex `/\b401\b/` because (a) `\b` doesn't actually
+ * mean "non-digit boundary" — it means "transition between \w and \W",
+ * which still treats "_401" as a match — and (b) plain string ops are
+ * easier to read and harder to break under future maintenance.
+ *
+ * @param {string} text   The error message, already lowercased.
+ * @param {string} code   The status code as a digit string, e.g. "401".
+ * @returns {boolean}
+ */
+function containsStatusCode(text, code) {
+  let i = 0;
+  while ((i = text.indexOf(code, i)) !== -1) {
+    const before = i === 0 ? '' : text[i - 1];
+    const after  = (i + code.length >= text.length) ? '' : text[i + code.length];
+    const beforeIsDigit = before >= '0' && before <= '9';
+    const afterIsDigit  = after  >= '0' && after  <= '9';
+    if (!beforeIsDigit && !afterIsDigit) return true;
+    i += code.length;
+  }
+  return false;
+}
+
 class AgentScheduler {
   /**
    * Register the Discord service so the scheduler can ask whether a given
@@ -1638,6 +1666,16 @@ class AgentScheduler {
       // Update AgentPool with compacted messages — pass pre-compaction watermark
       await this.agentPool.updateCompactedMessages(agentId, targetModel, compactionResult, preCompactionMessageCount);
 
+      // Mark a one-shot post-compaction nudge for the next turn. The
+      // agentScheduler reads this on the next prompt-build to emit a
+      // "consult AGENT MEMORY for context that may have been summarized
+      // away" reminder, then clears the flag. Best-effort — never
+      // block the rest of the compaction completion.
+      try {
+        const agent = await this.agentPool.getAgent(agentId);
+        if (agent) agent._postCompactionNudgePending = true;
+      } catch (_) { /* swallow — non-essential */ }
+
       if (ENABLE_COMPACT_DEBUG) {
         console.log('[COMPACT-COMPLETED]', {
           agentId,
@@ -2147,6 +2185,87 @@ class AgentScheduler {
         });
       }
 
+      // ── Auto-inject CODEBASE KNOWLEDGE index every turn ─────────────
+      // Production observation (Monopoly mission, May 2026): 22 code-map
+      // skeleton calls on the SAME file, 80% of those re-calls happened
+      // while the original tool result was still in the agent's active
+      // context — the agent simply didn't notice. A salient index at a
+      // stable system-prompt location addresses this attention failure.
+      // The index also survives compaction, addressing the 20% of
+      // re-calls that occur after compaction. See
+      // services/codebaseKnowledgeService.js for the full design.
+      //
+      // Capability gate: only runs for agents that have code-map in
+      // their capabilities. The cache is only populated by code-map
+      // calls today, so non-coder agents would never have anything to
+      // surface — no point paying the per-turn lookup overhead.
+      if (Array.isArray(agent.capabilities) && agent.capabilities.includes('code-map')) {
+        try {
+          const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
+          const ks = getCodebaseKnowledgeService(this.logger);
+          const block = ks.buildIndexBlock(agentId);
+          if (block) enhancedSystemPrompt = (enhancedSystemPrompt || '') + block;
+        } catch (ksErr) {
+          this.logger.warn(`Codebase-knowledge injection failed for agent ${agentId} (continuing without)`, {
+            error: ksErr?.message,
+          });
+        }
+      }
+
+      // ── Auto-inject AGENT MEMORY catalog every turn ─────────────────
+      // Compact list of memory IDs + titles (no contents) so the agent
+      // KNOWS what's in its memory store without paying the prompt-token
+      // cost of injecting full contents. Production observation
+      // (Monopoly mission, 1556 messages): 0 memory operations all
+      // session — the agent never consulted memories that existed.
+      // Visibility-only injection: agent can call `memory read` if a
+      // catalog entry looks relevant. Empirical wording verified safe
+      // (no in-context-learning bait) by the same harness that caught
+      // the codebase-knowledge regression earlier.
+      //
+      // Capability gate: only inject when the agent has memory in its
+      // capability set — agents that can't read/write memory would just
+      // be confused by the section.
+      if (Array.isArray(agent.capabilities) && agent.capabilities.includes('memory')) {
+        try {
+          const { getMemoryService } = await import('../services/memoryService.js');
+          const mem = getMemoryService(this.logger);
+          await mem.initialize();
+          const catalog = await mem.getCatalog(agentId, 20);
+          if (catalog && catalog.entries && catalog.entries.length > 0) {
+            const lines = ['', '## AGENT MEMORY (catalog — ids and titles only; use `memory read` for content)', ''];
+            for (const e of catalog.entries) {
+              const desc = e.description ? ` "${e.description}"` : '';
+              lines.push(`- ${e.id}  ${e.title}${desc}`);
+            }
+            if (catalog.total > catalog.entries.length) {
+              lines.push(`- … ${catalog.total - catalog.entries.length} more (use \`memory list\` to see all)`);
+            }
+            enhancedSystemPrompt = (enhancedSystemPrompt || '') + lines.join('\n');
+          }
+        } catch (memErr) {
+          this.logger.warn(`Memory catalog injection failed for agent ${agentId} (continuing without)`, {
+            error: memErr?.message,
+          });
+        }
+      }
+
+      // ── Post-compaction nudge (one-shot) ────────────────────────────
+      // When compaction has just run, the agent has lost a chunk of
+      // recent history. This is the highest-value moment to consult
+      // memory — older context may have been summarized away but
+      // memories remain. Emit a single nudge then clear the flag.
+      if (agent._postCompactionNudgePending) {
+        const nudge = '\n\n## POST-COMPACTION NUDGE (one-time)\n\n' +
+          'Compaction just summarized older messages. If your current work continues from before the compaction boundary, ' +
+          'scan the `## AGENT MEMORY` catalog above — older context that was summarized may still be available as a memory ' +
+          'you can `memory read` by id.';
+        enhancedSystemPrompt = (enhancedSystemPrompt || '') + nudge;
+        try {
+          agent._postCompactionNudgePending = false;
+        } catch (_) { /* read-only proxy edge case */ }
+      }
+
       // Check if streaming is enabled - consider both agent config and user message preference
       // Get the last user message to check for streaming preference
       const lastUserMsg = [...conversationHistory].reverse().find(m => m.role === 'user');
@@ -2156,6 +2275,39 @@ class AgentScheduler {
         ? userStreamingPref !== false
         : agent.streamingEnabled !== false; // Default to true
 
+      // ── Auto-recall: silent retrieval injected per turn (Phase 6d.2) ─
+      // When embeddings + autoRecall.enabled, look up high-similarity
+      // memory + reminisce items against the user's most recent message
+      // and append them under "## RELEVANT CONTEXT (auto-recalled)".
+      // Hybrid call path: voluntary `memory.semantic-search` remains the
+      // 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)
+      //   - aiService.augmentSystemPrompt is present (older builds
+      //     without Phase 6d skip cleanly)
+      //   - the helper itself short-circuits on disabled/empty config
+      if (
+        Array.isArray(agent.capabilities) &&
+        agent.capabilities.includes('memory') &&
+        typeof this.aiService?.augmentSystemPrompt === 'function'
+      ) {
+        try {
+          const recentText = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
+          if (recentText) {
+            enhancedSystemPrompt = await this.aiService.augmentSystemPrompt(
+              enhancedSystemPrompt, agentId, recentText,
+            );
+          }
+        } catch (err) {
+          this.logger.warn?.(`Auto-recall injection failed for agent ${agentId} (continuing without)`, {
+            error: err?.message,
+          });
+        }
+      }
+
       // Native function-call tools for the agent's enabled capabilities.
       // Passed as `options.tools` to the backend. For Responses-API models
       // (codex/o-series/gpt-5-pro) the backend forwards these to Azure so
@@ -2684,18 +2836,69 @@ class AgentScheduler {
       return; // Don't proceed with other error handling
     }
 
-    // Determine failure type and response
+    // Classification. Two reasons we do this here and not at AI-service call
+    // sites: (1) we already have the canonical error object, (2) the
+    // scheduler is the only place that decides "retry vs pause vs alert".
+    //
+    // Persistent vs transient is the key axis: persistent failures need a
+    // human in the loop (broadcast `agent_error` so it reaches the UI and
+    // Telegram); transient failures self-heal (skip the broadcast — they
+    // were the source of the per-minute Telegram floods historically).
     const errorMessage = error.message?.toLowerCase() || '';
 
-    if (errorMessage.includes('api key') || errorMessage.includes('authentication')) {
-      // API key issues - pause agent to prevent infinite retries
+    // Plain string operations only — no regex. Each classifier reads
+    // top-down as a flat list of substring or status-code probes,
+    // making it obvious what's matched and trivial to extend.
+    const isAuthError =
+         errorMessage.includes('api key')
+      || errorMessage.includes('api-key')
+      || errorMessage.includes('api_key')
+      || errorMessage.includes('apikey')
+      || errorMessage.includes('authentication')
+      || errorMessage.includes('unauthorized')
+      || errorMessage.includes('forbidden')
+      || containsStatusCode(errorMessage, '401')
+      || containsStatusCode(errorMessage, '403');
+
+    const isRateLimit =
+         errorMessage.includes('rate limit')
+      || errorMessage.includes('rate-limit')
+      || errorMessage.includes('ratelimit')
+      || errorMessage.includes('too many requests')
+      || containsStatusCode(errorMessage, '429');
+
+    // The bare "busy" branch is acceptable because the cost of a false
+    // positive is just a 2-min quiet retry (no broadcast, no escalation).
+    const isProviderOverload =
+         errorMessage.includes('overload')
+      || errorMessage.includes('capacity')
+      || errorMessage.includes('busy')
+      || containsStatusCode(errorMessage, '529');
+
+    const isGatewayError =
+         errorMessage.includes('service unavailable')
+      || errorMessage.includes('gateway')
+      || errorMessage.includes('upstream')
+      || containsStatusCode(errorMessage, '503')
+      || containsStatusCode(errorMessage, '504');
+
+    const isNetworkError =
+         errorMessage.includes('network')
+      || errorMessage.includes('connection')
+      || errorMessage.includes('econnrefused')
+      || errorMessage.includes('etimedout')
+      || errorMessage.includes('enotfound')
+      || errorMessage.includes('fetch failed');
+
+    if (isAuthError) {
+      // PERSISTENT — only the user can resolve. Long pause + broadcast so
+      // the Telegram fanout (and UI banner) tell them what's wrong.
       this.logger.warn(`Agent ${agentId} paused due to API key issue`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.API_KEY_ERROR_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'api-key-error');
 
-      // Add error message to agent's queue
       await this.agentPool.addToolResult(agentId, {
         toolId: 'system-error',
         status: 'failed',
@@ -2703,16 +2906,39 @@ class AgentScheduler {
         timestamp: new Date().toISOString()
       });
 
-    } else if (errorMessage.includes('rate limit') || errorMessage.includes('too many requests')) {
-      // Rate limit - delay agent
+      this._broadcastAgentError(agent, 'API key issue — check Settings → API Keys.', error);
+
+    } else if (isRateLimit) {
+      // TRANSIENT — provider asked us to back off. No broadcast.
       this.logger.warn(`Agent ${agentId} delayed due to rate limiting`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'rate-limit');
 
-    } else if (errorMessage.includes('network') || errorMessage.includes('connection')) {
-      // Network issues (non-timeout) - shorter delay and retry
+    } else if (isProviderOverload) {
+      // TRANSIENT — provider is over capacity (e.g. Anthropic 529). No
+      // broadcast: there's nothing actionable on the user's side. Reuse
+      // rate-limit's 2-min delay since the upstream advice is identical:
+      // "back off and try again."
+      this.logger.warn(`Agent ${agentId} delayed due to provider overload`);
+
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
+      await this.agentPool.persistAgentState(agentId);
+      await this.broadcastAgentStateUpdate(agentId, 'provider-overload');
+
+    } else if (isGatewayError) {
+      // TRANSIENT — 5xx / gateway / upstream timeout. Reuse the network
+      // 30-second delay; if it's still failing after a few retries it
+      // will eventually fall through to the unknown branch and broadcast.
+      this.logger.warn(`Agent ${agentId} delayed due to gateway/5xx error`);
+
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.NETWORK_ERROR_DELAY_MS).toISOString();
+      await this.agentPool.persistAgentState(agentId);
+      await this.broadcastAgentStateUpdate(agentId, 'gateway-error');
+
+    } else if (isNetworkError) {
+      // TRANSIENT — connectivity. No broadcast.
       this.logger.warn(`Agent ${agentId} delayed due to network issues`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.NETWORK_ERROR_DELAY_MS).toISOString();
@@ -2720,44 +2946,55 @@ class AgentScheduler {
       await this.broadcastAgentStateUpdate(agentId, 'network-error');
 
     } else if (this.isTokenLimitError(errorMessage)) {
-      // Token/context limit error - trigger emergency compaction and retry
+      // Token/context limit error — trigger emergency compaction and retry.
       await this.handleTokenLimitError(agentId, agent, error);
-      return; // Don't add error message or broadcast - will retry after compaction
+      return; // Don't add error message or broadcast — will retry after compaction.
 
     } else {
-      // Unknown error - pause agent and notify
+      // PERSISTENT (unknown shape) — we don't know what to do, so alert.
+      // The Telegram service's _registerErrorBroadcast dedup keeps this
+      // from flooding if the loop persists.
       this.logger.error(`Agent ${agentId} paused due to unknown AI service error: ${error.message}`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.UNKNOWN_ERROR_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'server-error');
 
-      // Add error message to agent's queue
       await this.agentPool.addToolResult(agentId, {
         toolId: 'system-error',
         status: 'failed',
         error: `AI service error: ${error.message}. Agent temporarily paused.`,
         timestamp: new Date().toISOString()
       });
-    }
 
-    // Broadcast error to UI
-    if (this.webSocketManager && this.webSocketManager.broadcastToSession) {
-      const sessionId = this.getAgentSession(agentId) || agent.sessionId || 'scheduler-session';
-      
-      // FIX: Wrap payload in 'data' field to match UI expectations
-      this.webSocketManager.broadcastToSession(sessionId, {
-        type: 'agent_error',
-        data: {
-          agentId: agentId,
-          error: error.message,
-          recovery: 'Agent temporarily paused for recovery',
-          timestamp: new Date().toISOString()
-        }
-      });
+      this._broadcastAgentError(agent, 'Agent temporarily paused for recovery', error);
     }
   }
 
+  /**
+   * Emit a `type: 'agent_error'` broadcast. Only called from the persistent
+   * failure branches (auth + unknown). Transient branches (rate-limit,
+   * provider-overload, gateway, network) deliberately do NOT broadcast —
+   * those used to flood Telegram every cycle and added no signal because
+   * the user couldn't act on them anyway.
+   *
+   * @private
+   */
+  _broadcastAgentError(agent, recovery, error) {
+    if (!this.webSocketManager || !this.webSocketManager.broadcastToSession) return;
+    const sessionId = this.getAgentSession(agent.id) || agent.sessionId || 'scheduler-session';
+    this.webSocketManager.broadcastToSession(sessionId, {
+      type: 'agent_error',
+      data: {
+        agentId:   agent.id,
+        agentName: agent.name,
+        error:     error.message,
+        recovery,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
   /**
    * Check if error message indicates a token/context limit error
    * @param {string} errorMessage - Lowercased error message
@@ -2765,7 +3002,7 @@ class AgentScheduler {
    * @private
    */
   isTokenLimitError(errorMessage) {
-    const tokenLimitPatterns = [
+    const substrings = [
       'prompt is too long',
       'tokens',
       'context length',
@@ -2774,15 +3011,15 @@ class AgentScheduler {
       'token limit',
       'max_tokens',
       'context_length_exceeded',
-      'maximum.*exceeded'
     ];
-
-    return tokenLimitPatterns.some(pattern => {
-      if (pattern.includes('.*')) {
-        return new RegExp(pattern).test(errorMessage);
-      }
-      return errorMessage.includes(pattern);
-    });
+    for (const p of substrings) {
+      if (errorMessage.includes(p)) return true;
+    }
+    // Match the old 'maximum.*exceeded' regex case without the regex:
+    // "maximum" followed somewhere later by "exceeded" in the same string.
+    const maxIdx = errorMessage.indexOf('maximum');
+    if (maxIdx !== -1 && errorMessage.indexOf('exceeded', maxIdx) !== -1) return true;
+    return false;
   }
 
   /**

package/src/index.js

@@ -20,12 +20,14 @@ import AgentScheduler from './core/agentScheduler.js';
 import ContextManager from './core/contextManager.js';
 import StateManager from './core/stateManager.js';
 import AIService from './services/aiService.js';
+import { EmbeddingService } from './services/embeddings/embeddingService.js';
+import { getUserDataPaths } from './utilities/userDataDir.js';
 import BudgetService from './services/budgetService.js';
 import ErrorHandler from './services/errorHandler.js';
 import BenchmarkService from './services/benchmarkService.js';
 import ModelRouterService from './services/modelRouterService.js';
 import ModelsService from './services/modelsService.js';
-import ApiKeyManager from './services/apiKeyManager.js';
+import ApiKeyManager, { registerApiKeyManager } from './services/apiKeyManager.js';
 import { getCredentialVault } from './services/credentialVault.js';
 import FileAttachmentService from './services/fileAttachmentService.js';
 import { ToolsRegistry } from './tools/baseTool.js';
@@ -51,7 +53,9 @@ 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';
 import SkillsTool from './tools/skillsTool.js';
 import VisionTool from './tools/visionTool.js';
 import UserPromptTool from './tools/userPromptTool.js';
@@ -275,6 +279,9 @@ class LoxiaApplication {
     // API Key Manager
     this.apiKeyManager = new ApiKeyManager(this.logger);
     await this.apiKeyManager.initialize(); // Load persisted keys
+    // Register the singleton so cross-cutting services (composioService,
+    // etc.) can resolve vendor keys without explicit injection.
+    registerApiKeyManager(this.apiKeyManager);
 
     // Credential Vault for secure website credential management
     this.credentialVault = getCredentialVault(this.logger);
@@ -324,9 +331,29 @@ class LoxiaApplication {
     
     // Set API Key Manager reference in AI Service
     this.aiService.setApiKeyManager(this.apiKeyManager);
-    
+
     // Set Agent Pool reference in AI Service
     this.aiService.setAgentPool(this.agentPool);
+
+    // Embedding Service — opt-in semantic retrieval layer. Boots in the
+    // disabled state by default; loadPersistedConfig() picks up whatever
+    // the user previously chose in Settings.
+    const stateDir = getUserDataPaths().state;
+    this.embeddingService = new EmbeddingService({
+      // Start with the in-memory default (disabled). The settings file
+      // (if present) will override this on the next line.
+      config: this.config?.embeddings || {},
+      apiKeyManager: this.apiKeyManager,
+      baseUrl: this.config?.backend?.baseUrl || this.aiService.baseUrl,
+      stateDir,
+      logger: this.logger,
+    });
+    await this.embeddingService.loadPersistedConfig();
+    this.aiService.setEmbeddingService(this.embeddingService);
+    this.logger.info('[Loxia] Embedding service ready', {
+      provider: this.embeddingService.config.provider,
+      enabled: this.embeddingService.isEnabled,
+    });
     
     // Initialize Model Routing Services
     this.benchmarkService = new BenchmarkService(this.config, this.logger);
@@ -486,17 +513,28 @@ class LoxiaApplication {
     // Register Help Tool (two-layer tool description system)
     await this.toolsRegistry.registerTool(HelpTool);
 
-    // Register Document (DOCX) Tool
+    // 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
+    // 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).
+    await this.toolsRegistry.registerTool(OfficeTool);
+
     // Register Memory Tool
     await this.toolsRegistry.registerTool(MemoryTool);
     await this.toolsRegistry.registerTool(SkillsTool);
     await this.toolsRegistry.registerTool(VisionTool);
 
+    // Register Composio integration tool (off by default — agents
+    // must have the `composio` capability AND the operator must set
+    // COMPOSIO_API_KEY for it to do anything).
+    await this.toolsRegistry.registerTool(ComposioTool);
+
     // Register User Prompt Tool
     await this.toolsRegistry.registerTool(UserPromptTool);
 
@@ -553,6 +591,14 @@ class LoxiaApplication {
       if (typeof platformControlTool.setStateManager === 'function') {
         platformControlTool.setStateManager(this.stateManager);
       }
+      // Memory tool's team-pool actions (publish/search/unpublish) need
+      // StateManager for the team-membership ACL check. The wiring is
+      // optional: when StateManager isn't attached, team-scoped actions
+      // refuse cleanly rather than defaulting open.
+      const memoryTool = this.toolsRegistry?.getTool?.('memory');
+      if (memoryTool && typeof memoryTool.setStateManager === 'function') {
+        memoryTool.setStateManager(this.stateManager);
+      }
       if (typeof platformControlTool.setMemoryService === 'function') {
         const { getMemoryService } = await import('./services/memoryService.js');
         platformControlTool.setMemoryService(getMemoryService(this.logger));
@@ -647,6 +693,34 @@ class LoxiaApplication {
       this.logger.info('WhatsAppService set for WhatsApp Tool');
     }
 
+    // ─── Catch-all aiService wiring ────────────────────────────────
+    //
+    // Several tools read `this.aiService.getEmbeddingService()` for their
+    // semantic-search / find-action paths (memory, agentcommunication,
+    // taskmanager, skills, composio) but have no `setAIService` method
+    // and were never wired by the explicit calls above. Production silently
+    // returned `this.aiService === undefined` → `_getIndexer()` returned
+    // null → every embedding-backed action surfaced "Embeddings are not
+    // enabled" even when embeddings WERE enabled (the user just hit this
+    // on composio.find-action; auto-recall in agentScheduler uses a
+    // different code path so it kept working, masking the wider gap).
+    //
+    // We sweep every registered tool here, AFTER the explicit per-tool
+    // wiring above. Tools that already have aiService set (image, vision,
+    // video, foundry-web-search, desktop) are skipped; everyone else
+    // gets it now. The assignment is harmless for tools that ignore the
+    // property.
+    {
+      let wired = 0;
+      for (const tool of this.toolsRegistry.tools.values()) {
+        if (!tool.aiService) {
+          tool.aiService = this.aiService;
+          wired++;
+        }
+      }
+      this.logger.info('AIService wired onto remaining tools', { count: wired });
+    }
+
     const toolCapabilities = this.toolsRegistry.getToolCapabilities();
     this.logger.info('Tools initialized', {
       toolCount: Object.keys(toolCapabilities).length,
@@ -721,6 +795,10 @@ class LoxiaApplication {
       // Set API Key Manager reference in Web Server
       webServer.setApiKeyManager(this.apiKeyManager);
 
+      // Embedding service handle so the /api/embeddings/* routes can
+      // read config + telemetry, hot-swap providers, etc.
+      webServer.embeddingService = this.embeddingService;
+
       // Set Credential Vault reference in Web Server
       webServer.setCredentialVault(this.credentialVault);