onbuzz 4.8.3 → 4.9.0

package/src/__tests__/composioCliFlags.test.js

@@ -0,0 +1,239 @@
+/**
+ * `loxia composio` CLI — flag parsing + subcommand wiring.
+ *
+ * The CLI uses HTTP against the running server, so a full end-to-end
+ * test would need to boot a real server. Instead we unit-test the
+ * pieces that don't need a live server:
+ *   - parseFlags: --json, --user, --args, --open, --help, positional
+ *   - subcommand handlers: with a stubbed http.request, verify they
+ *     hit the right URL with the right body and exit codes
+ *
+ * This catches the regressions that actually matter (broken arg parser,
+ * wrong path, missing JSON body) without paying the bootstrap cost.
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { _internal } from '../../bin/composio-cli.js';
+
+const { parseFlags, statusDot } = _internal;
+
+describe('parseFlags', () => {
+  test('captures positional args in order', () => {
+    const f = parseFlags(['connect', 'github']);
+    expect(f.positional).toEqual(['connect', 'github']);
+  });
+
+  test('--json sets the flag', () => {
+    expect(parseFlags(['toolkits', '--json']).json).toBe(true);
+    expect(parseFlags(['toolkits']).json).toBe(false);
+  });
+
+  test('--user accepts both --user X and --user=X', () => {
+    expect(parseFlags(['status', '--user', 'agent-42']).user).toBe('agent-42');
+    expect(parseFlags(['status', '--user=agent-42']).user).toBe('agent-42');
+  });
+
+  test('--args captures the JSON string for exec', () => {
+    const f = parseFlags(['exec', 'github', 'X', '--args', '{"per_page":3}']);
+    expect(f.args).toBe('{"per_page":3}');
+  });
+
+  test('--open is captured as boolean', () => {
+    expect(parseFlags(['connect', 'github', '--open']).open).toBe(true);
+  });
+
+  test('--help and -h both set help', () => {
+    expect(parseFlags(['--help']).help).toBe(true);
+    expect(parseFlags(['-h']).help).toBe(true);
+  });
+
+  test('unrecognised flags fall through to positional', () => {
+    // We don't whitelist; unknown flags survive in positional so the
+    // caller can decide what to do. (Defensive — protects against typos
+    // becoming silent no-ops.)
+    const f = parseFlags(['exec', 'gh', 'X', '--unknown']);
+    expect(f.positional).toContain('--unknown');
+  });
+});
+
+describe('statusDot', () => {
+  test('returns a coloured/raw character per status', () => {
+    // We don't assert on the exact ANSI codes (depends on TTY), but
+    // every variant produces a non-empty string.
+    for (const s of ['ACTIVE', 'INITIATED', 'FAILED', 'NOT_CONNECTED', null]) {
+      const dot = statusDot(s);
+      expect(typeof dot).toBe('string');
+      expect(dot.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+/* ---------------- Subcommand handlers (stubbed http) ---------------- */
+
+function makeDeps(routes) {
+  // Each route entry: { match: regex|string, method, response }
+  const http = {
+    request: jest.fn((url, opts, cb) => {
+      const u = new URL(url);
+      const route = routes.find(r => {
+        const m = r.match instanceof RegExp ? r.match.test(u.pathname) : u.pathname === r.match;
+        return m && (!r.method || r.method === opts.method);
+      });
+      const body = route ? route.response : { success: false, error: `unmatched ${opts.method} ${u.pathname}` };
+      const res = {
+        statusCode: route ? (route.status || 200) : 404,
+        on(evt, fn) {
+          if (evt === 'data') fn(JSON.stringify(body));
+          if (evt === 'end') fn();
+        },
+      };
+      setImmediate(() => cb(res));
+      return { on: () => {}, write: () => {}, end: () => {}, setTimeout: () => {}, destroy: () => {} };
+    }),
+  };
+  return {
+    http,
+    backend: { host: '127.0.0.1', port: 12345 },
+    args: [],
+  };
+}
+
+describe('cmdToolkits', () => {
+  test('hits GET /api/composio/toolkits and prints rows', async () => {
+    const deps = makeDeps([{ match: '/api/composio/toolkits', method: 'GET', response: { success: true, toolkits: [{ slug: 'github', name: 'GitHub' }] } }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdToolkits(deps, { json: false, positional: ['toolkits'] });
+      expect(deps.http.request).toHaveBeenCalled();
+      const calls = logSpy.mock.calls.flat().join('\n');
+      expect(calls).toMatch(/github/);
+      expect(calls).toMatch(/GitHub/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  test('--json emits the raw response', async () => {
+    const deps = makeDeps([{ match: '/api/composio/toolkits', method: 'GET', response: { success: true, toolkits: [] } }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdToolkits(deps, { json: true, positional: ['toolkits'] });
+      const out = logSpy.mock.calls.flat().join('\n');
+      expect(out).toMatch(/"success": true/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('cmdConnections', () => {
+  test('forwards userId in the query string', async () => {
+    const deps = makeDeps([{
+      match: /^\/api\/composio\/connections/,
+      method: 'GET',
+      response: { success: true, connections: [{ id: 'conn-1', toolkitSlug: 'github', status: 'ACTIVE' }] },
+    }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdConnections(deps, { json: false, user: 'agent-99', positional: ['connections'] });
+      const url = deps.http.request.mock.calls[0][0];
+      expect(url).toMatch(/userId=agent-99/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('cmdConnect', () => {
+  test('POSTs to /api/composio/connect with body { toolkitSlug, userId }', async () => {
+    const deps = makeDeps([{
+      match: '/api/composio/connect',
+      method: 'POST',
+      response: { success: true, connectLink: 'https://connect.composio.dev/link/x', connectionId: 'conn-1' },
+    }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdConnect(deps, { json: false, positional: ['connect', 'github'], user: 'operator' });
+      // Verify the body was JSON.stringified into write() — we get the
+      // call args via deps.http.request itself (we wrote {} body above
+      // but the real write happens on the returned req object).
+      const out = logSpy.mock.calls.flat().join('\n');
+      expect(out).toMatch(/Connect github/);
+      expect(out).toMatch(/connect\.composio\.dev/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('cmdDisconnect', () => {
+  test('routes UUID-style id to DELETE by-id', async () => {
+    const deps = makeDeps([{
+      match: /^\/api\/composio\/connections\/conn-abc-def-123-456/,
+      method: 'DELETE',
+      response: { success: true },
+    }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdDisconnect(deps, { json: false, positional: ['disconnect', 'conn-abc-def-123-456'] });
+      const url = deps.http.request.mock.calls[0][0];
+      expect(url).toMatch(/conn-abc-def-123-456/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  test('routes short slug to DELETE by-toolkit', async () => {
+    const deps = makeDeps([{
+      match: /^\/api\/composio\/connections\/by-toolkit/,
+      method: 'DELETE',
+      response: { success: true },
+    }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdDisconnect(deps, { json: false, positional: ['disconnect', 'github'], user: 'operator' });
+      const url = deps.http.request.mock.calls[0][0];
+      expect(url).toMatch(/by-toolkit/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});
+
+describe('cmdExec', () => {
+  test('parses --args as JSON and forwards', async () => {
+    const deps = makeDeps([{
+      match: '/api/composio/execute',
+      method: 'POST',
+      response: { success: true, output: { ok: 1 } },
+    }]);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await _internal.cmdExec(deps, {
+        json: false,
+        positional: ['exec', 'github', 'X'],
+        args: '{"per_page":3}',
+        user: 'operator',
+      });
+      const out = logSpy.mock.calls.flat().join('\n');
+      expect(out).toMatch(/X/);
+      expect(out).toMatch(/ok/);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  test('invalid --args JSON exits with helpful error', async () => {
+    const deps = makeDeps([]);
+    const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => { throw new Error('__exit__'); });
+    try {
+      await expect(_internal.cmdExec(deps, {
+        json: false, positional: ['exec', 'gh', 'X'], args: '{not-json',
+      })).rejects.toThrow('__exit__');
+      expect(errSpy.mock.calls.flat().join('\n')).toMatch(/Invalid --args/);
+    } finally {
+      errSpy.mockRestore();
+      exitSpy.mockRestore();
+    }
+  });
+});

package/src/core/__tests__/agentScheduler.codebaseKnowledge.test.js

@@ -0,0 +1,65 @@
+/**
+ * Contract tests for the `## CODEBASE KNOWLEDGE` injection in
+ * agentScheduler. Like the sibling tests for task-list and operating-
+ * posture, we source-grep rather than instantiating the heavy
+ * scheduler graph — the contract is: the injection block exists, sits
+ * in the right place, sources from the singleton service, and is
+ * wrapped in a graceful-degrade try/catch.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SRC = readFileSync(join(__dirname, '../agentScheduler.js'), 'utf-8');
+
+describe('agentScheduler — CODEBASE KNOWLEDGE injection', () => {
+  test('source contains the injection block', () => {
+    expect(SRC).toMatch(/Auto-inject CODEBASE KNOWLEDGE/);
+  });
+
+  test('injection sources from codebaseKnowledgeService singleton', () => {
+    expect(SRC).toMatch(/codebaseKnowledgeService/);
+    expect(SRC).toMatch(/getCodebaseKnowledgeService/);
+    expect(SRC).toMatch(/buildIndexBlock\(agentId\)/);
+  });
+
+  test('injection follows the CURRENT TASK LIST block (stable ordering for prompt cache)', () => {
+    const taskIdx = SRC.indexOf('CURRENT TASK LIST');
+    const cbIdx = SRC.indexOf('CODEBASE KNOWLEDGE');
+    expect(taskIdx).toBeGreaterThan(-1);
+    expect(cbIdx).toBeGreaterThan(-1);
+    expect(cbIdx).toBeGreaterThan(taskIdx);
+  });
+
+  test('graceful degrade: wrapped in try/catch with a `continuing without` warning', () => {
+    const block = SRC.slice(
+      SRC.indexOf('Auto-inject CODEBASE KNOWLEDGE'),
+      SRC.indexOf('Check if streaming is enabled'),
+    );
+    expect(block).toMatch(/try\s*\{/);
+    expect(block).toMatch(/catch\s*\(/);
+    expect(block).toMatch(/continuing without/);
+  });
+
+  test('REGRESSION: injection is GATED on the agent having code-map in capabilities', () => {
+    // Non-coder agents (chat-only, marketing agents, etc.) must not
+    // pay the per-turn service-lookup cost. The cache is only
+    // populated by code-map results — agents without code-map have
+    // nothing to surface.
+    const block = SRC.slice(
+      SRC.indexOf('Auto-inject CODEBASE KNOWLEDGE'),
+      SRC.indexOf('Check if streaming is enabled'),
+    );
+    // Must check capabilities for 'code-map' before doing anything.
+    expect(block).toMatch(/agent\.capabilities/);
+    expect(block).toMatch(/includes\(['"]code-map['"]\)/);
+    // The whole try-block should sit INSIDE that conditional, not
+    // outside it (otherwise the gate doesn't actually skip the work).
+    const guardIdx = block.indexOf('includes(\'code-map\')');
+    const tryIdx   = block.indexOf('try {');
+    expect(guardIdx).toBeGreaterThan(-1);
+    expect(tryIdx).toBeGreaterThan(guardIdx);
+  });
+});

package/src/core/__tests__/agentScheduler.memoryInjection.test.js

@@ -0,0 +1,78 @@
+/**
+ * Contract tests for the `## AGENT MEMORY` catalog injection and
+ * post-compaction nudge inside agentScheduler. We source-grep — the
+ * contracts are:
+ *   - The catalog injection block exists, is gated on the `memory`
+ *     capability, calls memoryService.getCatalog, lists `id  title`
+ *     compactly, and is wrapped in try/catch.
+ *   - The post-compaction nudge is a one-shot flag-driven block
+ *     keyed off `_postCompactionNudgePending`, and the flag is set
+ *     after the compaction step succeeds.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SRC = readFileSync(join(__dirname, '../agentScheduler.js'), 'utf-8');
+
+describe('agentScheduler — AGENT MEMORY catalog injection', () => {
+  test('source contains the AGENT MEMORY catalog injection header', () => {
+    expect(SRC).toMatch(/AGENT MEMORY \(catalog/);
+  });
+
+  test('injection sources from memoryService.getCatalog', () => {
+    expect(SRC).toMatch(/getMemoryService/);
+    expect(SRC).toMatch(/getCatalog\(agentId/);
+  });
+
+  test('injection is gated on the `memory` capability', () => {
+    const start = SRC.indexOf('Auto-inject AGENT MEMORY');
+    const block = SRC.slice(start, start + 1500);
+    expect(block).toMatch(/capabilities\.includes\(['"]memory['"]\)/);
+  });
+
+  test('injection follows the CODEBASE KNOWLEDGE block (stable ordering for prompt cache)', () => {
+    const cbIdx = SRC.indexOf('Auto-inject CODEBASE KNOWLEDGE');
+    const memIdx = SRC.indexOf('Auto-inject AGENT MEMORY');
+    expect(cbIdx).toBeGreaterThan(-1);
+    expect(memIdx).toBeGreaterThan(-1);
+    expect(memIdx).toBeGreaterThan(cbIdx);
+  });
+
+  test('graceful degrade: wrapped in try/catch', () => {
+    const start = SRC.indexOf('AGENT MEMORY');
+    const block = SRC.slice(Math.max(0, start - 600), start + 800);
+    expect(block).toMatch(/try\s*\{/);
+    expect(block).toMatch(/catch\s*\(/);
+  });
+});
+
+describe('agentScheduler — POST-COMPACTION NUDGE', () => {
+  test('source contains the POST-COMPACTION NUDGE block', () => {
+    expect(SRC).toMatch(/POST-COMPACTION NUDGE/);
+  });
+
+  test('nudge is driven by the _postCompactionNudgePending flag (one-shot)', () => {
+    expect(SRC).toMatch(/_postCompactionNudgePending/);
+    const block = SRC.slice(
+      SRC.indexOf('POST-COMPACTION NUDGE') - 200,
+      SRC.indexOf('POST-COMPACTION NUDGE') + 600,
+    );
+    // The flag is consumed (set false) after emission.
+    expect(block).toMatch(/_postCompactionNudgePending\s*=\s*false/);
+  });
+
+  test('the flag is set after the compaction step', () => {
+    // Look for a place that flips the flag to true (not false).
+    expect(SRC).toMatch(/_postCompactionNudgePending\s*=\s*true/);
+  });
+
+  test('nudge references AGENT MEMORY so the agent knows where to look', () => {
+    const start = SRC.indexOf('POST-COMPACTION NUDGE');
+    const block = SRC.slice(start, start + 1200);
+    expect(block).toMatch(/AGENT MEMORY/);
+    expect(block).toMatch(/memory read/);
+  });
+});

package/src/core/agentPool.js

@@ -889,6 +889,16 @@ class AgentPool {
       }
     }
 
+    // Clear codebase-knowledge cache for this agent — bytes live in
+    // the service's in-memory map; without this the per-agent entry
+    // would persist until the next process restart.
+    try {
+      const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
+      getCodebaseKnowledgeService(this.logger).clear(agentId);
+    } catch (e) {
+      this.logger.debug?.('codebase-knowledge clear failed on agent delete', { agentId, error: e.message });
+    }
+
     // Clean up visual editor instance
     try {
       const visualEditorBridge = getVisualEditorBridge();

package/src/core/agentScheduler.js

@@ -1638,6 +1638,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 +2157,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');

package/src/index.js

@@ -25,7 +25,7 @@ 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 +51,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 +277,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);
@@ -486,17 +491,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);