@1agh/maude 0.45.0 → 0.45.2

package/apps/studio/test/acp-transcript-view.test.ts

@@ -0,0 +1,71 @@
+// Pure unit tests for client/panels/transcript-view.js (Task C4).
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  DEFAULT_TRANSCRIPT_VIEW,
+  filterTranscriptParts,
+  TRANSCRIPT_VIEWS,
+  transcriptForcesExpand,
+} from '../client/panels/transcript-view.js';
+
+const PARTS = [
+  { type: 'reasoning', text: 'let me think' },
+  { type: 'tool-call', toolCallId: '1', toolName: 'Read file' },
+  { type: 'text', text: 'first answer' },
+  { type: 'reasoning', text: 'more thinking' },
+  { type: 'text', text: 'final answer' },
+];
+
+describe('filterTranscriptParts', () => {
+  test('normal hides reasoning, keeps text + tool-calls in order', () => {
+    const result = filterTranscriptParts(PARTS, 'normal');
+    expect(result.map((p) => p.type)).toEqual(['tool-call', 'text', 'text']);
+  });
+
+  test('thinking keeps everything, including reasoning', () => {
+    expect(filterTranscriptParts(PARTS, 'thinking')).toEqual(PARTS);
+  });
+
+  test('verbose also keeps everything (the extra verbosity is a render-detail toggle)', () => {
+    expect(filterTranscriptParts(PARTS, 'verbose')).toEqual(PARTS);
+  });
+
+  test('summary keeps ONLY the last text part', () => {
+    const result = filterTranscriptParts(PARTS, 'summary');
+    expect(result).toEqual([{ type: 'text', text: 'final answer' }]);
+  });
+
+  test('summary with no text parts at all returns empty, not a crash', () => {
+    expect(filterTranscriptParts([{ type: 'tool-call', toolCallId: '1' }], 'summary')).toEqual([]);
+  });
+
+  test('an unrecognized mode fails toward normal (less noise), not everything', () => {
+    expect(filterTranscriptParts(PARTS, 'nonsense')).toEqual(
+      filterTranscriptParts(PARTS, 'normal')
+    );
+  });
+
+  test('tolerates missing/empty input', () => {
+    expect(filterTranscriptParts(undefined, 'normal')).toEqual([]);
+    expect(filterTranscriptParts(null, 'thinking')).toEqual([]);
+    expect(filterTranscriptParts([], 'summary')).toEqual([]);
+  });
+});
+
+describe('transcriptForcesExpand', () => {
+  test('only verbose forces expansion', () => {
+    expect(transcriptForcesExpand('verbose')).toBe(true);
+    expect(transcriptForcesExpand('normal')).toBe(false);
+    expect(transcriptForcesExpand('thinking')).toBe(false);
+    expect(transcriptForcesExpand('summary')).toBe(false);
+    expect(transcriptForcesExpand(undefined)).toBe(false);
+  });
+});
+
+describe('constants', () => {
+  test('the view list + default are stable and consistent', () => {
+    expect(TRANSCRIPT_VIEWS).toEqual(['normal', 'thinking', 'verbose', 'summary']);
+    expect(TRANSCRIPT_VIEWS).toContain(DEFAULT_TRANSCRIPT_VIEW);
+  });
+});

package/apps/studio/test/acp-transcript.test.ts

