fix: filter cross-exercise build results via participation lookup

Artemis delivers build results for all of the user's participations over
a single WebSocket topic, and ResultDTO carries only a participationId,
not an exerciseId. TelemetryManager.onNewResult previously guarded only
against a missing active session, so a result from exercise A arriving
while exercise B was active would feed A's compiler errors into B's EQ
engine — producing phantom struggle signals on the wrong exercise.

- ExerciseRegistry now stores an optional participationId per exercise
  and exposes getExerciseIdByParticipation(). The reverse map is kept
  in sync on re-register (stale mappings dropped) and on clearCourse.
- registerFromCourseData extracts studentParticipations[0].id, and
  ExerciseOpeningService forwards it on individual registrations.
- TelemetryManager accepts an optional ExerciseRegistry and, on
  onNewResult, resolves result.participation.id → exerciseId. Known
  mismatches are dropped; unknown mappings are passed through (the
  registry may still be populating, and dropping real data is worse
  than a transient over-inclusive fallback).
- extension.ts constructs ExerciseRegistry before TelemetryManager so
  the dependency can be injected at creation time.

Drive-by fix in TelemetryManager.dispose(): the final _log call wrote
to an already-disposed output channel, throwing "Channel has been
closed". Moved the log before disposal — pre-existing bug that only
surfaced once a test disposed a TelemetryManager in a teardown hook.

Tests: 6 scenarios in telemetryManagerCrossExercise.test.ts cover
match, mismatch, unknown, missing, no-session, and session-switch
cases. 6 extra ExerciseRegistry tests cover the reverse-lookup
contract including stale-mapping cleanup and course clearing.

Author: Predixx

extension/src/extension.ts

@@ -45,7 +45,10 @@ export async function activate(context: vscode.ExtensionContext) {
 	const artemisApiService = new ArtemisApiService(authManager);
 	const artemisWebsocketService = new ArtemisWebsocketService(authManager);
 	const buildErrorCodeLensProvider = new BuildErrorCodeLensProvider();
-	const telemetryManager = new TelemetryManager();
+	// Created early because TelemetryManager needs it for participationId → exerciseId
+	// resolution when filtering WebSocket build results (prevents cross-exercise contamination).
+	const exerciseRegistry = new ExerciseRegistry();
+	const telemetryManager = new TelemetryManager(exerciseRegistry);
 	activeTelemetryManager = telemetryManager;
 
 	telemetryManager.setWebsocketService(artemisWebsocketService);
@@ -106,7 +109,7 @@ export async function activate(context: vscode.ExtensionContext) {
 	});
 
 	// ── Registries & providers ───────────────────────────────────────
-	const exerciseRegistry = new ExerciseRegistry();
+	// Note: exerciseRegistry is created earlier (above) so TelemetryManager can use it.
 	const courseDataCache = new CourseDataCache(artemisApiService);
 	context.subscriptions.push(courseDataCache);
 	const providerRegistry = createProviderRegistry();

extension/src/extension/services/exerciseRegistry.ts

