onbuzz 3.8.13 → 3.9.1

package/src/modules/fileExplorer/__tests__/rename.test.js

@@ -0,0 +1,178 @@
+/**
+ * File Explorer – rename endpoint tests
+ * Tests both the FileExplorerController.renameItem() business logic
+ * and the POST /rename route handler validation.
+ */
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import FileExplorerController from '../controller.js';
+import { createFileExplorerRouter } from '../routes.js';
+
+describe('FileExplorerController.renameItem', () => {
+  let tmpDir;
+  let controller;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fe-rename-'));
+    controller = new FileExplorerController({});
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  test('renames a file successfully', async () => {
+    const oldFile = path.join(tmpDir, 'old.txt');
+    await fs.writeFile(oldFile, 'hello');
+
+    const result = await controller.renameItem(oldFile, 'new.txt');
+
+    expect(result.success).toBe(true);
+    expect(result.data.name).toBe('new.txt');
+    expect(result.data.oldPath).toBe(path.resolve(oldFile));
+    expect(result.data.newPath).toBe(path.join(tmpDir, 'new.txt'));
+
+    // Verify on disk
+    await expect(fs.access(oldFile)).rejects.toThrow();
+    await expect(fs.access(path.join(tmpDir, 'new.txt'))).resolves.toBeUndefined();
+  });
+
+  test('renames a directory successfully', async () => {
+    const oldDir = path.join(tmpDir, 'old-dir');
+    await fs.mkdir(oldDir);
+    await fs.writeFile(path.join(oldDir, 'inner.txt'), 'x');
+
+    const result = await controller.renameItem(oldDir, 'new-dir');
+    expect(result.success).toBe(true);
+
+    const inner = await fs.readFile(path.join(tmpDir, 'new-dir', 'inner.txt'), 'utf8');
+    expect(inner).toBe('x');
+  });
+
+  test('rejects invalid characters in new name (slash)', async () => {
+    const oldFile = path.join(tmpDir, 'a.txt');
+    await fs.writeFile(oldFile, 'x');
+
+    const result = await controller.renameItem(oldFile, 'bad/name.txt');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Invalid file/directory name');
+  });
+
+  test('rejects invalid characters (colon, asterisk, etc.)', async () => {
+    const oldFile = path.join(tmpDir, 'a.txt');
+    await fs.writeFile(oldFile, 'x');
+
+    for (const badChar of [':', '*', '?', '"', '<', '>', '|', '\\']) {
+      const result = await controller.renameItem(oldFile, `name${badChar}.txt`);
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Invalid file/directory name');
+    }
+  });
+
+  test('rejects empty new name', async () => {
+    const oldFile = path.join(tmpDir, 'a.txt');
+    await fs.writeFile(oldFile, 'x');
+    const result = await controller.renameItem(oldFile, '');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Invalid file/directory name');
+  });
+
+  test('rejects when source does not exist', async () => {
+    const result = await controller.renameItem(path.join(tmpDir, 'nonexistent.txt'), 'new.txt');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Source path does not exist');
+  });
+
+  test('rejects when target name already exists', async () => {
+    await fs.writeFile(path.join(tmpDir, 'a.txt'), '1');
+    await fs.writeFile(path.join(tmpDir, 'b.txt'), '2');
+
+    const result = await controller.renameItem(path.join(tmpDir, 'a.txt'), 'b.txt');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('An item with that name already exists');
+  });
+
+  test('respects restrictedPaths configuration', async () => {
+    const restricted = new FileExplorerController({ restrictedPaths: [tmpDir] });
+    const oldFile = path.join(tmpDir, 'a.txt');
+    await fs.writeFile(oldFile, 'x');
+
+    const result = await restricted.renameItem(oldFile, 'new.txt');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Access to this path is restricted');
+  });
+});
+
+describe('POST /rename route handler', () => {
+  function getHandler(router) {
+    const layer = router.stack.find(l => l.route && l.route.path === '/rename');
+    expect(layer).toBeDefined();
+    const handlers = layer.route.stack;
+    return handlers[handlers.length - 1].handle;
+  }
+
+  function makeRes() {
+    const res = {
+      _status: 200,
+      _body: null,
+      status: jest.fn(function (code) { this._status = code; return this; }),
+      json: jest.fn(function (body) { this._body = body; return this; })
+    };
+    return res;
+  }
+
+  test('rejects missing oldPath with 400', async () => {
+    const router = createFileExplorerRouter();
+    const handler = getHandler(router);
+
+    const res = makeRes();
+    await handler({ body: { newName: 'new.txt' } }, res);
+    expect(res._status).toBe(400);
+    expect(res._body).toEqual({
+      success: false,
+      error: 'oldPath and newName are required'
+    });
+  });
+
+  test('rejects missing newName with 400', async () => {
+    const router = createFileExplorerRouter();
+    const handler = getHandler(router);
+
+    const res = makeRes();
+    await handler({ body: { oldPath: '/tmp/a.txt' } }, res);
+    expect(res._status).toBe(400);
+    expect(res._body.success).toBe(false);
+  });
+
+  test('returns 400 when controller reports failure', async () => {
+    const router = createFileExplorerRouter();
+    const handler = getHandler(router);
+
+    const res = makeRes();
+    // nonexistent path → controller returns success: false
+    await handler({ body: { oldPath: '/this/does/not/exist/zzz.txt', newName: 'new.txt' } }, res);
+    expect(res._status).toBe(400);
+    expect(res._body.success).toBe(false);
+  });
+
+  test('returns 200 with success on valid rename', async () => {
+    const router = createFileExplorerRouter();
+    const handler = getHandler(router);
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fe-rename-route-'));
+    try {
+      const oldFile = path.join(tmpDir, 'a.txt');
+      await fs.writeFile(oldFile, 'x');
+
+      const res = makeRes();
+      await handler({ body: { oldPath: oldFile, newName: 'b.txt' } }, res);
+
+      expect(res._status).toBe(200);
+      expect(res._body.success).toBe(true);
+      expect(res._body.data.name).toBe('b.txt');
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+});

package/src/tools/__tests__/taskManagerTool.memory.test.js

@@ -0,0 +1,303 @@
+/**
+ * Tests for task ↔ memory linking inside TaskManagerTool.
+ *
+ * Covers:
+ *   - _agentHasMemory: detects 'memory' capability on context.agent
+ *   - _storeDescriptionAsMemory: returns description unchanged if too short,
+ *     no capability, or memory service fails; otherwise creates a memory and
+ *     returns "[memory:mem-xxx] summary..."
+ *   - _extractMemoryRefs: pulls mem-xxx IDs out of task descriptions
+ *   - create action: long descriptions auto-stored as memory and replaced
+ *     with reference, included in returned task
+ *   - complete action: memoryHint emitted when task description references
+ *     a memory
+ *   - sync action: memoryHint included when synced tasks contain memory refs
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock the memory service before importing the tool
+const mockAddMemory = jest.fn();
+const mockInitialize = jest.fn().mockResolvedValue(undefined);
+jest.unstable_mockModule('../../services/memoryService.js', () => ({
+  getMemoryService: jest.fn(() => ({
+    initialize: mockInitialize,
+    addMemory: mockAddMemory
+  }))
+}));
+
+// Mock uuid for deterministic IDs
+let uuidCounter = 0;
+jest.unstable_mockModule('uuid', () => ({
+  v4: jest.fn(() => `mock-uuid-${++uuidCounter}`)
+}));
+
+const { default: TaskManagerTool } = await import('../taskManagerTool.js');
+
+function makeTool() {
+  const tool = new TaskManagerTool({ description: 'test' });
+  tool.logger = createMockLogger();
+  return tool;
+}
+
+function makeContext({ hasMemoryCapability = true, taskList = { tasks: [], lastUpdated: new Date().toISOString() } } = {}) {
+  const agent = {
+    id: 'agent-1',
+    name: 'Memory Test Agent',
+    capabilities: hasMemoryCapability ? ['memory', 'tools'] : ['tools'],
+    taskList
+  };
+  return {
+    agent,
+    context: {
+      agentId: 'agent-1',
+      agentName: 'Memory Test Agent',
+      agent,
+      agentPool: {
+        getAgent: jest.fn().mockResolvedValue(agent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      },
+      projectDir: '/tmp/test'
+    }
+  };
+}
+
+beforeEach(() => {
+  uuidCounter = 0;
+  mockAddMemory.mockReset();
+  mockInitialize.mockReset();
+  mockInitialize.mockResolvedValue(undefined);
+});
+
+describe('TaskManagerTool — task ↔ memory linking', () => {
+  // ── _agentHasMemory ──────────────────────────────────────────────
+  describe('_agentHasMemory', () => {
+    test('returns true when agent.capabilities includes "memory"', () => {
+      const tool = makeTool();
+      expect(tool._agentHasMemory({ agent: { capabilities: ['memory', 'web'] } })).toBe(true);
+    });
+
+    test('returns false when capabilities array does not contain "memory"', () => {
+      const tool = makeTool();
+      expect(tool._agentHasMemory({ agent: { capabilities: ['web', 'terminal'] } })).toBe(false);
+    });
+
+    test('returns false when agent has no capabilities array', () => {
+      const tool = makeTool();
+      expect(tool._agentHasMemory({ agent: {} })).toBeFalsy();
+    });
+
+    test('returns false when context has no agent', () => {
+      const tool = makeTool();
+      expect(tool._agentHasMemory({})).toBeFalsy();
+    });
+  });
+
+  // ── _storeDescriptionAsMemory ────────────────────────────────────
+  describe('_storeDescriptionAsMemory', () => {
+    test('returns description unchanged when shorter than 200 chars', async () => {
+      const tool = makeTool();
+      const { context } = makeContext();
+      const short = 'a short description';
+      const result = await tool._storeDescriptionAsMemory('agent-1', 'My Task', short, context);
+      expect(result).toBe(short);
+      expect(mockAddMemory).not.toHaveBeenCalled();
+    });
+
+    test('returns description unchanged when agent lacks memory capability', async () => {
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: false });
+      const long = 'x'.repeat(500);
+      const result = await tool._storeDescriptionAsMemory('agent-1', 'My Task', long, context);
+      expect(result).toBe(long);
+      expect(mockAddMemory).not.toHaveBeenCalled();
+    });
+
+    test('stores long description as memory and returns reference summary', async () => {
+      mockAddMemory.mockResolvedValueOnce({ id: 'mem-abc-123' });
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: true });
+
+      const long = 'This is a fairly long description that exceeds the 200-character threshold. '.repeat(5);
+      const result = await tool._storeDescriptionAsMemory('agent-1', 'Build API', long, context);
+
+      expect(mockInitialize).toHaveBeenCalled();
+      expect(mockAddMemory).toHaveBeenCalledWith('agent-1', expect.objectContaining({
+        title: 'task-context: Build API',
+        content: long,
+        description: 'Context for task "Build API"'
+      }));
+      expect(result).toMatch(/^\[memory:mem-abc-123\] /);
+      expect(result).toContain('...');
+      // Summary should be max 100 chars + the prefix + suffix
+      expect(result.length).toBeLessThan(200);
+    });
+
+    test('falls back to original description when memory service throws', async () => {
+      mockAddMemory.mockRejectedValueOnce(new Error('vault full'));
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: true });
+
+      const long = 'y'.repeat(500);
+      const result = await tool._storeDescriptionAsMemory('agent-1', 'Build', long, context);
+      expect(result).toBe(long);
+      expect(tool.logger.warn).toHaveBeenCalledWith(
+        'Failed to store task description as memory',
+        expect.objectContaining({ error: 'vault full', agentId: 'agent-1', taskTitle: 'Build' })
+      );
+    });
+
+    test('falls back when addMemory returns no id', async () => {
+      mockAddMemory.mockResolvedValueOnce({}); // no id field
+      const tool = makeTool();
+      const { context } = makeContext();
+      const long = 'z'.repeat(500);
+      const result = await tool._storeDescriptionAsMemory('agent-1', 'X', long, context);
+      expect(result).toBe(long);
+    });
+
+    test('handles empty description gracefully', async () => {
+      const tool = makeTool();
+      const { context } = makeContext();
+      expect(await tool._storeDescriptionAsMemory('agent-1', 'X', '', context)).toBe('');
+      expect(await tool._storeDescriptionAsMemory('agent-1', 'X', null, context)).toBeNull();
+      expect(mockAddMemory).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── _extractMemoryRefs ───────────────────────────────────────────
+  describe('_extractMemoryRefs', () => {
+    test('extracts mem-xxx IDs from task descriptions', () => {
+      const tool = makeTool();
+      const refs = tool._extractMemoryRefs([
+        { description: '[memory:mem-abc] do this' },
+        { description: '[memory:mem-xyz-456] another' },
+        { description: 'plain task without ref' }
+      ]);
+      expect(refs).toEqual(['mem-abc', 'mem-xyz-456']);
+    });
+
+    test('returns empty array when no memory refs present', () => {
+      const tool = makeTool();
+      expect(tool._extractMemoryRefs([
+        { description: 'just text' },
+        { description: '' },
+        { description: undefined }
+      ])).toEqual([]);
+    });
+
+    test('returns empty array for empty task list', () => {
+      const tool = makeTool();
+      expect(tool._extractMemoryRefs([])).toEqual([]);
+    });
+
+    test('only matches mem- prefix (not other [foo:bar] tags)', () => {
+      const tool = makeTool();
+      expect(tool._extractMemoryRefs([
+        { description: '[user:bob] hi' },
+        { description: '[memory:other-xyz] no' }, // not mem- prefix
+        { description: '[memory:mem-good] yes' }
+      ])).toEqual(['mem-good']);
+    });
+  });
+
+  // ── create action: auto-storing as memory ────────────────────────
+  describe('create action — auto-stores long description', () => {
+    test('replaces long description with memory reference when memory capability present', async () => {
+      mockAddMemory.mockResolvedValueOnce({ id: 'mem-task-1' });
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: true });
+
+      const longDesc = 'A very detailed task spec. '.repeat(20);
+      const result = await tool.execute(
+        { action: 'create', title: 'Implement Feature', description: longDesc, priority: 'high' },
+        context
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.task.description).toMatch(/^\[memory:mem-task-1\]/);
+      expect(mockAddMemory).toHaveBeenCalledWith('agent-1', expect.objectContaining({
+        title: 'task-context: Implement Feature',
+        content: longDesc
+      }));
+    });
+
+    test('keeps short description as-is (no memory creation)', async () => {
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: true });
+
+      const result = await tool.execute(
+        { action: 'create', title: 'Quick fix', description: 'Tiny note', priority: 'low' },
+        context
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.task.description).toBe('Tiny note');
+      expect(mockAddMemory).not.toHaveBeenCalled();
+    });
+
+    test('keeps long description as-is when agent has no memory capability', async () => {
+      const tool = makeTool();
+      const { context } = makeContext({ hasMemoryCapability: false });
+
+      const longDesc = 'Detailed.'.repeat(50);
+      const result = await tool.execute(
+        { action: 'create', title: 'No memory agent task', description: longDesc },
+        context
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.task.description).toBe(longDesc);
+      expect(mockAddMemory).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── complete action: memory cleanup hint ─────────────────────────
+  describe('complete action — emits memoryHint when task references a memory', () => {
+    test('includes memoryHint with the referenced memory ID', async () => {
+      const tool = makeTool();
+      const { agent, context } = makeContext({ hasMemoryCapability: true });
+      agent.taskList.tasks = [{
+        id: 'task-1',
+        title: 'Old Task',
+        description: '[memory:mem-context-99] summary text...',
+        status: 'in_progress',
+        priority: 'medium',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }];
+
+      const result = await tool.execute(
+        { action: 'complete', taskId: 'task-1' },
+        context
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.memoryHint).toContain('mem-context-99');
+      expect(result.result.memoryHint).toMatch(/cleaning up/i);
+    });
+
+    test('does not emit memoryHint when task has no memory reference', async () => {
+      const tool = makeTool();
+      const { agent, context } = makeContext();
+      agent.taskList.tasks = [{
+        id: 'task-1',
+        title: 'Plain task',
+        description: 'No reference here',
+        status: 'in_progress',
+        priority: 'medium',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }];
+
+      const result = await tool.execute(
+        { action: 'complete', taskId: 'task-1' },
+        context
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.memoryHint).toBeUndefined();
+    });
+  });
+});

package/src/tools/__tests__/visualEditorTool.broadcast.test.js

@@ -0,0 +1,219 @@
+/**
+ * Tests for VisualEditorTool's auto-open broadcast paths.
+ *
+ * The tool broadcasts a `visual_editor_open` WebSocket message to the web-ui
+ * whenever the agent runs `set-app-url` or `serve-static`. The broadcast tries
+ * three fallback paths to find a webServer reference (for resilience across
+ * different agent execution contexts):
+ *   1. context.agentPool.messageProcessor.orchestrator.webServer
+ *   2. context.orchestrator.webServer
+ *   3. global.loxiaWebServer
+ * If none are present, it logs a warning instead of throwing.
+ *
+ * These tests directly invoke the private _broadcastOpenEditor method since
+ * the public actions depend on heavy bridge/server initialization.
+ */
+
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock heavy dependencies that get pulled in at import time
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn(),
+  InstanceStatus: { CONNECTED: 'connected', DISCONNECTED: 'disconnected' }
+}));
+jest.unstable_mockModule('../../services/visualEditorServer.js', () => ({
+  getVisualEditorServer: jest.fn(),
+  getVisualEditorPort: jest.fn(() => 4000),
+  getVisualEditorBaseUrl: jest.fn(() => 'http://localhost:4000')
+}));
+jest.unstable_mockModule('../../services/portTracker.js', () => ({
+  getPortTracker: jest.fn()
+}));
+jest.unstable_mockModule('../../services/projectDetector.js', () => ({
+  getProjectDetector: jest.fn(),
+  PROJECT_TYPES: {}
+}));
+
+const { VisualEditorTool } = await import('../visualEditorTool.js');
+
+function makeTool() {
+  const tool = new VisualEditorTool({}, createMockLogger());
+  return tool;
+}
+
+const sampleData = {
+  agentId: 'agent-1',
+  appUrl: 'http://localhost:3000',
+  editorUrl: 'http://localhost:4000?agentId=agent-1&appUrl=http%3A%2F%2Flocalhost%3A3000'
+};
+
+describe('VisualEditorTool._broadcastOpenEditor', () => {
+  let originalGlobalServer;
+
+  beforeEach(() => {
+    originalGlobalServer = global.loxiaWebServer;
+    delete global.loxiaWebServer;
+  });
+
+  afterEach(() => {
+    if (originalGlobalServer !== undefined) {
+      global.loxiaWebServer = originalGlobalServer;
+    } else {
+      delete global.loxiaWebServer;
+    }
+  });
+
+  // ── Path 1: through agentPool ────────────────────────────────────
+  test('uses agentPool.messageProcessor.orchestrator.webServer when available', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    const context = {
+      sessionId: 'session-A',
+      agentPool: {
+        messageProcessor: {
+          orchestrator: {
+            webServer: { broadcastToSession }
+          }
+        }
+      }
+    };
+
+    tool._broadcastOpenEditor(context, sampleData);
+
+    expect(broadcastToSession).toHaveBeenCalledTimes(1);
+    expect(broadcastToSession).toHaveBeenCalledWith('session-A', {
+      type: 'visual_editor_open',
+      data: {
+        agentId: 'agent-1',
+        appUrl: 'http://localhost:3000',
+        editorUrl: sampleData.editorUrl
+      }
+    });
+  });
+
+  test('falls back to "web-session" when sessionId is missing on agentPool path', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    const context = {
+      agentPool: {
+        messageProcessor: {
+          orchestrator: { webServer: { broadcastToSession } }
+        }
+      }
+    };
+
+    tool._broadcastOpenEditor(context, sampleData);
+    expect(broadcastToSession).toHaveBeenCalledWith('web-session', expect.any(Object));
+  });
+
+  // ── Path 2: direct orchestrator ──────────────────────────────────
+  test('uses context.orchestrator.webServer when agentPool path missing', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    const context = {
+      sessionId: 'session-B',
+      orchestrator: { webServer: { broadcastToSession } }
+    };
+
+    tool._broadcastOpenEditor(context, sampleData);
+    expect(broadcastToSession).toHaveBeenCalledWith('session-B', expect.objectContaining({
+      type: 'visual_editor_open'
+    }));
+  });
+
+  test('prefers agentPool path over orchestrator path when both exist', () => {
+    const tool = makeTool();
+    const agentPoolBroadcast = jest.fn();
+    const orchestratorBroadcast = jest.fn();
+    const context = {
+      sessionId: 'session-C',
+      agentPool: {
+        messageProcessor: {
+          orchestrator: { webServer: { broadcastToSession: agentPoolBroadcast } }
+        }
+      },
+      orchestrator: { webServer: { broadcastToSession: orchestratorBroadcast } }
+    };
+
+    tool._broadcastOpenEditor(context, sampleData);
+    expect(agentPoolBroadcast).toHaveBeenCalled();
+    expect(orchestratorBroadcast).not.toHaveBeenCalled();
+  });
+
+  // ── Path 3: global fallback ──────────────────────────────────────
+  test('uses global.loxiaWebServer when context paths missing', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    global.loxiaWebServer = { broadcastToSession };
+
+    const context = { sessionId: 'session-D' };
+    tool._broadcastOpenEditor(context, sampleData);
+
+    expect(broadcastToSession).toHaveBeenCalledWith('session-D', expect.objectContaining({
+      type: 'visual_editor_open',
+      data: expect.objectContaining({ agentId: 'agent-1' })
+    }));
+  });
+
+  test('global fallback also defaults sessionId to "web-session"', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    global.loxiaWebServer = { broadcastToSession };
+
+    tool._broadcastOpenEditor({}, sampleData);
+    expect(broadcastToSession).toHaveBeenCalledWith('web-session', expect.any(Object));
+  });
+
+  // ── No webServer at all → warn but don't throw ───────────────────
+  test('logs warning when no webServer is reachable from any path', () => {
+    const tool = makeTool();
+    const context = {}; // Nothing at all
+
+    expect(() => tool._broadcastOpenEditor(context, sampleData)).not.toThrow();
+    expect(tool.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Could not broadcast open-editor')
+    );
+  });
+
+  test('handles partial agentPool object gracefully (no messageProcessor)', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    const context = {
+      agentPool: {}, // missing messageProcessor
+      orchestrator: { webServer: { broadcastToSession } }
+    };
+
+    // Should fall through to orchestrator path
+    tool._broadcastOpenEditor(context, sampleData);
+    expect(broadcastToSession).toHaveBeenCalled();
+  });
+
+  // ── Message shape ─────────────────────────────────────────────────
+  test('message data only contains agentId, appUrl, and editorUrl (no extra fields)', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    const context = {
+      orchestrator: { webServer: { broadcastToSession } },
+      sessionId: 's'
+    };
+
+    // Pass extra fields - they should not leak into the broadcast
+    tool._broadcastOpenEditor(context, { ...sampleData, extra: 'leaked', secret: 'hidden' });
+
+    const message = broadcastToSession.mock.calls[0][1];
+    expect(Object.keys(message.data).sort()).toEqual(['agentId', 'appUrl', 'editorUrl']);
+    expect(message.data.extra).toBeUndefined();
+    expect(message.data.secret).toBeUndefined();
+  });
+
+  test('message type is exactly "visual_editor_open"', () => {
+    const tool = makeTool();
+    const broadcastToSession = jest.fn();
+    tool._broadcastOpenEditor(
+      { orchestrator: { webServer: { broadcastToSession } } },
+      sampleData
+    );
+    expect(broadcastToSession.mock.calls[0][1].type).toBe('visual_editor_open');
+  });
+});