onbuzz 4.0.1 → 4.1.0

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

@@ -256,19 +256,27 @@ describe('AgentScheduler', () => {
 
   // ─── handleRepetitiveLoop ──────────────────────────────────────────────
   describe('handleRepetitiveLoop', () => {
-    test('switches agent to chat mode and adds intervention message', async () => {
-      const agent = makeAgent({ id: 'agent-loop' });
+    test('switches agent to chat mode without polluting the chat transcript', async () => {
+      // Loop detection is a system event, not conversation content. The mode
+      // flip is the action; the humanReason is surfaced via the
+      // `agent_mode_changed` broadcast so the UI can render a toast /
+      // notification-center entry. NO transcript bubble is added (previous
+      // behavior tripled-posted the same "I notice I've been producing
+      // similar responses..." text every time the loop tripped).
+      const agent = makeAgent({ id: 'agent-loop', mode: 'agent' });
       agentPool.getAgent.mockResolvedValue(agent);
 
       await scheduler.handleRepetitiveLoop('agent-loop', { occurrences: 5, windowSize: 20 });
 
       expect(agent.mode).toBe('chat');
-      expect(agent.conversations.full.messages.length).toBe(1);
-      const msg = agent.conversations.full.messages[0];
-      expect(msg.role).toBe('assistant');
-      expect(msg.content).toContain('similar responses repeatedly');
-      expect(msg.loopDetection.occurrences).toBe(5);
+      expect(agent.conversations.full.messages.length).toBe(0); // no chat bubble
       expect(agentPool.persistAgentState).toHaveBeenCalledWith('agent-loop');
+
+      // Mode transition was recorded with a human-readable reason.
+      const history = scheduler._modeTransitionHistory.get('agent-loop');
+      expect(history).toHaveLength(1);
+      expect(history[0].reasonCode).toBe('loop-detected');
+      expect(history[0].humanReason).toMatch(/repeated 5 times in a 20-step window/);
     });
 
     test('clears hash history after handling', async () => {
@@ -288,7 +296,8 @@ describe('AgentScheduler', () => {
     });
 
     test('broadcasts to websocket if available', async () => {
-      const agent = makeAgent({ id: 'agent-loop', sessionId: 'sess-abc' });
+      // See sibling test — needs mode:'agent' so the flip is a real transition.
+      const agent = makeAgent({ id: 'agent-loop', mode: 'agent', sessionId: 'sess-abc' });
       agentPool.getAgent.mockResolvedValue(agent);
       const ws = { broadcastToSession: jest.fn() };
       scheduler.webSocketManager = ws;
@@ -403,11 +412,20 @@ describe('AgentScheduler', () => {
 
       expect(agent.mode).toBe('chat');
       expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(false);
-      // User-facing intervention message appended
-      const msgs = agent.conversations.full.messages;
-      expect(msgs.length).toBe(1);
-      expect(msgs[0].role).toBe('assistant');
-      expect(msgs[0].content).toContain('empty responses');
+
+      // NO chat-transcript bubble — the stall is surfaced via the
+      // `agent_mode_changed` broadcast's `humanReason`, not a fake
+      // assistant message in the conversation. Previously every stall
+      // posted the same "I've switched to chat mode" paragraph into the
+      // feed, which operators (reasonably) complained about.
+      expect(agent.conversations.full.messages.length).toBe(0);
+
+      // The transition, however, is recorded with count + elapsedSec
+      // interpolated into the human reason.
+      const history = scheduler._modeTransitionHistory.get('agent-empty');
+      expect(history).toHaveLength(1);
+      expect(history[0].reasonCode).toBe('empty-response-stall');
+      expect(history[0].humanReason).toMatch(/5 empty responses/);
     });
 
     test('stall handler is crash-safe when persist throws', async () => {

package/src/core/__tests__/messageProcessor.sourceHeader.test.js

@@ -0,0 +1,195 @@
+/**
+ * MessageProcessor — source-header injection.
+ *
+ * Contract:
+ *   When a user message arrives carrying a `context.source` produced by
+ *   services/messageSource.js (Discord / Telegram ingress), the message
+ *   content queued on the agent is prefixed with a parenthesized
+ *   attribution line:
+ *
+ *       (Message by alice from Discord > MyGuild > #ops)
+ *       hi is anyone there?
+ *
+ *   The source object itself is also preserved on the queued message for
+ *   downstream consumers (relays, logs). Re-invocation with a message that
+ *   already carries the header is idempotent.
+ *
+ * These tests mock agentPool but exercise the real prependSourceHeader +
+ * createDiscordSource / createTelegramSource paths so the contract is
+ * verified end-to-end through the processMessage boundary.
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockAiService } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn(() => ({
+    isEnabled: () => false,
+    hasInstance: () => false,
+  })),
+  InstanceStatus: { IDLE: 'idle', RUNNING: 'running', ERROR: 'error' },
+}));
+
+jest.unstable_mockModule('../../utilities/tagParser.js', () => ({
+  default: jest.fn().mockImplementation(() => ({
+    extractToolCommands: jest.fn().mockReturnValue([]),
+    normalizeToolCommand: jest.fn((c) => c),
+    extractAgentRedirects: jest.fn().mockReturnValue([]),
+    parseXMLParameters: jest.fn().mockReturnValue({}),
+    decodeHtmlEntities: jest.fn((s) => s),
+  })),
+}));
+
+jest.unstable_mockModule('../../tools/visualEditorTool.js', () => ({
+  VisualEditorTool: { injectContextIntoMessage: jest.fn((msg) => msg) },
+}));
+
+// Import the REAL messageSource factories — this is intentional. The
+// integration value of these tests is the end-to-end contract between the
+// source module and the processor.
+const { createDiscordSource, createTelegramSource, createWebSource } =
+  await import('../../services/messageSource.js');
+const { default: MessageProcessor } = await import('../messageProcessor.js');
+
+function makeMP() {
+  const config = createMockConfig();
+  const logger = createMockLogger();
+  const agentPool = {
+    getAgent: jest.fn().mockResolvedValue({
+      id: 'agent-1',
+      name: 'TestAgent',
+      mode: 'chat',
+      conversations: { full: { messages: [] } },
+      messageQueues: { userMessages: [], interAgentMessages: [], toolResults: [] },
+    }),
+    addUserMessage: jest.fn().mockResolvedValue(undefined),
+    addInterAgentMessage: jest.fn().mockResolvedValue(undefined),
+  };
+  const contextManager = { getContext: jest.fn() };
+  const mp = new MessageProcessor(
+    config, logger, { getTool: jest.fn() }, agentPool, contextManager, createMockAiService()
+  );
+  return { mp, agentPool };
+}
+
+describe('MessageProcessor — source header injection', () => {
+  let mp, agentPool;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    ({ mp, agentPool } = makeMP());
+  });
+
+  test('Discord guild message → content prefixed with attribution line', async () => {
+    const source = createDiscordSource({
+      id: 'm1',
+      author: { id: 'u1', username: 'alice' },
+      guild: { id: 'g1', name: 'MyGuild' },
+      channel: { id: 'c1', name: 'ops', isThread: () => false },
+    });
+
+    await mp.processMessage('agent-1', 'hi is anyone there?', {
+      sessionId: 'discord-g1-c1',
+      source,
+    });
+
+    expect(agentPool.addUserMessage).toHaveBeenCalledTimes(1);
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe(
+      '(Message by alice from Discord > MyGuild > #ops)\nhi is anyone there?'
+    );
+    // Source is also preserved structurally for downstream consumers.
+    expect(queued.source).toBe(source);
+    expect(queued.role).toBe('user');
+  });
+
+  test('Telegram private message → Telegram > DM attribution', async () => {
+    const source = createTelegramSource({
+      message_id: 1,
+      chat: { id: 42, type: 'private' },
+      from: { id: 7, username: 'alice' },
+    });
+
+    await mp.processMessage('agent-1', 'status?', {
+      sessionId: 'telegram-42',
+      source,
+    });
+
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe('(Message by alice from Telegram > DM)\nstatus?');
+    expect(queued.source).toBe(source);
+  });
+
+  test('Discord thread message → parent + thread path in header', async () => {
+    const source = createDiscordSource({
+      id: 'm2',
+      author: { username: 'alice' },
+      guild: { id: 'g', name: 'MyGuild' },
+      channel: {
+        id: 't1', name: 'deploy-thread',
+        parentId: 'c1', parent: { name: 'ops' },
+        isThread: () => true,
+      },
+    });
+
+    await mp.processMessage('agent-1', 'deploy status?', { sessionId: 's', source });
+
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe(
+      '(Message by alice from Discord > MyGuild > #ops > deploy-thread)\ndeploy status?'
+    );
+  });
+
+  test('no source on context → content passes through untouched', async () => {
+    await mp.processMessage('agent-1', 'raw input', { sessionId: 's' });
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe('raw input');
+    expect(queued.source).toBeNull();
+  });
+
+  test('web source → no header (web UI interactions stay clean)', async () => {
+    const source = createWebSource({ sessionId: 'web-1', userName: 'operator' });
+    await mp.processMessage('agent-1', 'hello', { sessionId: 'web-1', source });
+
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe('hello');
+    expect(queued.source).toBe(source);  // structurally preserved even when no header rendered
+  });
+
+  test('idempotency — re-processing a message that already has the header does not double-prefix', async () => {
+    const source = createDiscordSource({
+      author: { username: 'alice' },
+      guild: { name: 'MyGuild' },
+      channel: { id: 'c', name: 'ops', isThread: () => false },
+    });
+
+    // First call — fresh content gets prefixed.
+    await mp.processMessage('agent-1', 'hi', { source });
+    const firstContent = agentPool.addUserMessage.mock.calls[0][1].content;
+    expect(firstContent.startsWith('(Message by alice')).toBe(true);
+
+    // Second call — pass the ALREADY-prefixed content back through (as
+    // would happen on replay / state-restore paths). The header must not
+    // be duplicated.
+    jest.clearAllMocks();
+    ({ mp, agentPool } = makeMP());
+    await mp.processMessage('agent-1', firstContent, { source });
+    const secondContent = agentPool.addUserMessage.mock.calls[0][1].content;
+    expect(secondContent).toBe(firstContent);
+    // i.e. not "(Message by alice ...)\n(Message by alice ...)\nhi"
+    const headerCount = (secondContent.match(/\(Message by alice/g) || []).length;
+    expect(headerCount).toBe(1);
+  });
+
+  test('unknown user fallback keeps the header well-formed', async () => {
+    const source = createDiscordSource({
+      // no author
+      guild: { name: 'G' },
+      channel: { id: 'c', name: 'general', isThread: () => false },
+    });
+    await mp.processMessage('agent-1', 'ping', { source });
+    const [, queued] = agentPool.addUserMessage.mock.calls[0];
+    expect(queued.content).toBe(
+      '(Message by unknown user from Discord > G > #general)\nping'
+    );
+  });
+});

package/src/core/agentPool.js

@@ -441,6 +441,15 @@ class AgentPool {
     // Persist the updated agent state
     await this.stateManager.persistAgentState(updatedAgent);
 
+    // Record the mode transition (both directions) into the scheduler's
+    // per-agent history. This is where UI-toggle and programmatic
+    // update_agent flips land — internal scheduler flips go through
+    // scheduler._transitionMode directly. Both feed the same ring buffer
+    // and the same /scheduler visualizer row.
+    if (updates.mode !== undefined && agent.mode !== updates.mode && this.scheduler?.recordModeTransition) {
+      this.scheduler.recordModeTransition(agentId, agent.mode, updates.mode, 'user-toggle');
+    }
+
     // CRITICAL: If agent was switched to AGENT mode, add it to scheduler
     if (updates.mode === AGENT_MODES.AGENT && this.scheduler) {
       // CRITICAL FIX: Use the session ID from updates first, then agent's sessionId