onbuzz 5.0.2 → 5.3.0

package/src/tools/__tests__/webTool.recall.test.js

@@ -0,0 +1,167 @@
+/**
+ * Stage 4: web `recall` operation — semantic search over saved documents.
+ *
+ *  1. recall() method branches (fake DocumentMemory).
+ *  2. execute('recall') end-to-end with a REAL DocumentMemory (temp store +
+ *     real indexer + deterministic embeddings), asserting hits come back
+ *     top-level AND the browser is never launched (recall is browserless).
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import WebTool from '../webTool.js';
+import { DocumentMemory } from '../../services/documents/documentMemory.js';
+import { DocumentStore } from '../../services/documents/documentStore.js';
+import { DocumentIndexer } from '../../services/embeddings/indexers/documentIndexer.js';
+import { InMemoryJsonStore } from '../../services/embeddings/vectorStore/inMemoryJsonStore.js';
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+
+// ── recall() method branches ────────────────────────────────────────────
+describe('recall()', () => {
+  function tool() { return new WebTool({}, logger); }
+  function fakeMem({ enabled = true, hits = [] } = {}) {
+    return { embeddingsEnabled: enabled, recall: jest.fn(async () => ({ enabled, hits })) };
+  }
+
+  test('empty / whitespace query → error', async () => {
+    const wt = tool();
+    expect((await wt.recall('', { agentId: 'a' })).success).toBe(false);
+    expect((await wt.recall('   ', { agentId: 'a' })).success).toBe(false);
+  });
+
+  test('missing agentId → error', async () => {
+    expect((await tool().recall('q', {})).success).toBe(false);
+  });
+
+  test('embeddings OFF → success with note, no hits, recall not called', async () => {
+    const wt = tool();
+    const mem = fakeMem({ enabled: false });
+    wt._documentMemory = mem;
+    const r = await wt.recall('q', { agentId: 'a' });
+    expect(r.success).toBe(true);
+    expect(r.count).toBe(0);
+    expect(r.hits).toEqual([]);
+    expect(r.note).toMatch(/OFF/);
+    expect(mem.recall).not.toHaveBeenCalled();
+  });
+
+  test('embeddings ON → maps hits + count', async () => {
+    const wt = tool();
+    wt._documentMemory = fakeMem({
+      hits: [{ docId: 'd1', title: 'T', source: 'u', lineStart: 2, lineEnd: 4, score: 0.9, text: 'passage' }],
+    });
+    const r = await wt.recall('q', { agentId: 'a' });
+    expect(r.success).toBe(true);
+    expect(r.count).toBe(1);
+    expect(r.hits[0]).toEqual({ docId: 'd1', title: 'T', source: 'u', lineStart: 2, lineEnd: 4, score: 0.9, text: 'passage' });
+  });
+
+  test('docId restricts the search; default topK is 8', async () => {
+    const wt = tool();
+    const mem = fakeMem();
+    wt._documentMemory = mem;
+    await wt.recall('q', { agentId: 'a', docId: 'd1' });
+    expect(mem.recall).toHaveBeenCalledWith('a', 'q', { topK: 8, docId: 'd1' });
+  });
+
+  test('explicit topK is honoured; no docId omits the filter', async () => {
+    const wt = tool();
+    const mem = fakeMem();
+    wt._documentMemory = mem;
+    await wt.recall('q', { agentId: 'a', topK: 3 });
+    expect(mem.recall).toHaveBeenCalledWith('a', 'q', { topK: 3 });
+  });
+
+  test('invalid topK falls back to default 8', async () => {
+    const wt = tool();
+    const mem = fakeMem();
+    wt._documentMemory = mem;
+    await wt.recall('q', { agentId: 'a', topK: -5 });
+    expect(mem.recall).toHaveBeenCalledWith('a', 'q', { topK: 8 });
+  });
+});
+
+// ── execute('recall') end-to-end (real memory, no browser) ──────────────
+describe('execute(recall) end-to-end', () => {
+  let tmp;
+  let vecStore;
+  const vecFor = (t) => (String(t).toLowerCase().includes('alpha') ? Float32Array.from([1, 0, 0]) : Float32Array.from([0, 1, 0]));
+
+  beforeEach(async () => {
+    tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'webrecall-'));
+    vecStore = new InMemoryJsonStore({ filePath: path.join(tmp, 'documents.vec.json'), dimensions: 3, modelFingerprint: 'test' });
+    await vecStore.load();
+  });
+  afterEach(async () => { await fs.rm(tmp, { recursive: true, force: true }); });
+
+  function realMemory() {
+    const svc = {
+      isEnabled: true,
+      embedDocuments: async (texts) => texts.map(vecFor),
+      embedQuery: async (q) => vecFor(q),
+      getStore: async () => vecStore,
+    };
+    return new DocumentMemory({ store: new DocumentStore({ baseDir: tmp }), indexer: new DocumentIndexer({ embeddingService: svc }) });
+  }
+
+  test('recalls a previously-saved doc and never launches the browser', async () => {
+    const mem = realMemory();
+    await mem.remember('agent-r', { source: 'https://x/a', title: 'A', content: 'alpha '.repeat(80) });
+
+    const wt = new WebTool({}, logger);
+    wt._documentMemory = mem;
+    wt.ensureBrowser = jest.fn(async () => {}); // must NOT be called
+
+    const res = await wt.execute({ operation: 'recall', query: 'alpha', topK: 5 }, { agentId: 'agent-r', context: {} });
+
+    expect(res.success).toBe(true);
+    expect(res.count).toBeGreaterThan(0);
+    expect(res.hits[0].docId).toBeTruthy();
+    expect(res.hits[0]).toHaveProperty('lineStart');
+    expect(wt.ensureBrowser).not.toHaveBeenCalled(); // browserless op
+  });
+
+  test('recall with no matches returns success + empty hits (no browser)', async () => {
+    const mem = realMemory();
+    const wt = new WebTool({}, logger);
+    wt._documentMemory = mem;
+    wt.ensureBrowser = jest.fn(async () => {});
+    const res = await wt.execute({ operation: 'recall', query: 'nothing-here' }, { agentId: 'agent-empty', context: {} });
+    expect(res.success).toBe(true);
+    expect(res.count).toBe(0);
+    expect(wt.ensureBrowser).not.toHaveBeenCalled();
+  });
+
+  test('pin marks a saved doc and never launches the browser', async () => {
+    const mem = realMemory();
+    const h = await mem.remember('agent-r', { source: 'https://x/a', content: 'alpha '.repeat(80) });
+    const wt = new WebTool({}, logger);
+    wt._documentMemory = mem;
+    wt.ensureBrowser = jest.fn(async () => {});
+
+    const pinned = await wt.execute({ operation: 'pin', docId: h.docId }, { agentId: 'agent-r', context: {} });
+    expect(pinned.success).toBe(true);
+    expect(pinned.pinned).toBe(true);
+    expect(wt.ensureBrowser).not.toHaveBeenCalled();
+    expect((await mem.list('agent-r'))[0].pinned).toBe(true);
+
+    const unpinned = await wt.execute({ operation: 'pin', docId: h.docId, pinned: false }, { agentId: 'agent-r', context: {} });
+    expect(unpinned.pinned).toBe(false);
+  });
+});
+
+describe('pinDocument() guards', () => {
+  function tool() { return new WebTool({}, logger); }
+  test('missing docId / agentId → error', async () => {
+    expect((await tool().pinDocument('', { agentId: 'a' })).success).toBe(false);
+    expect((await tool().pinDocument('doc-1', {})).success).toBe(false);
+    expect((await tool().pinDocument('doc-1')).success).toBe(false); // no options (default arg)
+  });
+  test('unknown document → error', async () => {
+    const wt = tool();
+    wt._documentMemory = { pin: async () => null };
+    expect((await wt.pinDocument('doc-nope', { agentId: 'a' })).success).toBe(false);
+  });
+});

package/src/tools/__tests__/webTool.tabReuse.test.js

@@ -0,0 +1,349 @@
+/**
+ * Tab-reuse / efficient-interaction fixes for the web tool.
+ *
+ * Background: a real customer session ("CTF explorer") re-opened a fresh tab
+ * (open-tab + url) on 62 of 72 interactive calls, reloading the chatbot every
+ * turn and wiping its conversation — because switch-tab couldn't carry actions
+ * and top-level actions errored ("must be executed within a tab context"). These
+ * tests lock in the fixes: switch-tab/top-level actions run on the open page
+ * WITHOUT reloading, plus the accessibility snapshot action and humanMode default.
+ *
+ * The browser is stubbed and pages are mocked (the convention in webTool.*.test).
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+// Make human-like delays instant + deterministic, and COUNT them so we can
+// prove pacing is applied only to genuine input actions (efficiency under
+// 'maximum' stealth).
+const humanWaitMock = jest.fn(async () => {});
+jest.unstable_mockModule('../../utilities/humanBehavior.js', () => ({
+  createHumanCursor: () => ({ click: async () => {}, moveTo: async () => {} }),
+  humanType: async () => {},
+  humanWait: humanWaitMock,
+  humanScroll: async () => {},
+  humanSubmit: async () => {},
+}));
+
+const { default: WebTool } = await import('../webTool.js');
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+
+/** Mock page that models a stateful chat: goto() reloads → wipes state. */
+function makeChatPage(snapshotTree) {
+  const state = { messages: [] };
+  let gotoCount = 0;
+  return {
+    state,
+    gotoCalls: () => gotoCount,
+    url: () => 'http://fixture.local/chat',
+    goto: async () => { gotoCount += 1; state.messages = []; return { status: () => 200 }; },
+    content: async () => '<html><body>chat</body></html>',
+    close: async () => {},
+    on: () => {},
+    setCookie: async () => {},
+    $: async () => ({}),
+    click: async () => {},
+    type: async () => {},
+    // evaluate('send …') appends a message (deterministic stand-in for typing+sending).
+    evaluate: async (_cb, script) => {
+      if (typeof script === 'string' && script.includes('send')) {
+        state.messages.push('m' + (state.messages.length + 1));
+        return state.messages.length;
+      }
+      if (typeof script === 'string' && script.includes('count')) return state.messages.length;
+      return null;
+    },
+    accessibility: {
+      snapshot: async () => snapshotTree ?? {
+        role: 'WebArea', name: '', children: [
+          { role: 'heading', name: 'Negotiator' },
+          { role: 'textbox', name: 'Message', value: 'draft text' },
+          { role: 'button', name: 'Send', disabled: false },
+          { role: 'button', name: 'Cancel', disabled: true },
+          { role: 'generic', name: '', children: [{ role: 'link', name: 'Help' }] },
+          { role: 'checkbox', name: 'Remember me', checked: false },
+        ],
+      },
+    },
+  };
+}
+
+function makeTabInfo(page, humanMode = false) {
+  return {
+    page, url: 'http://fixture.local/chat', name: 'chat', humanMode,
+    pageErrors: [], networkFailures: [], httpErrors: [], consoleMessages: [], lastActivity: 0,
+  };
+}
+
+/** A WebTool with the browser stubbed and one named tab seeded. */
+function seeded({ agentId = 'a1', name = 'chat', page = makeChatPage(), active = false, humanMode = false } = {}) {
+  const wt = new WebTool({}, logger);
+  wt.ensureBrowser = async () => {};
+  wt.browser = { isConnected: () => true, _stealthConfig: { stealthLevel: 'standard' } };
+  wt.agentTabs.set(agentId, new Map([[name, makeTabInfo(page, humanMode)]]));
+  if (active) wt.agentActiveTab.set(agentId, name);
+  return { wt, page, agentId, name };
+}
+
+const run = (wt, actions, agentId = 'a1') =>
+  wt.interactive(actions, { agentId, stealthLevel: 'standard', humanMode: false });
+
+beforeEach(() => jest.clearAllMocks());
+
+describe('switch-tab carries actions (no reload)', () => {
+  test('runs nestedActions on the open tab without navigating', async () => {
+    const { wt, page } = seeded();
+    const r = await run(wt, [{ type: 'switch-tab', name: 'chat', nestedActions: [{ type: 'evaluate', script: 'send' }] }]);
+    expect(r.success).toBe(true);
+    expect(page.gotoCalls()).toBe(0);              // NO reload
+    expect(page.state.messages).toEqual(['m1']);   // action ran on the live page
+    expect(r.results[0].action).toBe('switch-tab');
+    expect(r.results[0].results[0].action).toBe('evaluate');
+    expect(wt.agentActiveTab.get('a1')).toBe('chat');
+  });
+
+  test('accepts the `actions` alias and reports failed actions', async () => {
+    const { wt } = seeded();
+    const r = await run(wt, [{ type: 'switch-tab', name: 'chat', actions: [{ type: 'evaluate' /* no script → fails */ }] }]);
+    expect(r.results[0].success).toBe(false);
+    expect(r.results[0].warning).toMatch(/1 of 1 action/);
+  });
+
+  test('bare switch-tab (no actions) just switches + sets active tab', async () => {
+    const { wt } = seeded();
+    const r = await run(wt, [{ type: 'switch-tab', name: 'chat' }]);
+    expect(r.results[0].message).toMatch(/Switched to tab 'chat'/);
+    expect(wt.agentActiveTab.get('a1')).toBe('chat');
+  });
+
+  test('switch-tab to an unknown tab fails gracefully (no throw to caller)', async () => {
+    const { wt } = seeded();
+    const r = await run(wt, [{ type: 'switch-tab', name: 'ghost' }]);
+    expect(r.results[0].success).toBe(false);
+    expect(r.results[0].error).toMatch(/not found/);
+  });
+});
+
+describe('top-level actions run on the active tab', () => {
+  test('a bare action targets the active tab (no reload, no context error)', async () => {
+    const { wt, page } = seeded({ active: true });
+    const r = await run(wt, [{ type: 'evaluate', script: 'send' }]);
+    expect(r.results[0].action).toBe('evaluate');
+    expect(r.results[0].success).toBe(true);
+    expect(page.gotoCalls()).toBe(0);
+    expect(page.state.messages).toEqual(['m1']);
+  });
+
+  test('with no active tab, returns a helpful error (not the old cryptic one)', async () => {
+    const { wt } = seeded({ active: false });
+    const r = await run(wt, [{ type: 'evaluate', script: 'send' }], 'noTabAgent');
+    expect(r.results[0].success).toBe(false);
+    expect(r.results[0].error).toMatch(/no active tab/i);
+    expect(r.results[0].error).not.toMatch(/must be executed within a tab context/);
+  });
+});
+
+describe('open-tab / close-tab active-tab tracking', () => {
+  test('open-tab on an existing tab reloads (url) and sets it active', async () => {
+    const { wt, page } = seeded();
+    const r = await run(wt, [{ type: 'open-tab', name: 'chat', url: 'http://fixture.local/chat', nestedActions: [{ type: 'evaluate', script: 'send' }] }]);
+    expect(r.results[0].success).toBe(true);
+    expect(page.gotoCalls()).toBe(1);              // url present → reload (the OLD pattern)
+    expect(wt.agentActiveTab.get('a1')).toBe('chat');
+  });
+
+  test('close-tab clears the active tab', async () => {
+    const { wt } = seeded({ active: true });
+    await run(wt, [{ type: 'close-tab', name: 'chat' }]);
+    expect(wt.agentActiveTab.has('a1')).toBe(false);
+  });
+
+  test('close-tab on a non-active tab leaves the active tab intact', async () => {
+    const { wt } = seeded({ active: true }); // active = 'chat'
+    wt.agentTabs.get('a1').set('other', makeTabInfo(makeChatPage()));
+    await run(wt, [{ type: 'close-tab', name: 'other' }]);
+    expect(wt.agentActiveTab.get('a1')).toBe('chat'); // unchanged
+  });
+
+  test('list-tabs reports the open tabs', async () => {
+    const { wt } = seeded({ active: true });
+    const r = await run(wt, [{ type: 'list-tabs' }]);
+    expect(r.results[0].success).not.toBe(false);
+  });
+});
+
+describe('snapshot (accessibility) action', () => {
+  test('returns interactive elements as role+name (and headings)', async () => {
+    const { wt } = seeded({ active: true });
+    const r = await run(wt, [{ type: 'snapshot' }]);
+    const snap = r.results[0];
+    expect(snap.success).toBe(true);
+    const roles = snap.elements.map(e => e.role);
+    expect(roles).toEqual(expect.arrayContaining(['heading', 'textbox', 'button', 'link', 'checkbox']));
+    expect(snap.elements.find(e => e.role === 'button').name).toBe('Send');
+    expect(snap.elements.find(e => e.role === 'checkbox').checked).toBe(false);
+    expect(snap.elements.find(e => e.role === 'textbox').value).toBe('draft text'); // value branch
+    expect(snap.elements.find(e => e.name === 'Cancel').disabled).toBe(true);        // disabled branch
+    expect(snap.elementCount).toBe(roles.length);
+  });
+
+  test('accessibility-snapshot alias + limit truncation', async () => {
+    const big = { role: 'WebArea', name: '', children: Array.from({ length: 5 }, (_, i) => ({ role: 'button', name: 'b' + i })) };
+    const { wt } = seeded({ active: true, page: makeChatPage(big) });
+    const r = await run(wt, [{ type: 'accessibility-snapshot', limit: 2 }]);
+    expect(r.results[0].elements).toHaveLength(2);
+    expect(r.results[0].truncated).toBe(3);
+  });
+
+  test('snapshot failure is reported, not thrown', async () => {
+    const page = makeChatPage();
+    page.accessibility.snapshot = async () => { throw new Error('no a11y'); };
+    const { wt } = seeded({ active: true, page });
+    const r = await run(wt, [{ type: 'snapshot' }]);
+    expect(r.results[0].success).toBe(false);
+    expect(r.results[0].error).toMatch(/Snapshot failed: no a11y/);
+  });
+});
+
+describe('_runActionsOnTab error collection', () => {
+  test('attaches js/network/http/console errors per action', async () => {
+    const { wt } = seeded();
+    const tab = makeTabInfo(makeChatPage());
+    wt.executeTabAction = async (page, action, tabInfo) => {
+      tabInfo.pageErrors.push({ message: 'boom' });
+      tabInfo.networkFailures.push({ method: 'GET', url: 'x', errorText: 'fail' });
+      tabInfo.httpErrors.push({ method: 'GET', url: 'y', status: 500 });
+      tabInfo.consoleMessages.push({ type: 'error', text: 'cerr' });
+      return { success: true };
+    };
+    const { results, failed } = await wt._runActionsOnTab(tab, [{ type: 'evaluate' }], {});
+    expect(failed).toBe(0);
+    expect(results[0].jsErrors).toEqual(['boom']);
+    expect(results[0].networkFailures[0]).toMatch(/GET x → fail/);
+    expect(results[0].httpErrors[0]).toMatch(/→ 500/);
+    expect(results[0].consoleErrors).toEqual(['cerr']);
+  });
+
+  test('a thrown action is captured as a failed result (not propagated)', async () => {
+    const { wt } = seeded();
+    const tab = makeTabInfo(makeChatPage());
+    wt.executeTabAction = async () => { throw new Error('kaboom'); };
+    const { results, failed } = await wt._runActionsOnTab(tab, [{ type: 'x' }], {});
+    expect(failed).toBe(1);
+    expect(results[0]).toMatchObject({ action: 'x', success: false, error: 'kaboom' });
+  });
+
+  test('humanMode tab waits between actions (branch coverage)', async () => {
+    const { wt } = seeded();
+    const tab = { ...makeTabInfo(makeChatPage()), humanMode: true };
+    wt.executeTabAction = async () => ({ success: true });
+    const { results } = await wt._runActionsOnTab(tab, [{ type: 'a' }, { type: 'b' }], {});
+    expect(results).toHaveLength(2);
+  });
+});
+
+describe('getDescription documents the efficient-interaction pattern', () => {
+  test('mentions snapshot + tab reuse + avoiding reload', () => {
+    const d = new WebTool({}, logger).getDescription();
+    expect(d).toMatch(/snapshot/);
+    expect(d).toMatch(/switch-tab/);
+    expect(d).toMatch(/RELOADS the page|avoids reloading/i);
+  });
+});
+
+describe('humanMode default tied to stealth (execute → interactive)', () => {
+  async function captureHumanMode(params) {
+    const wt = new WebTool({}, logger);
+    wt.ensureBrowser = async () => {};
+    wt.browser = { isConnected: () => true, _stealthConfig: { stealthLevel: params.stealthLevel || 'standard' } };
+    let captured;
+    wt.interactive = async (_actions, opts) => { captured = opts; return { success: true, results: [] }; };
+    await wt.execute({ operation: 'interactive', actions: [], ...params }, { agentId: 'a1' });
+    return captured.humanMode;
+  }
+  test("'standard' stealth → humanMode off (fast)", async () => {
+    expect(await captureHumanMode({ stealthLevel: 'standard' })).toBe(false);
+  });
+  test("'maximum' stealth → humanMode on", async () => {
+    expect(await captureHumanMode({ stealthLevel: 'maximum' })).toBe(true);
+  });
+  test('explicit humanMode:false wins even at maximum', async () => {
+    expect(await captureHumanMode({ stealthLevel: 'maximum', humanMode: false })).toBe(false);
+  });
+});
+
+describe('efficient under maximum stealth (humanMode)', () => {
+  test('tab reuse still avoids reloads with humanMode on', async () => {
+    const { wt, page } = seeded({ humanMode: true });
+    await run(wt, [{ type: 'switch-tab', name: 'chat', nestedActions: [{ type: 'type', selector: '#input', text: 'hi' }, { type: 'click', selector: '#submit' }] }]);
+    expect(page.gotoCalls()).toBe(0); // reuse, not reload — even under stealth
+  });
+
+  test('human pacing applies to input actions but NOT to observation actions', async () => {
+    const { wt } = seeded();
+    const tab = { ...makeTabInfo(makeChatPage(), true) };
+    wt.executeTabAction = async () => ({ success: true });
+    await wt._runActionsOnTab(tab, [
+      { type: 'type' }, { type: 'click' },        // paced (2)
+      { type: 'snapshot' }, { type: 'evaluate' }, // NOT paced
+      { type: 'extract-text' }, { type: 'wait-for' },
+    ], {});
+    // Only the 2 genuine input actions incur a human delay → no dead time on reads.
+    expect(humanWaitMock).toHaveBeenCalledTimes(2);
+  });
+
+  test('openTab reuse loop paces only input actions too', async () => {
+    const { wt } = seeded({ humanMode: true });
+    humanWaitMock.mockClear();
+    // open-tab reuse with url runs the openTab nested loop under humanMode.
+    await wt.interactive([{
+      type: 'open-tab', name: 'chat', url: 'http://fixture.local/chat',
+      nestedActions: [{ type: 'click', selector: '#submit' }, { type: 'evaluate', script: 'send' }],
+    }], { agentId: 'a1', stealthLevel: 'maximum', humanMode: true });
+    const actionDelays = humanWaitMock.mock.calls.filter(c => c[0] === 'action').length;
+    expect(actionDelays).toBe(1); // click only — evaluate (read) not paced
+  });
+
+  test('opening a NEW tab paces only input actions in its nested loop', async () => {
+    const { wt } = seeded();                 // a1 already has 'chat'
+    wt.createPage = async () => ({ page: makeChatPage(), cursor: null });
+    humanWaitMock.mockClear();
+    await wt.interactive([{
+      type: 'open-tab', name: 'fresh',       // no url → exercises the new-tab nested loop
+      nestedActions: [{ type: 'click', selector: '#submit' }, { type: 'evaluate', script: 'send' }],
+    }], { agentId: 'a1', stealthLevel: 'maximum', humanMode: true });
+    const actionDelays = humanWaitMock.mock.calls.filter(c => c[0] === 'action').length;
+    expect(actionDelays).toBe(1); // click only
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CONTROLLED EXPERIMENT — proves the fix: a 5-turn chatbot conversation.
+// OLD pattern (open-tab + url each turn) reloads every turn and loses state.
+// NEW pattern (open once, then switch-tab + actions) preserves the whole chat.
+// Same real dispatch code; only the call pattern differs.
+// ─────────────────────────────────────────────────────────────────────────────
+describe('EXPERIMENT: multi-turn chatbot — old vs new call pattern', () => {
+  const TURNS = 5;
+
+  test('OLD pattern: reloads every turn, conversation never accumulates', async () => {
+    const { wt, page } = seeded({ agentId: 'old' });
+    for (let i = 0; i < TURNS; i++) {
+      await run(wt, [{ type: 'open-tab', name: 'chat', url: 'http://fixture.local/chat', nestedActions: [{ type: 'evaluate', script: 'send' }] }], 'old');
+    }
+    expect(page.gotoCalls()).toBe(TURNS);          // 5 reloads
+    expect(page.state.messages).toHaveLength(1);    // state wiped each turn → only the last survives
+  });
+
+  test('NEW pattern: opens once, conversation accumulates across all turns', async () => {
+    const { wt, page } = seeded({ agentId: 'new' });
+    // Turn 1: open once (load the page).
+    await run(wt, [{ type: 'open-tab', name: 'chat', url: 'http://fixture.local/chat', nestedActions: [{ type: 'evaluate', script: 'send' }] }], 'new');
+    // Turns 2..N: reuse the open tab, no url → no reload.
+    for (let i = 1; i < TURNS; i++) {
+      await run(wt, [{ type: 'switch-tab', name: 'chat', nestedActions: [{ type: 'evaluate', script: 'send' }] }], 'new');
+    }
+    expect(page.gotoCalls()).toBe(1);               // ONE load for the whole conversation
+    expect(page.state.messages).toHaveLength(TURNS); // full 5-turn conversation preserved
+  });
+});

package/src/tools/baseTool.js

@@ -1041,8 +1041,7 @@ class ToolsRegistry {
       'skills': 'Knowledge',
       'agentcommunication': 'Collaboration',
       'help': 'System',
-      'doc': 'File Operations',
-      'spreadsheet': 'File Operations',
+      'office': 'File Operations',
       'whatsapp': 'Communication',
     };
 
@@ -1067,8 +1066,7 @@ class ToolsRegistry {
       'file-tree':            'ListBullet',
       'code-map':             'MapIcon',
       'pdf':                  'DocumentText',
-      'doc':                  'DocumentText',
-      'spreadsheet':          'TableCells',
+      'office':               'DocumentText',
       'staticanalysis':       'CodeBracket',
       'clonedetection':       'DocumentDuplicate',
       'import-analyzer':      'MagnifyingGlass',