mcpctl/.taskmaster/tasks/task_106.md

# Task ID: 106

**Title:** Implement Pause Queue for Model Studio

**Status:** done

**Dependencies:** 105 ✓

**Priority:** medium

**Description:** Add a pause queue in mcplocal that holds outgoing responses when model studio pause mode is active.

**Details:**

Create `src/mcplocal/src/proxymodel/pause-queue.ts`:

```typescript
interface PausedResponse {
  id: string;
  sessionId: string;
  contentType: 'prompt' | 'toolResult';
  sourceName: string;
  original: string;
  transformed: string;
  resolve: (content: string) => void;
  timestamp: number;
}

class PauseQueue {
  private paused = false;
  private queue: PausedResponse[] = [];
  private listeners = new Set<(items: PausedResponse[]) => void>();
  
  setPaused(paused: boolean): void {
    this.paused = paused;
    if (!paused) {
      // Release all paused items with their transformed content
      for (const item of this.queue) {
        item.resolve(item.transformed);
      }
      this.queue = [];
    }
    this.notifyListeners();
  }
  
  isPaused(): boolean {
    return this.paused;
  }
  
  async enqueue(item: Omit<PausedResponse, 'resolve' | 'id' | 'timestamp'>): Promise<string> {
    if (!this.paused) return item.transformed;
    
    return new Promise(resolve => {
      this.queue.push({
        ...item,
        id: crypto.randomUUID(),
        timestamp: Date.now(),
        resolve,
      });
      this.notifyListeners();
    });
  }
  
  editAndRelease(id: string, editedContent: string): void {
    const idx = this.queue.findIndex(q => q.id === id);
    if (idx >= 0) {
      const item = this.queue.splice(idx, 1)[0];
      item.resolve(editedContent);
      this.notifyListeners();
    }
  }
  
  releaseOne(id: string): void {
    const idx = this.queue.findIndex(q => q.id === id);
    if (idx >= 0) {
      const item = this.queue.splice(idx, 1)[0];
      item.resolve(item.transformed);
      this.notifyListeners();
    }
  }
  
  dropOne(id: string): void {
    const idx = this.queue.findIndex(q => q.id === id);
    if (idx >= 0) {
      const item = this.queue.splice(idx, 1)[0];
      item.resolve(''); // Empty response
      this.notifyListeners();
    }
  }
}

export const pauseQueue = new PauseQueue();
```

**Test Strategy:**

Unit tests: enqueue returns immediately when not paused, enqueue blocks when paused, releaseOne/editAndRelease/dropOne work correctly, setPaused(false) releases all.