@@ -1,11 +1,17 @@
 // acp/transcript — repo-level chat list + raw-transcript → clean-messages.
 
 import { afterEach, describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { deleteChat, listChats, readChatMessages } from '../acp/transcript.ts';
+import {
+  deleteChat,
+  listChats,
+  readChatMessages,
+  readChatMeta,
+  writeChatMeta,
+} from '../acp/transcript.ts';
 
 let root: string;
 afterEach(() => {
@@ -109,6 +115,73 @@ describe('deleteChat', () => {
     expect(listChats(designRoot).length).toBe(0);
     expect(deleteChat(designRoot, 'gone')).toBe(false);
   });
+
+  test('also removes the .meta.json and .session.json sidecars (Task C5)', () => {
+    const designRoot = seed('withmeta', [{ ts: 1, role: 'user', text: 'hi' }]);
+    writeChatMeta(designRoot, 'withmeta', { title: 'Renamed' });
+    writeFileSync(
+      join(designRoot, '_chat', 'withmeta.session.json'),
+      JSON.stringify({ sessionId: 'x' })
+    );
+    expect(deleteChat(designRoot, 'withmeta')).toBe(true);
+    expect(readChatMeta(designRoot, 'withmeta')).toEqual({});
+    expect(existsSync(join(designRoot, '_chat', 'withmeta.session.json'))).toBe(false);
+  });
+});
+
+describe('readChatMeta / writeChatMeta (Task C5 — rename + archive)', () => {
+  test('missing sidecar → {} (no override), never throws', () => {
+    const designRoot = seed('nometa', [{ ts: 1, role: 'user', text: 'hi' }]);
+    expect(readChatMeta(designRoot, 'nometa')).toEqual({});
+  });
+
+  test('a corrupt sidecar degrades to {} rather than throwing', () => {
+    const designRoot = seed('badmeta', [{ ts: 1, role: 'user', text: 'hi' }]);
+    writeFileSync(join(designRoot, '_chat', 'badmeta.meta.json'), '{not valid json');
+    expect(readChatMeta(designRoot, 'badmeta')).toEqual({});
+  });
+
+  test('writeChatMeta sets a title and it wins over the auto-derived one in listChats', () => {
+    const designRoot = seed('rn1', [
+      { ts: 1, role: 'user', text: 'the auto-derived first-line title' },
+    ]);
+    expect(listChats(designRoot)[0]?.title).toBe('the auto-derived first-line title');
+    expect(listChats(designRoot)[0]?.renamed).toBeFalsy();
+    writeChatMeta(designRoot, 'rn1', { title: 'My Renamed Chat' });
+    expect(listChats(designRoot)[0]?.title).toBe('My Renamed Chat');
+    expect(listChats(designRoot)[0]?.renamed).toBe(true);
+    expect(readChatMeta(designRoot, 'rn1')).toEqual({ title: 'My Renamed Chat' });
+  });
+
+  test('writeChatMeta merges — setting archived does not clobber an existing title', () => {
+    const designRoot = seed('rn2', [{ ts: 1, role: 'user', text: 'hi' }]);
+    writeChatMeta(designRoot, 'rn2', { title: 'Kept Title' });
+    writeChatMeta(designRoot, 'rn2', { archived: true });
+    expect(readChatMeta(designRoot, 'rn2')).toEqual({ title: 'Kept Title', archived: true });
+  });
+
+  test('archived chats are excluded from listChats but the transcript survives', () => {
+    const designRoot = seed('arch1', [{ ts: 1, role: 'user', text: 'archive me' }]);
+    writeChatMeta(designRoot, 'arch1', { archived: true });
+    expect(listChats(designRoot)).toEqual([]);
+    expect(readChatMessages(designRoot, 'arch1').length).toBe(1); // still readable directly
+  });
+
+  test('unarchiving (archived: false) brings the chat back into listChats', () => {
+    const designRoot = seed('arch2', [{ ts: 1, role: 'user', text: 'x' }]);
+    writeChatMeta(designRoot, 'arch2', { archived: true });
+    expect(listChats(designRoot)).toEqual([]);
+    writeChatMeta(designRoot, 'arch2', { archived: false });
+    expect(listChats(designRoot).length).toBe(1);
+  });
+
+  test('clearing a title (title: null) falls back to the auto-derived one again', () => {
+    const designRoot = seed('rn3', [{ ts: 1, role: 'user', text: 'original first line' }]);
+    writeChatMeta(designRoot, 'rn3', { title: 'Overridden' });
+    expect(listChats(designRoot)[0]?.title).toBe('Overridden');
+    writeChatMeta(designRoot, 'rn3', { title: null });
+    expect(listChats(designRoot)[0]?.title).toBe('original first line');
+  });
 });
 
 describe('context-hardening projection (feature-acp-context-hardening)', () => {

package/apps/studio/test/acp-usage-bridge.test.ts

@@ -0,0 +1,136 @@
+// Proves the usage-channel harvest (Milestone D, Task D1) end-to-end against
+// a mock ACP agent (fixtures/mock-acp-agent-usage.mjs) — no real `claude`
+// needed. Covers: onUsage fires with {used,size,cost}, the rate-limit _meta
+// payload is carried through opaque, usage_update never leaks into onUpdate
+// (chrome, not turn content), and the Acp manager caches + replays it to a
+// freshly-opened socket.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { join } from 'node:path';
+
+import type { ServerWebSocket } from 'bun';
+
+import { AcpBridge, type BridgeUsage } from '../acp/bridge.ts';
+import { createAcp } from '../acp/index.ts';
+import type { Context } from '../context.ts';
+import type { WsData } from '../ws.ts';
+
+const FIXTURE = join(import.meta.dir, 'fixtures', 'mock-acp-agent-usage.mjs');
+const TEST_ENV_KEYS = ['MAUDE_ACP_ADAPTER_ENTRY', 'MAUDE_ACP_RUNTIME', 'MAUDE_CLAUDE_BIN'];
+
+function useMockAgent() {
+  process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+  process.env.MAUDE_ACP_RUNTIME = process.execPath;
+  process.env.MAUDE_CLAUDE_BIN = process.execPath;
+}
+
+afterEach(() => {
+  for (const key of TEST_ENV_KEYS) delete process.env[key];
+});
+
+async function until<T>(fn: () => T | undefined, timeoutMs = 12000): Promise<T> {
+  const start = performance.now();
+  for (;;) {
+    const v = fn();
+    if (v !== undefined) return v;
+    if (performance.now() - start > timeoutMs) throw new Error('timeout waiting for condition');
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
+function fakeWs(id: string) {
+  const frames: Array<Record<string, unknown>> = [];
+  const ws = {
+    data: { id } as WsData,
+    send: (raw: string) => {
+      frames.push(JSON.parse(raw));
+    },
+  } as unknown as ServerWebSocket<WsData>;
+  return { ws, frames };
+}
+
+describe('AcpBridge — usage harvest (Task D1)', () => {
+  test('onUsage fires with used/size/cost; usage_update never reaches onUpdate', async () => {
+    useMockAgent();
+    const usages: BridgeUsage[] = [];
+    const updates: unknown[] = [];
+    const bridge = new AcpBridge({
+      repoRoot: process.cwd(),
+      onUpdate: (u) => updates.push(u),
+      onUsage: (u) => usages.push(u),
+    });
+    try {
+      await bridge.prompt('hi', 'c1');
+      const usage = await until(() => (usages.length ? usages[usages.length - 1] : undefined));
+      expect(usage.used).toBe(4200);
+      expect(usage.size).toBe(200000);
+      expect(usage.cost).toEqual({ amount: 0.0123, currency: 'USD' });
+      expect(bridge.usage).toEqual(usage);
+      // chrome, not turn content — no usage_update leaked into onUpdate
+      expect(
+        updates.some((u) => (u as { sessionUpdate?: string }).sessionUpdate === 'usage_update')
+      ).toBe(false);
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('the rate-limit _meta payload is carried through opaque', async () => {
+    useMockAgent();
+    const usages: BridgeUsage[] = [];
+    const bridge = new AcpBridge({
+      repoRoot: process.cwd(),
+      onUpdate: () => {},
+      onUsage: (u) => usages.push(u),
+    });
+    try {
+      await bridge.prompt('trigger-rate-limit', 'c1');
+      const withRateLimit = await until(() => usages.find((u) => u.rateLimit != null));
+      expect(withRateLimit.rateLimit).toMatchObject({
+        status: 'allowed_warning',
+        rateLimitType: 'five_hour',
+        utilization: 82,
+      });
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('no usage yet → bridge.usage is null', async () => {
+    useMockAgent();
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      expect(bridge.usage).toBeNull();
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+});
+
+describe('Acp manager — usage frame is cached + replayed on a fresh socket (Task D1)', () => {
+  test('a usage frame is broadcast during a turn, then replayed to a newly-opened socket', async () => {
+    useMockAgent();
+    const ctx = {
+      paths: { repoRoot: process.cwd(), designRoot: '/tmp/does-not-matter-usage' },
+    } as unknown as Context;
+    const acp = createAcp(ctx);
+
+    const a = fakeWs('usage-ws-a');
+    try {
+      acp.onOpen(a.ws);
+      acp.onMessage(a.ws, JSON.stringify({ t: 'prompt', text: 'hi', chat: 'c1' }));
+      const usageFrame = await until(() => a.frames.find((f) => f.t === 'usage'));
+      expect((usageFrame.usage as BridgeUsage).used).toBe(4200);
+
+      const b = fakeWs('usage-ws-b');
+      acp.onOpen(b.ws);
+      const replay = b.frames.find((f) => f.t === 'usage');
+      if (!replay) throw new Error('expected a replayed usage frame');
+      expect((replay.usage as BridgeUsage).used).toBe(4200);
+      acp.onClose(b.ws);
+    } finally {
+      acp.onClose(a.ws);
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }, 20000);
+});

package/apps/studio/test/acp-usage.test.ts

@@ -0,0 +1,143 @@
+// Pure unit tests for client/panels/acp-usage.js — parseUsage (Tasks D2/D4).
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseUsage } from '../client/panels/acp-usage.js';
+
+const NOW = 1_700_000_000_000;
+
+describe('parseUsage — context + cost', () => {
+  test('computes a rounded percentage from used/size', () => {
+    const result = parseUsage({ t: 'usage', usage: { used: 4200, size: 200000 } }, NOW);
+    expect(result.context).toEqual({ used: 4200, size: 200000, pct: 2 });
+    expect(result.asOf).toBe(NOW);
+  });
+
+  test('clamps the percentage to [0,100] against a bogus used > size', () => {
+    const result = parseUsage({ usage: { used: 999999, size: 1000 } }, NOW);
+    expect(result.context?.pct).toBe(100);
+  });
+
+  test('size:0 (or missing) yields no context gauge rather than dividing by zero', () => {
+    expect(parseUsage({ usage: { used: 10, size: 0 } }, NOW).context).toBeNull();
+    expect(parseUsage({ usage: { used: 10 } }, NOW).context).toBeNull();
+  });
+
+  test('carries cost through, defaulting currency to USD when absent', () => {
+    const result = parseUsage(
+      { usage: { used: 1, size: 2, cost: { amount: 0.5, currency: 'EUR' } } },
+      NOW
+    );
+    expect(result.cost).toEqual({ amount: 0.5, currency: 'EUR' });
+  });
+
+  test('no cost on the frame → null, not undefined/0', () => {
+    expect(parseUsage({ usage: { used: 1, size: 2 } }, NOW).cost).toBeNull();
+  });
+});
+
+describe('parseUsage — rate limit (SDKRateLimitInfo fixtures)', () => {
+  const TYPES = [
+    ['five_hour', '5-hour limit'],
+    ['seven_day', 'Weekly limit'],
+    ['seven_day_opus', 'Weekly · Opus'],
+    ['seven_day_sonnet', 'Weekly · Sonnet'],
+    ['seven_day_overage_included', 'Weekly (overage included)'],
+    ['overage', 'Overage'],
+  ];
+
+  for (const [type, label] of TYPES) {
+    test(`maps rateLimitType "${type}" → "${label}"`, () => {
+      const result = parseUsage(
+        {
+          usage: {
+            used: 1,
+            size: 2,
+            rateLimit: {
+              status: 'allowed_warning',
+              rateLimitType: type,
+              utilization: 61,
+              resetsAt: 123,
+            },
+          },
+        },
+        NOW
+      );
+      expect(result.rateLimit).toEqual({
+        type,
+        label,
+        pct: 61,
+        resetsAt: 123,
+        status: 'allowed_warning',
+      });
+    });
+  }
+
+  test('an unrecognized rateLimitType falls back to a generic label, not undefined', () => {
+    const result = parseUsage(
+      {
+        usage: {
+          used: 1,
+          size: 2,
+          rateLimit: { status: 'rejected', rateLimitType: 'something_new' },
+        },
+      },
+      NOW
+    );
+    expect(result.rateLimit?.label).toBe('Usage limit');
+  });
+
+  test('null/missing rate-limit on the frame → gauge-only (rateLimit: null), no crash', () => {
+    expect(parseUsage({ usage: { used: 1, size: 2, rateLimit: null } }, NOW).rateLimit).toBeNull();
+    expect(parseUsage({ usage: { used: 1, size: 2 } }, NOW).rateLimit).toBeNull();
+  });
+
+  test('utilization/resetsAt clamp + tolerate missing fields', () => {
+    const result = parseUsage(
+      { usage: { used: 1, size: 2, rateLimit: { status: 'allowed', utilization: 250 } } },
+      NOW
+    );
+    expect(result.rateLimit).toEqual({
+      type: null,
+      label: 'Usage limit',
+      pct: 100,
+      resetsAt: null,
+      status: 'allowed',
+    });
+  });
+});
+
+describe('parseUsage — malformed input tolerance', () => {
+  test('missing usage entirely → all-null shape, never throws', () => {
+    expect(parseUsage({}, NOW)).toEqual({ context: null, cost: null, rateLimit: null, asOf: NOW });
+    expect(parseUsage(undefined, NOW)).toEqual({
+      context: null,
+      cost: null,
+      rateLimit: null,
+      asOf: NOW,
+    });
+    expect(parseUsage(null, NOW)).toEqual({
+      context: null,
+      cost: null,
+      rateLimit: null,
+      asOf: NOW,
+    });
+  });
+
+  test('a malformed _meta-derived rateLimit (not an object) is tolerated', () => {
+    expect(() =>
+      parseUsage({ usage: { used: 1, size: 2, rateLimit: 'not-an-object' } }, NOW)
+    ).not.toThrow();
+    expect(
+      parseUsage({ usage: { used: 1, size: 2, rateLimit: 'not-an-object' } }, NOW).rateLimit
+    ).toBeNull();
+  });
+
+  test('defaults `now` to Date.now() when not injected', () => {
+    const before = Date.now();
+    const result = parseUsage({ usage: { used: 1, size: 2 } });
+    const after = Date.now();
+    expect(result.asOf).toBeGreaterThanOrEqual(before);
+    expect(result.asOf).toBeLessThanOrEqual(after);
+  });
+});

package/apps/studio/test/fixtures/mock-acp-agent-caps.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env bun
+// Mock ACP agent exercising the session-capabilities channel (feature-acp-
+// panel-dynamic-claude-code-capabilities) — modes + configOptions returned
+// from session/new, live session/set_mode + session/set_config_option, and
+// the config_option_update / session_info_update notifications a real
+// claude-agent-acp session emits. No real `claude` needed.
+//
+// Mirrors the REAL adapter's observed behavior (read from the installed
+// @agentclientprotocol/claude-agent-acp source, not guessed):
+//   - session/set_mode updates the mode AND mirrors it into configOptions'
+//     "mode" entry, emitting ONLY a config_option_update notification (no
+//     current_mode_update) — bridge.ts cross-derives lastModes from that.
+//   - session/set_config_option('model', …) can change which OTHER options
+//     are offered (here: picking "opus" adds a "fast" option) and returns
+//     the FULL refreshed configOptions in its RPC response (no notification).
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const MODEL_OPTIONS = [
+  { value: 'sonnet', name: 'Sonnet' },
+  { value: 'opus', name: 'Opus' },
+];
+const EFFORT_OPTIONS = [
+  { value: 'default', name: 'Default' },
+  { value: 'high', name: 'High' },
+];
+const MODE_OPTIONS = [
+  { value: 'default', name: 'Manual' },
+  { value: 'plan', name: 'Plan Mode' },
+];
+const AVAILABLE_MODES = [
+  {
+    id: 'default',
+    name: 'Manual',
+    description: 'Standard behavior, prompts for dangerous operations',
+  },
+  { id: 'plan', name: 'Plan Mode', description: 'Planning mode, no actual tool execution' },
+];
+
+// `session` carries every tracked field (model/effort/mode/fast) so a call
+// that rebuilds the FULL option set (e.g. session/set_mode, which is scoped
+// to just the mode) never regresses a field a PRIOR call already changed —
+// mirrors the real adapter's `session.configOptions` being one persistent
+// object, not independently recomputed per field.
+function baseConfigOptions(session) {
+  const opts = [
+    {
+      id: 'model',
+      name: 'Model',
+      category: 'model',
+      type: 'select',
+      currentValue: session.model,
+      options: MODEL_OPTIONS,
+    },
+    {
+      id: 'effort',
+      name: 'Effort',
+      category: 'thought_level',
+      type: 'select',
+      currentValue: session.effort,
+      options: EFFORT_OPTIONS,
+    },
+    {
+      id: 'mode',
+      name: 'Mode',
+      category: 'mode',
+      type: 'select',
+      currentValue: session.mode,
+      options: MODE_OPTIONS,
+    },
+  ];
+  if (session.model === 'opus') {
+    opts.push({
+      id: 'fast',
+      name: 'Fast mode',
+      category: 'model_config',
+      type: 'select',
+      currentValue: session.fast,
+      options: [
+        { value: 'on', name: 'On' },
+        { value: 'off', name: 'Off' },
+      ],
+    });
+  }
+  return opts;
+}
+
+let n = 0;
+const sessions = new Map(); // sessionId -> { model, effort, mode, fast }
+
+acp
+  .agent({ name: 'mock-acp-agent-caps' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', async (ctx) => {
+    const sessionId = `mock-caps-session-${++n}`;
+    const session = { model: 'sonnet', effort: 'default', mode: 'default', fast: 'off' };
+    sessions.set(sessionId, session);
+    await ctx.client.notify('session/update', {
+      sessionId,
+      update: { sessionUpdate: 'session_info_update', title: 'New chat' },
+    });
+    return {
+      sessionId,
+      modes: { currentModeId: 'default', availableModes: AVAILABLE_MODES },
+      configOptions: baseConfigOptions(session),
+    };
+  })
+  .onRequest('session/prompt', async (ctx) => {
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'ok' } },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .onRequest('session/set_mode', async (ctx) => {
+    const session = sessions.get(ctx.params.sessionId);
+    if (!session) throw new Error('session not found');
+    if (!AVAILABLE_MODES.some((m) => m.id === ctx.params.modeId)) {
+      throw new Error(`unknown mode: ${ctx.params.modeId}`);
+    }
+    session.mode = ctx.params.modeId;
+    // Real adapter: setSessionMode emits ONLY config_option_update, never
+    // current_mode_update — bridge.ts must cross-derive lastModes from it.
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'config_option_update', configOptions: baseConfigOptions(session) },
+    });
+    return {};
+  })
+  .onRequest('session/set_config_option', async (ctx) => {
+    const session = sessions.get(ctx.params.sessionId);
+    if (!session) throw new Error('session not found');
+    const { configId, value } = ctx.params;
+    if (configId === 'model') {
+      if (!MODEL_OPTIONS.some((o) => o.value === value)) throw new Error(`unknown model: ${value}`);
+      session.model = value;
+    } else if (configId === 'effort') {
+      if (!EFFORT_OPTIONS.some((o) => o.value === value))
+        throw new Error(`unknown effort: ${value}`);
+      session.effort = value;
+    } else if (configId === 'mode') {
+      if (!AVAILABLE_MODES.some((m) => m.id === value)) throw new Error(`unknown mode: ${value}`);
+      session.mode = value;
+    } else if (configId === 'fast') {
+      session.fast = value;
+    } else {
+      throw new Error(`unknown config option: ${configId}`);
+    }
+    return { configOptions: baseConfigOptions(session) };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-elicit-flood.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+// Mock ACP agent proving the MAX_PENDING_ELICITATIONS cap (feature-acp-ask-
+// user-question, SECURITY / ethical-hacker finding — an unbounded queue lets
+// any connected MCP server flood the client with elicitation requests). Fires
+// MORE than the cap concurrently, without waiting for each one — mirroring a
+// hostile/compromised MCP server that never waits for an answer before
+// issuing the next request — and reports which ones actually round-tripped to
+// the client vs. were declined immediately by the bridge's own cap.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const FLOOD_COUNT = 8; // > MAX_PENDING_ELICITATIONS (5) in acp/bridge.ts
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-elicit-flood' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-elicit-flood-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    const requests = Array.from({ length: FLOOD_COUNT }, (_, i) =>
+      ctx.client.request(acp.methods.client.elicitation.create, {
+        mode: 'form',
+        sessionId: ctx.params.sessionId,
+        message: `Flood question ${i}`,
+        requestedSchema: { type: 'object', properties: { [`q${i}`]: { type: 'string' } } },
+      })
+    );
+    const responses = await Promise.all(requests);
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `responses=${JSON.stringify(responses)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);