fix(harness): eliminate agent forking — use single shared agent across modes

.changeset/clear-buses-judge.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fixed signal providers losing memory access when harness forks agents per mode. Harness now propagates runtime services (memory, storage, etc.) to the base config agent during init so signal providers connected to it can deliver notifications.

packages/core/src/harness/fork-clone-metadata.test.ts

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { Agent } from '../agent';
 import { RequestContext } from '../request-context';
+import { SignalProvider } from '../signals/signal-provider';
 
 import { Harness } from './harness';
 import type * as Tools from './tools';
@@ -199,4 +200,59 @@ describe('Harness fork clone metadata wiring', () => {
     expect(builtIn.subagent).toBeDefined();
     expect(builtIn.ask_user).toBeDefined();
   });
+
+  it('propagates memory to the base config.agent so signal providers have access', async () => {
+    class TestSignalProvider extends SignalProvider<'test-signals'> {
+      readonly id = 'test-signals' as const;
+      getConnectedAgent() {
+        return this.agent;
+      }
+    }
+
+    const signalProvider = new TestSignalProvider();
+    const memoryFactory = vi.fn().mockResolvedValue({});
+
+    const baseAgent = new Agent({
+      name: 'base',
+      instructions: 'base agent',
+      model: { provider: 'openai', name: 'gpt-4o', toolChoice: 'auto' },
+      signals: [signalProvider],
+    });
+
+    // Signal provider is connected to the base agent
+    expect(signalProvider.isConnected).toBe(true);
+    expect(signalProvider.getConnectedAgent()).toBe(baseAgent);
+
+    // Before harness init, base agent has no memory
+    expect(baseAgent.hasOwnMemory()).toBe(false);
+
+    const harness = new Harness({
+      id: 'test',
+      resourceId: 'test-resource',
+      memory: memoryFactory as unknown as never,
+      modes: [
+        {
+          id: 'build',
+          name: 'Build',
+          default: true,
+          defaultModelId: 'openai/gpt-4o',
+          instructions: 'Build things.',
+        },
+        {
+          id: 'plan',
+          name: 'Plan',
+          defaultModelId: 'openai/gpt-4o',
+          instructions: 'Plan things.',
+        },
+      ],
+      agent: baseAgent,
+    });
+
+    await harness.init();
+
+    // After init, signal provider's connected agent (the base agent) should have memory
+    const connectedAgent = signalProvider.getConnectedAgent()!;
+    expect(connectedAgent).toBe(baseAgent);
+    expect(connectedAgent.hasOwnMemory()).toBe(true);
+  });
 });

packages/core/src/harness/harness.ts

@@ -630,6 +630,15 @@ export class Harness<TState = {}> {
       this.propagateRuntimeServicesToAgent(agent);
     }
 
+    // Also propagate runtime services to the base config agent so that signal
+    // providers connected to it during construction have access to memory and
+    // storage. Without this, signal providers (e.g. GitHubSignals) that were
+    // `connect()`-ed to the base agent before forking remain pointed at a
+    // memoryless instance and fail when attempting notification delivery.
+    if (this.config.agent) {
+      this.propagateRuntimeServicesToAgent(this.config.agent);
+    }
+
     this.startHeartbeats();
   }