@@ -3,13 +3,40 @@ import { logger } from './loggingService';
 
 export interface ExerciseRegistryEntry extends ExerciseRef {
     repositoryUri: string;
+    participationId?: number;
 }
 
 export class ExerciseRegistry {
     private exercises: Map<number, ExerciseRegistryEntry> = new Map();
+    /**
+     * Reverse lookup from participationId to exerciseId.
+     * Enables TelemetryManager to filter WebSocket build results by the
+     * currently-active exercise — the ResultDTO only carries a participationId,
+     * not an exerciseId, so without this map a result from exercise A would
+     * contaminate the EQ engine of the active exercise B.
+     */
+    private participationToExercise: Map<number, number> = new Map();
 
-    public registerExercise(id: number, title: string, repositoryUri: string, shortName?: string, courseId?: number): void {
-        this.exercises.set(id, { id, title, repositoryUri, shortName, courseId });
+    public registerExercise(id: number, title: string, repositoryUri: string, shortName?: string, courseId?: number, participationId?: number): void {
+        // If this exercise already had a different participationId, drop the old
+        // reverse mapping so it doesn't linger and match stale results.
+        const existing = this.exercises.get(id);
+        if (existing?.participationId !== undefined && existing.participationId !== participationId) {
+            this.participationToExercise.delete(existing.participationId);
+        }
+        this.exercises.set(id, { id, title, repositoryUri, shortName, courseId, participationId });
+        if (participationId !== undefined) {
+            this.participationToExercise.set(participationId, id);
+        }
+    }
+
+    /**
+     * Resolve a participationId to the exerciseId it belongs to.
+     * Returns undefined if the mapping is unknown (e.g. exercise was never
+     * registered, or course data did not contain a participation).
+     */
+    public getExerciseIdByParticipation(participationId: number): number | undefined {
+        return this.participationToExercise.get(participationId);
     }
 
     /**
@@ -25,6 +52,10 @@ export class ExerciseRegistry {
             }
         }
         for (const id of toDelete) {
+            const entry = this.exercises.get(id);
+            if (entry?.participationId !== undefined) {
+                this.participationToExercise.delete(entry.participationId);
+            }
             this.exercises.delete(id);
         }
         if (toDelete.length > 0) {
@@ -52,7 +83,7 @@ export class ExerciseRegistry {
                 id?: number;
                 title?: string;
                 shortName?: string;
-                studentParticipations?: Array<{ repositoryUri?: string }>
+                studentParticipations?: Array<{ id?: number; repositoryUri?: string }>
             };
             const participations = ex.studentParticipations || [];
 
@@ -62,7 +93,8 @@ export class ExerciseRegistry {
                     ex.title,
                     participations[0].repositoryUri,
                     ex.shortName,
-                    courseId
+                    courseId,
+                    typeof participations[0].id === 'number' ? participations[0].id : undefined,
                 );
                 registeredCount++;
                 registered.push(`${ex.id}: ${ex.title}`);

extension/src/extension/services/telemetry/telemetryManager.ts

@@ -23,6 +23,7 @@ import { ArtemisWebsocketService } from '../websocket/artemisWebsocketService';
 import { ResultDTO, WebSocketMessageHandler } from '../../types';
 import { VSCODE_CONFIG } from '../../utils/constants';
 import { logger, LogCategory } from '../loggingService';
+import type { ExerciseRegistry } from '../exerciseRegistry';
 
 /**
  * Central orchestration service for EQ-based struggle detection.
@@ -56,6 +57,7 @@ export class TelemetryManager implements vscode.Disposable, WebSocketMessageHand
     private readonly _sessionServices: SessionResettable[];
     private _activeExerciseId: number | undefined;
     private _lastTriggerType: TriggerType | undefined;
+    private readonly _exerciseRegistry: ExerciseRegistry | undefined;
     // Debug mode
     private _debugMode: boolean = false;
     private _debugStatusBarItem: vscode.StatusBarItem;
@@ -84,7 +86,8 @@ export class TelemetryManager implements vscode.Disposable, WebSocketMessageHand
         return this._interventionService.onDidDismissIntervention;
     }
 
-    constructor() {
+    constructor(exerciseRegistry?: ExerciseRegistry) {
+        this._exerciseRegistry = exerciseRegistry;
         this._outputChannel = vscode.window.createOutputChannel('Artemis Telemetry');
         this._disposables.push(this._outputChannel);
 
@@ -161,12 +164,15 @@ export class TelemetryManager implements vscode.Disposable, WebSocketMessageHand
 
         this.endCurrentSession();
 
+        // Log BEFORE disposing the output channel — otherwise _log() writes to
+        // an already-disposed channel and throws "Channel has been closed".
+        this._log('TelemetryManager disposed');
+
         while (this._disposables.length > 0) {
             this._disposables.pop()?.dispose();
         }
 
         this._onDidCalculateEQ.dispose();
-        this._log('TelemetryManager disposed');
     }
 
     // ==================== WebSocket Message Handler ====================
@@ -183,14 +189,27 @@ export class TelemetryManager implements vscode.Disposable, WebSocketMessageHand
             return;
         }
 
-        // Guard: Skip results when no exercise session is active (Edge Case 1b).
-        // ResultDTO has no exerciseId field, so we can't filter by exercise directly.
-        // The WebSocket subscription (personalResults) may deliver results for any exercise.
-        // Without an active session, results should not feed into EQ.
+        // Guard 1: Skip results when no exercise session is active (Edge Case 1b).
+        // The WebSocket subscription (personalResults) delivers results for any
+        // participation of the user, not just the active exercise's.
         if (this._activeExerciseId === undefined) {
             return;
         }
 
+        // Guard 2: Skip results that belong to a different exercise than the
+        // active session. ResultDTO only carries a participationId, so we
+        // resolve it through ExerciseRegistry. Policy: permissive on unknown
+        // mapping — if the registry has not yet learned this participationId
+        // (e.g. first course load not finished), we let the result through
+        // rather than dropping real data. Known mismatches are dropped.
+        const resultParticipationId = result.participation?.id;
+        if (resultParticipationId !== undefined && this._exerciseRegistry) {
+            const mappedExerciseId = this._exerciseRegistry.getExerciseIdByParticipation(resultParticipationId);
+            if (mappedExerciseId !== undefined && mappedExerciseId !== this._activeExerciseId) {
+                return;
+            }
+        }
+
         // Step 1: EQ snapshot FIRST (synchronous)
         const event = this._compileEmitter.handleBuildResult(result);
         if (event) {

extension/src/extension/services/ui/exerciseOpeningService.ts

@@ -31,7 +31,8 @@ export class ExerciseOpeningService {
                 exerciseTitle,
                 participations[0].repositoryUri,
                 exercise.shortName || '',
-                exercise.course?.id
+                exercise.course?.id,
+                typeof participations[0].id === 'number' ? participations[0].id : undefined,
             );
             logger.exercise(`Registered individual exercise: ${exerciseTitle}`);
         }

extension/test/unit/provider/exerciseRegistry.test.ts

@@ -57,6 +57,55 @@ suite('ExerciseRegistry Test Suite', () => {
         assert.strictEqual(exercises[0].courseId, 200);
     });
 
+    // --- participationId reverse-lookup (NEW-2 fix) ---
+
+    test('getExerciseIdByParticipation returns exerciseId for registered participation', () => {
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100, 5001);
+        assert.strictEqual(registry.getExerciseIdByParticipation(5001), 1);
+    });
+
+    test('getExerciseIdByParticipation returns undefined for unknown participation', () => {
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100, 5001);
+        assert.strictEqual(registry.getExerciseIdByParticipation(9999), undefined);
+    });
+
+    test('getExerciseIdByParticipation returns undefined when exercise registered without participationId', () => {
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100);
+        assert.strictEqual(registry.getExerciseIdByParticipation(5001), undefined);
+    });
+
+    test('re-registering same exercise with new participationId removes old reverse mapping', () => {
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100, 5001);
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100, 5002);
+        assert.strictEqual(registry.getExerciseIdByParticipation(5001), undefined, 'old participation must no longer resolve');
+        assert.strictEqual(registry.getExerciseIdByParticipation(5002), 1, 'new participation must resolve');
+    });
+
+    test('clearCourse removes participation reverse mappings for that course', () => {
+        registry.registerExercise(1, 'Ex1', 'https://git.example.com/ex1', 'ex1', 100, 5001);
+        registry.registerExercise(2, 'Ex2', 'https://git.example.com/ex2', 'ex2', 200, 5002);
+        registry.clearCourse(100);
+        assert.strictEqual(registry.getExerciseIdByParticipation(5001), undefined, 'cleared course participation must not resolve');
+        assert.strictEqual(registry.getExerciseIdByParticipation(5002), 2, 'other course participation must still resolve');
+    });
+
+    test('registerFromCourseData extracts participationId from studentParticipations', () => {
+        const courseData = {
+            course: {
+                id: 100,
+                exercises: [
+                    {
+                        id: 1,
+                        title: 'Ex1',
+                        studentParticipations: [{ id: 5001, repositoryUri: 'https://git.example.com/ex1' }]
+                    }
+                ]
+            }
+        };
+        registry.registerFromCourseData(courseData);
+        assert.strictEqual(registry.getExerciseIdByParticipation(5001), 1);
+    });
+
     test('should replace course exercises when re-registering from fresh course data', () => {
         // Initial registration
         const courseData1 = {

extension/test/unit/struggle-detection/telemetryManagerCrossExercise.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Regression tests for NEW-2: Cross-exercise build result contamination.
+ *
+ * Background: ResultDTO from the Artemis WebSocket carries only a participationId,
+ * never an exerciseId. Without a reverse lookup, a build result from exercise A
+ * would be fed into the EQ engine of the currently-active exercise B, producing
+ * phantom struggle signals.
+ *
+ * Fix: TelemetryManager accepts an ExerciseRegistry, and onNewResult resolves
+ * result.participation.id → exerciseId via the registry. Mismatches are dropped.
+ * Unknown mappings are passed through (permissive fallback so real data is not
+ * lost while the registry is still populating).
+ */
+
+import * as assert from 'assert';
+import { TelemetryManager } from '../../../src/extension/services/telemetry/telemetryManager';
+import { ExerciseRegistry } from '../../../src/extension/services/exerciseRegistry';
+import type { ResultDTO } from '../../../src/extension/domain';
+
+function makeResult(participationId: number | undefined, opts: { buildFailed?: boolean; successful?: boolean } = {}): ResultDTO {
+    return {
+        id: Math.floor(Math.random() * 1_000_000),
+        participation: participationId !== undefined ? { id: participationId } : undefined,
+        submission: opts.buildFailed !== undefined ? { buildFailed: opts.buildFailed } : undefined,
+        successful: opts.successful,
+    };
+}
+
+suite('TelemetryManager Cross-Exercise Filter (NEW-2 fix)', () => {
+    let registry: ExerciseRegistry;
+    let telemetry: TelemetryManager;
+
+    setup(() => {
+        registry = new ExerciseRegistry();
+        // Exercise A: exerciseId=1, participationId=5001
+        // Exercise B: exerciseId=2, participationId=5002
+        registry.registerExercise(1, 'Exercise A', 'git://a', 'exA', 100, 5001);
+        registry.registerExercise(2, 'Exercise B', 'git://b', 'exB', 100, 5002);
+        telemetry = new TelemetryManager(registry);
+    });
+
+    teardown(() => {
+        telemetry.dispose();
+    });
+
+    // Note: a failing build result causes *two* EQ fires — one with source='build'
+    // (from the snapshot add path) and one with source='trigger' (from the
+    // execution-error BoundaryTrigger). We count them together and only assert
+    // on the delta, so the guard logic is tested independently of that coupling.
+
+    test('result for active exercise is processed', () => {
+        telemetry.startExerciseSession(2); // active = B
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            telemetry.onNewResult(makeResult(5002, { buildFailed: true }));
+            assert.ok(fireCount > 0, 'EQ should update for active-exercise result');
+        } finally {
+            sub.dispose();
+        }
+    });
+
+    test('result for a different registered exercise is dropped', () => {
+        telemetry.startExerciseSession(2); // active = B
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            // Result belongs to A's participation while B is active → must be dropped
+            telemetry.onNewResult(makeResult(5001, { buildFailed: true }));
+            assert.strictEqual(fireCount, 0, 'EQ must not update for foreign-exercise result');
+        } finally {
+            sub.dispose();
+        }
+    });
+
+    test('result with unknown participation is passed through (permissive fallback)', () => {
+        telemetry.startExerciseSession(2);
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            // participationId 9999 is not in the registry → permissive: let it through
+            telemetry.onNewResult(makeResult(9999, { buildFailed: true }));
+            assert.ok(fireCount > 0, 'unknown mapping must not drop data');
+        } finally {
+            sub.dispose();
+        }
+    });
+
+    test('result without participation is passed through (permissive fallback)', () => {
+        telemetry.startExerciseSession(2);
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            telemetry.onNewResult(makeResult(undefined, { buildFailed: true }));
+            assert.ok(fireCount > 0, 'missing participation must not drop data');
+        } finally {
+            sub.dispose();
+        }
+    });
+
+    test('result is dropped when no session is active regardless of participation', () => {
+        // No startExerciseSession call
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            telemetry.onNewResult(makeResult(5002, { buildFailed: true }));
+            assert.strictEqual(fireCount, 0, 'no active session → no EQ update');
+        } finally {
+            sub.dispose();
+        }
+    });
+
+    test('after session switch, only results for new active exercise are accepted', () => {
+        telemetry.startExerciseSession(1); // active = A
+        let fireCount = 0;
+        const sub = telemetry.onDidCalculateEQ(() => { fireCount++; });
+        try {
+            // A-result → accepted
+            telemetry.onNewResult(makeResult(5001, { buildFailed: true }));
+            const afterA = fireCount;
+            assert.ok(afterA > 0, 'A-result on active session A must fire EQ');
+
+            telemetry.startExerciseSession(2); // switch to B
+
+            // Stale A-result arriving after switch → must be dropped
+            telemetry.onNewResult(makeResult(5001, { buildFailed: true }));
+            assert.strictEqual(fireCount, afterA, 'stale A-result after switch must be dropped');
+
+            // B-result → accepted
+            telemetry.onNewResult(makeResult(5002, { buildFailed: true }));
+            assert.ok(fireCount > afterA, 'B-result on active session B must fire EQ');
+        } finally {
+            sub.dispose();
+        }
+    });
+});