lint

Author: toubatbrian

agents/src/ipc/proc_pool.test.ts

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { describe, expect, it, vi } from 'vitest';
 import type { RunningJobInfo } from '../job.js';
-import { JobStatus, type JobExecutor } from './job_executor.js';
+import { type JobExecutor, JobStatus } from './job_executor.js';
 import { ProcPool } from './proc_pool.js';
 
 function createMockExecutor() {

agents/src/voice/room_io/_output.test.ts

@@ -6,7 +6,7 @@ import { Future } from '../../utils.js';
 import { ParticipantAudioOutput } from './_output.js';
 
 describe('ParticipantAudioOutput waitForPlayoutTask', () => {
-  it('preserves duration queued by overlapping next segment', async () => {
+  it('resets tracked duration after non-interrupted playout', async () => {
     let resolvePlayout!: () => void;
     const waitForPlayout = new Promise<void>((resolve) => {
       resolvePlayout = resolve;
@@ -38,15 +38,61 @@ describe('ParticipantAudioOutput waitForPlayoutTask', () => {
 
     const task = output.waitForPlayoutTask(new AbortController());
 
-    // Simulate a new overlapping segment that starts before the previous flush completes.
-    output.pushedDuration += 0.5;
     resolvePlayout();
     await task;
 
-    expect(output.pushedDuration).toBe(0.5);
+    expect(output.pushedDuration).toBe(0);
     expect(onPlaybackFinished).toHaveBeenCalledWith({
       playbackPosition: 1.0,
       interrupted: false,
     });
   });
+
+  it('resets duration to queue state when interrupted flush clears overlap', async () => {
+    let resolvePlayout!: () => void;
+    const waitForPlayout = new Promise<void>((resolve) => {
+      resolvePlayout = resolve;
+    });
+
+    const output = Object.create(ParticipantAudioOutput.prototype) as ParticipantAudioOutput & {
+      pushedDuration: number;
+      interruptedFuture: Future<void>;
+      firstFrameEmitted: boolean;
+      audioSource: {
+        waitForPlayout: () => Promise<void>;
+        queuedDuration: number;
+        clearQueue: () => void;
+      };
+      onPlaybackFinished: (event: { playbackPosition: number; interrupted: boolean }) => void;
+      waitForPlayoutTask: (abortController: AbortController) => Promise<void>;
+    };
+
+    const onPlaybackFinished = vi.fn();
+    output.pushedDuration = 1.0;
+    output.interruptedFuture = new Future<void>();
+    output.firstFrameEmitted = true;
+    output.onPlaybackFinished = onPlaybackFinished;
+    output.audioSource = {
+      waitForPlayout: () => waitForPlayout,
+      queuedDuration: 500,
+      clearQueue: vi.fn(() => {
+        output.audioSource.queuedDuration = 0;
+      }),
+    };
+
+    const task = output.waitForPlayoutTask(new AbortController());
+
+    // Overlap from the next segment arrives before interruption.
+    output.pushedDuration += 0.5;
+    output.interruptedFuture.resolve();
+    resolvePlayout();
+    await task;
+
+    // interrupted path clears queued overlap, so duration should not retain stale overlap time.
+    expect(output.pushedDuration).toBe(0);
+    expect(onPlaybackFinished).toHaveBeenCalledWith({
+      playbackPosition: 0.5,
+      interrupted: true,
+    });
+  });
 });

agents/src/voice/room_io/_output.ts

@@ -387,8 +387,7 @@ export class ParticipantAudioOutput extends AudioOutput {
       this.audioSource.clearQueue();
     }
 
-    // Remove only this segment's duration; newer captured frames remain queued for the next flush.
-    this.pushedDuration -= accountedDuration;
+    this.pushedDuration = 0;
     this.interruptedFuture = new Future();
     this.firstFrameEmitted = false;