@1agh/maude 0.45.0 → 0.45.2

package/apps/studio/client/panels/acp-capabilities.js

@@ -0,0 +1,71 @@
+// Pure helpers for the ACP session-capabilities channel (feature-acp-panel-
+// dynamic-claude-code-capabilities). Every model/mode/effort list rendered by
+// the panel is parsed from these — NEVER a hardcoded array. The session's
+// `configOptions[]` is a generic, agent-defined menu (models/effort/fast-mode/
+// agent persona/…, keyed by opaque ids); `modes` is the separate, protocol-
+// typed permission-mode roster. See CapabilityBar.jsx for the render side.
+
+const KNOWN_CONFIG_IDS = { model: 'model', effort: 'effort', fast: 'fast', mode: 'mode' };
+
+/**
+ * `configOptions[]` → the three well-known controls (identified by `id` —
+ * `category` is only a UX hint and may be absent, e.g. the "Agent persona"
+ * option) plus every OTHER advertised select option, generic. The "mode"
+ * entry mirrors `modes`/`SessionModeState` (the adapter keeps both in sync)
+ * so it's excluded here — the dedicated mode picker renders from `parseModes`
+ * instead, never from this list, or it would show twice.
+ */
+export function parseConfigOptions(configOptions) {
+  const list = Array.isArray(configOptions) ? configOptions : [];
+  let model = null;
+  let effort = null;
+  let fast = null;
+  const others = [];
+  for (const opt of list) {
+    if (!opt || typeof opt !== 'object' || opt.id === KNOWN_CONFIG_IDS.mode) continue;
+    if (opt.id === KNOWN_CONFIG_IDS.model) model = opt;
+    else if (opt.id === KNOWN_CONFIG_IDS.effort) effort = opt;
+    else if (opt.id === KNOWN_CONFIG_IDS.fast) fast = opt;
+    else others.push(opt);
+  }
+  return { model, effort, fast, others };
+}
+
+/**
+ * `SessionModeState` → `{ current, available }` (empty when the agent doesn't
+ * advertise modes at all). `available` legitimately varies turn to turn — the
+ * adapter clamps the roster to what the CURRENT model supports (e.g. "Auto"
+ * only when `supportsAutoMode`) — never assume a fixed set.
+ */
+export function parseModes(modes) {
+  if (!modes || !Array.isArray(modes.availableModes)) return { current: null, available: [] };
+  return { current: modes.currentModeId ?? null, available: modes.availableModes };
+}
+
+/**
+ * Flatten a `SessionConfigSelect.options` — a flat option array OR grouped
+ * (`SessionConfigSelectGroup[]`, each `{group,name,options}`) — into one list
+ * of selectable leaves (`{value,name,description}`).
+ */
+export function flattenSelectOptions(options) {
+  const list = Array.isArray(options) ? options : [];
+  const out = [];
+  for (const o of list) {
+    if (o && Array.isArray(o.options)) out.push(...o.options);
+    else if (o) out.push(o);
+  }
+  return out;
+}
+
+/**
+ * Resolve which value a picker should show: the user's last explicit pick
+ * (localStorage, `savedValue`) if it's still offered among `availableValues`
+ * (a plain array of value/id strings — the caller flattens+maps first), else
+ * `defaultValue` (the session's own current value — a fresh session/model can
+ * default to something the last chat didn't use).
+ */
+export function resolvePersistedPick(availableValues, savedValue, defaultValue) {
+  const set = new Set(Array.isArray(availableValues) ? availableValues : []);
+  if (savedValue != null && set.has(savedValue)) return savedValue;
+  return defaultValue ?? null;
+}

package/apps/studio/client/panels/acp-elicitation.js

@@ -0,0 +1,194 @@
+// Pure helpers for ACP form elicitation (feature-acp-ask-user-question) —
+// parses a `requestedSchema` (ElicitationSchema, confirmed on disk against
+// `@agentclientprotocol/sdk`'s schema/types.gen.d.ts) into renderable question
+// descriptors, and folds the UI's answer state back into the `content` map a
+// `CreateElicitationResponse` expects. No DOM — `ElicitationPrompt.jsx` is the
+// only consumer that touches rendering.
+//
+// The exact field-naming convention this is written against — `question_<n>`
+// paired with a sibling `question_<n>_custom` free-text field, enum options
+// carrying `{const, title, description?}` — is confirmed by reading
+// `@agentclientprotocol/claude-agent-acp/dist/elicitation.js`'s
+// `askUserQuestionsToCreateRequest`/`applyAskElicitationResponse` directly (the
+// installed source, not the docs — this whole feature rides an UNSTABLE
+// protocol surface). The parser is written generically against the pairing
+// PATTERN (`<key>` + `<key>_custom` both present in `properties`), not
+// hardcoded to the `question_` prefix, so a well-formed non-AskUserQuestion MCP
+// form that happens to follow the same convention renders correctly too.
+
+// SECURITY (ethical-hacker finding) — Maude's bridge only ever declares the
+// `form` elicitation capability, never `url` (see DDR-180's Open decisions +
+// `acp/bridge.ts`'s structural rejection of any other mode). The MCP spec's
+// OWN guidance is that url-mode exists specifically so a real credential
+// request never has to pass through the LLM/client at all. By not supporting
+// it, Maude makes the free-text box on THIS card the only channel any
+// connected MCP server — benign or hostile — can ever use to ask for a
+// secret. This heuristic doesn't change accept/decline routing or try to
+// block the request; it only asks the free-text input to behave like a
+// password field (masked, with a visible warning) when the question's own
+// text reads as a credential ask, so a user who WOULD stop and think twice
+// before typing a real secret into a password-styled field gets that same
+// pause here. A false positive just means an unrelated question shows a
+// masked box — harmless; a false negative leaves today's behavior unchanged.
+const SECRET_SHAPED_PATTERN =
+  /\b(password|passphrase|secret|api[\s_-]?key|access[\s_-]?key|private[\s_-]?key|auth(?:entication)?[\s_-]?token|credential|oauth[\s_-]?token)\b/i;
+
+/** Does this question's own text read as a request for a credential/secret?
+ *  Checked against title + description (or a top-level card `message`) — text
+ *  the requester chose, never the user's own typed answer. */
+export function looksLikeSecretRequest(...texts) {
+  const joined = texts.filter((t) => typeof t === 'string').join(' ');
+  return SECRET_SHAPED_PATTERN.test(joined);
+}
+
+/** `_meta` key under which `askUserQuestionsToCreateRequest` bridges an
+ *  AskUserQuestion option's `preview` (mockup/code-snippet/comparison) — ACP's
+ *  `EnumOption` has no first-class slot for it (confirmed on disk against the
+ *  installed `claude-agent-acp/dist/elicitation.js`). */
+const OPTION_PREVIEW_META_KEY = '_claude/askUserQuestionOption';
+
+/** Titled or bare enum options → a uniform `{value, label, description, preview}`
+ *  list. `oneOf`/array-items `anyOf` carry `{const, title, description?, _meta?}`;
+ *  a bare `enum` is just an array of strings with no separate label/preview. */
+function normalizeOptions(schema) {
+  if (Array.isArray(schema?.oneOf)) {
+    return schema.oneOf.map((o) => ({
+      value: o?.const,
+      label: o?.title ?? String(o?.const ?? ''),
+      description: o?.description ?? null,
+      preview: o?._meta?.[OPTION_PREVIEW_META_KEY]?.preview ?? null,
+    }));
+  }
+  if (Array.isArray(schema?.enum)) {
+    return schema.enum.map((v) => ({
+      value: v,
+      label: String(v),
+      description: null,
+      preview: null,
+    }));
+  }
+  return [];
+}
+
+/** Classify one ElicitationPropertySchema into a renderable `kind` + its options. */
+function classifyProperty(prop) {
+  if (!prop || typeof prop !== 'object') return null;
+  if (prop.type === 'string' && (Array.isArray(prop.oneOf) || Array.isArray(prop.enum))) {
+    return { kind: 'single', options: normalizeOptions(prop) };
+  }
+  if (prop.type === 'array') {
+    const items = prop.items;
+    const options = Array.isArray(items?.anyOf)
+      ? normalizeOptions({ oneOf: items.anyOf })
+      : normalizeOptions(items);
+    if (options.length) return { kind: 'multi', options };
+    return { kind: 'text', options: [] }; // array without an item enum — no renderer for it; fall back to text
+  }
+  // string/number/integer/boolean with no enum, or anything unrecognized —
+  // render as a plain free-text field rather than dropping the question.
+  return { kind: 'text', options: [] };
+}
+
+/**
+ * Walk `requestedSchema.properties` in object-key order into an ordered list
+ * of renderable question descriptors:
+ *   { id, title, description, kind: 'single'|'multi'|'text', options, required, customFieldId }
+ * Tolerates a missing/malformed schema (returns `[]`) — never throws, since a
+ * malformed elicitation must still let the user Skip/Cancel rather than crash
+ * the panel.
+ */
+export function parseElicitationSchema(requestedSchema) {
+  const properties = requestedSchema?.properties;
+  if (!properties || typeof properties !== 'object') return [];
+  const keys = Object.keys(properties);
+  const required = new Set(Array.isArray(requestedSchema.required) ? requestedSchema.required : []);
+  // A key is a "custom" sibling (and must NOT render as its own top-level
+  // question) when `<base>_custom` names it AND `<base>` is also a property.
+  const customKeys = new Set();
+  for (const k of keys) {
+    if (!k.endsWith('_custom')) continue;
+    const base = k.slice(0, -'_custom'.length);
+    if (base && Object.hasOwn(properties, base)) customKeys.add(k);
+  }
+
+  const questions = [];
+  for (const id of keys) {
+    if (customKeys.has(id)) continue;
+    const prop = properties[id];
+    const classified = classifyProperty(prop);
+    if (!classified) continue;
+    const customFieldId = customKeys.has(`${id}_custom`) ? `${id}_custom` : null;
+    questions.push({
+      id,
+      title: prop.title ?? null,
+      description: prop.description ?? null,
+      kind: classified.kind,
+      options: classified.options,
+      required: required.has(id),
+      customFieldId,
+      secretShaped: looksLikeSecretRequest(prop.title, prop.description),
+    });
+  }
+  return questions;
+}
+
+/**
+ * Fold the UI's answer state into the `content` map a `CreateElicitationResponse`
+ * `accept` action carries. `answers` is keyed by question id (string for
+ * single/text, string[] for multi) AND by `customFieldId` (string) where the
+ * user typed a free-text override.
+ *
+ * Single/text: a non-empty, trimmed custom answer WINS over a selection —
+ * mirrors `applyAskElicitationResponse`'s documented read order exactly (it
+ * checks the `_custom` field first and only falls back to the base field when
+ * empty), so a single-select AskUserQuestion field folds identically however
+ * the adapter reads it back. This is a real protocol constraint, not a UI
+ * choice — a single-select question only has room for one answer.
+ *
+ * Multi: a non-empty custom answer is APPENDED to the checked options instead
+ * (routed through the BASE field, `content[q.id]`, never `content[customFieldId]`)
+ * — dogfooding expected "type something extra" to ADD to a multi-select pick,
+ * not silently discard it the way single-select's override does. This is safe
+ * specifically because `applyAskElicitationResponse` only reads the custom key
+ * to decide whether to override; when it's absent, it falls through to
+ * `Array.isArray(value) ? value.join(", ") : ...` on the base field, which
+ * doesn't validate array entries against the declared enum — appending an
+ * arbitrary string is exactly what a real multi-select "and also…" answer
+ * should read as once joined. `content[customFieldId]` is deliberately never
+ * populated for a multi-select question, so the override path never fires.
+ *
+ * An unanswered, non-required question is simply omitted from `content`
+ * (Skip/leave-blank must never fabricate a value).
+ */
+export function buildElicitationContent(questions, answers) {
+  // `Object.create(null)` — a question/custom-field id of `__proto__` (an
+  // agent-supplied schema key, technically attacker-influenceable) would
+  // otherwise hit the Object.prototype accessor on a plain `{}` literal
+  // instead of creating an own key, silently dropping that answer
+  // (security-auditor finding; not exploitable across the wire since
+  // JSON.stringify never serializes it either way, but a null-prototype
+  // object closes it outright rather than relying on that side effect).
+  const content = Object.create(null);
+  const src = answers && typeof answers === 'object' ? answers : {};
+  for (const q of questions ?? []) {
+    const custom = q.customFieldId ? src[q.customFieldId] : undefined;
+    const trimmedCustom = typeof custom === 'string' ? custom.trim() : '';
+
+    if (q.kind === 'multi') {
+      const selected = Array.isArray(src[q.id]) ? src[q.id] : [];
+      const combined = trimmedCustom ? [...selected, trimmedCustom] : selected;
+      if (combined.length) content[q.id] = combined;
+      continue;
+    }
+
+    if (trimmedCustom) {
+      content[q.customFieldId] = trimmedCustom;
+      continue;
+    }
+    const value = src[q.id];
+    if (typeof value === 'string' && value !== '') {
+      content[q.id] = value;
+    }
+  }
+  return content;
+}

package/apps/studio/client/panels/acp-runtime.js

@@ -144,6 +144,45 @@ export function createAcpConnection() {
   const commandListeners = new Set();
   let commands = [];
 
+  // Session capabilities (feature-acp-panel-dynamic-claude-code-capabilities)
+  // — the live, dynamic replacement for the old hardcoded MODELS/EFFORTS
+  // arrays. `caps` = `{modes, configOptions}`, sourced entirely from the ACP
+  // session (never a static list); `sessionInfo` = the agent-generated title.
+  const capsListeners = new Set();
+  let caps = { modes: null, configOptions: [] };
+  const sessionInfoListeners = new Set();
+  let sessionInfo = { title: null, updatedAt: null };
+
+  // Usage (Milestone D) — the raw `usage` frame's payload, replayed on
+  // subscribe like caps/commands/sessionInfo above. Parsed into render-ready
+  // shape by acp-usage.js's parseUsage, not here (keep this file transport-only).
+  const usageListeners = new Set();
+  let usage = null;
+
+  // Pending permission requests (Milestone B — retires DDR-125 F2's blanket
+  // auto-approve). Surfaced OUTSIDE the assistant-ui message stream (like
+  // commands/caps above) via a panel-level subscription, since a request can
+  // arrive mid-turn and the run() loop only understands text/tool-call/
+  // reasoning parts — not "pause here for a human decision."
+  const permissionListeners = new Set();
+  let pendingPermissions = [];
+  function emitPermissions() {
+    const snap = pendingPermissions.slice();
+    for (const fn of permissionListeners) fn(snap);
+  }
+
+  // Pending elicitation requests (feature-acp-ask-user-question — AskUserQuestion
+  // + generic MCP form input). Same "outside the assistant-ui message stream"
+  // treatment as pendingPermissions above, for the same reason: a request can
+  // arrive mid-turn and the run() loop only understands text/tool-call/reasoning
+  // parts, not "pause here for a human form."
+  const elicitationListeners = new Set();
+  let pendingElicitations = [];
+  function emitElicitations() {
+    const snap = pendingElicitations.slice();
+    for (const fn of elicitationListeners) fn(snap);
+  }
+
   function emitStatus() {
     for (const fn of statusListeners) fn({ ...status });
   }
@@ -184,6 +223,22 @@ export function createAcpConnection() {
     emitBackground();
   }
 
+  // Connection-problem error card (Task C3) — the bridge `error` frame (a
+  // socket/adapter failure mid-turn) is ALSO thrown from prompt()'s generator
+  // (so assistant-ui's own turn-failed bookkeeping still runs), but a thrown
+  // generator error renders as a bare, unstyled assistant-ui fallback. Expose
+  // it as its own channel too so the panel can render a proper retry card
+  // instead — same "chrome, not turn content" treatment as commands/caps.
+  const errorListeners = new Set();
+  let lastError = null; // { message } | null
+  function emitError() {
+    for (const fn of errorListeners) fn(lastError);
+  }
+  function setError(message) {
+    lastError = message ? { message } : null;
+    emitError();
+  }
+
   function onFrame(frame) {
     if (frame.t === 'ready') {
       status.ready = true;
@@ -199,6 +254,62 @@ export function createAcpConnection() {
       for (const fn of commandListeners) fn(commands);
       return;
     }
+    // Same treatment for the capability channel — chrome, not turn content,
+    // arrives on establish + on every live mode/config-option change.
+    if (frame.t === 'caps') {
+      caps = { modes: frame.modes ?? null, configOptions: frame.configOptions ?? [] };
+      for (const fn of capsListeners) fn(caps);
+      return;
+    }
+    if (frame.t === 'session-info') {
+      sessionInfo = { title: frame.title ?? null, updatedAt: frame.updatedAt ?? null };
+      for (const fn of sessionInfoListeners) fn(sessionInfo);
+      return;
+    }
+    if (frame.t === 'usage') {
+      usage = frame.usage ?? null;
+      for (const fn of usageListeners) fn(usage);
+      return;
+    }
+    if (frame.t === 'permission-request') {
+      pendingPermissions = [
+        ...pendingPermissions,
+        { id: frame.id, toolCall: frame.toolCall, options: frame.options ?? [] },
+      ];
+      emitPermissions();
+      return;
+    }
+    if (frame.t === 'elicitation-request') {
+      pendingElicitations = [
+        ...pendingElicitations,
+        {
+          id: frame.id,
+          message: frame.message,
+          mode: frame.mode,
+          requestedSchema: frame.requestedSchema,
+          // Present only when this elicitation is scoped to a specific tool
+          // call (e.g. the built-in AskUserQuestion) — absent for a raw
+          // session-scoped MCP-server elicitation. ElicitationPrompt.jsx uses
+          // this to avoid a blanket "from Claude" attribution it can't back up.
+          toolCallId: frame.toolCallId,
+        },
+      ];
+      emitElicitations();
+      return;
+    }
+    // The bridge settled a pending elicitation itself (timeout/cancel/stop) —
+    // drop it from the pending list even though the client never responded,
+    // so the card doesn't sit open with a Submit button that's already dead.
+    // A client-driven response already removed its own entry optimistically
+    // (respondElicitation below), so this is a no-op for that path — it only
+    // does real work for a settlement the client didn't initiate.
+    if (frame.t === 'elicitation-resolved') {
+      if (pendingElicitations.some((p) => p.id === frame.id)) {
+        pendingElicitations = pendingElicitations.filter((p) => p.id !== frame.id);
+        emitElicitations();
+      }
+      return;
+    }
     // Everything else belongs to the active prompt turn.
     trackActivity(frame);
     if (turnHandler) turnHandler(frame);
@@ -256,6 +367,13 @@ export function createAcpConnection() {
       return () => backgroundListeners.delete(fn);
     },
 
+    /** Subscribe to the connection-problem error card's source (Task C3); replays the current one, if any. */
+    onError(fn) {
+      errorListeners.add(fn);
+      fn(lastError);
+      return () => errorListeners.delete(fn);
+    },
+
     /** Subscribe to the slash-command catalogue; replays the current list. */
     onCommands(fn) {
       commandListeners.add(fn);
@@ -263,12 +381,111 @@ export function createAcpConnection() {
       return () => commandListeners.delete(fn);
     },
 
+    /** Subscribe to the live capability set (`{modes, configOptions}`); replays the current snapshot. */
+    onCaps(fn) {
+      capsListeners.add(fn);
+      fn(caps);
+      return () => capsListeners.delete(fn);
+    },
+
+    /** Subscribe to the agent-generated chat title; replays the current snapshot. */
+    onSessionInfo(fn) {
+      sessionInfoListeners.add(fn);
+      fn(sessionInfo);
+      return () => sessionInfoListeners.delete(fn);
+    },
+
+    /** Subscribe to the raw usage frame (Milestone D); replays the current snapshot (may be null). */
+    onUsage(fn) {
+      usageListeners.add(fn);
+      fn(usage);
+      return () => usageListeners.delete(fn);
+    },
+
+    /** Subscribe to the list of currently-pending permission requests; replays the current snapshot. */
+    onPermission(fn) {
+      permissionListeners.add(fn);
+      fn(pendingPermissions);
+      return () => permissionListeners.delete(fn);
+    },
+
+    /** Subscribe to the list of currently-pending elicitation requests; replays the current snapshot. */
+    onElicitation(fn) {
+      elicitationListeners.add(fn);
+      fn(pendingElicitations);
+      return () => elicitationListeners.delete(fn);
+    },
+
+    /**
+     * Answer a pending permission request — `decision` is one of the
+     * request's own `options[].optionId`, or `'cancelled'` to reject. Removes
+     * it from the pending list optimistically (the server has no separate
+     * "resolved" frame; the turn just continues). A response for an id that's
+     * no longer pending (already timed out, or a duplicate click) is a no-op.
+     */
+    async respondPermission(id, decision) {
+      if (!pendingPermissions.some((p) => p.id === id)) return;
+      pendingPermissions = pendingPermissions.filter((p) => p.id !== id);
+      emitPermissions();
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'permission-response', id, decision }));
+      } catch {
+        /* socket unavailable — the bridge's own timeout will deny this request */
+      }
+    },
+
+    /**
+     * Answer a pending elicitation request — `response` is `{ action, content? }`,
+     * `action` one of `'accept'`/`'decline'`/`'cancel'`. Mirrors `respondPermission`
+     * exactly, including the optimistic removal + no-op-on-stale-id behavior.
+     */
+    async respondElicitation(id, response) {
+      if (!pendingElicitations.some((p) => p.id === id)) return;
+      pendingElicitations = pendingElicitations.filter((p) => p.id !== id);
+      emitElicitations();
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'elicitation-response', id, ...response }));
+      } catch {
+        /* socket unavailable — the bridge's own timeout will decline this request */
+      }
+    },
+
+    /**
+     * Live-set the session mode (Manual/Plan/…) for `chatId` on an
+     * ALREADY-established session — no respawn. Fire-and-forget like `warm`;
+     * the server validates against its own last-advertised roster and
+     * silently ignores an unadvertised id, so a stale/racy pick never corrupts
+     * state — the next `caps` frame is the source of truth either way.
+     */
+    async setMode(chatId, modeId) {
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'set-mode', chat: chatId || undefined, modeId }));
+      } catch {
+        /* socket unavailable — non-fatal */
+      }
+    },
+
+    /** Live-set one config option (model/effort/fast/…) for `chatId`. See `setMode`. */
+    async setConfig(chatId, configId, value) {
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'set-config', chat: chatId || undefined, configId, value }));
+      } catch {
+        /* socket unavailable — non-fatal */
+      }
+    },
+
     /**
      * Warm the adapter WITHOUT prompting so the agent publishes its command
      * catalogue. Fired when the user starts typing a slash command. Best-effort;
-     * a dead socket just leaves autocomplete on the static list.
+     * a dead socket just leaves autocomplete on the static list. `model`/
+     * `effort`/`mode` are the user's PERSISTED picks — applied once, live, by
+     * the bridge right after the session establishes (never onto an existing one).
      */
-    async warm(chatId, model, effort) {
+    async warm(chatId, model, effort, mode) {
       try {
         await ensureOpen();
         ws?.send(
@@ -277,6 +494,7 @@ export function createAcpConnection() {
             chat: chatId || undefined,
             model: model || undefined,
             effort: effort || undefined,
+            mode: mode || undefined,
           })
         );
       } catch {
@@ -287,17 +505,25 @@ export function createAcpConnection() {
     /**
      * Drive one prompt turn. Async-generates the bridge's `update` frames until
      * `turn-end`; throws on `error`; sends `cancel` when `abortSignal` aborts.
+     * `model`/`effort`/`mode` — see `warm`.
      */
-    async *prompt(text, chatId, abortSignal, model, effort) {
-      await ensureOpen();
+    async *prompt(text, chatId, abortSignal, model, effort, mode) {
+      try {
+        await ensureOpen();
+      } catch (err) {
+        setError(err?.message || 'Could not reach the Claude bridge.');
+        throw err;
+      }
       const queue = [];
       let wake = null;
       let ended = false;
       let failure = null;
       turnHandler = (frame) => {
         if (frame.t === 'turn-end') ended = true;
-        else if (frame.t === 'error') failure = frame.message || 'The Claude bridge errored.';
-        else queue.push(frame); // update / connected / permission
+        else if (frame.t === 'error') {
+          failure = frame.message || 'The Claude bridge errored.';
+          setError(failure); // Task C3 — the styled retry card's source
+        } else queue.push(frame); // update / connected / permission
         if (wake) {
           const w = wake;
           wake = null;
@@ -319,6 +545,7 @@ export function createAcpConnection() {
       // setBusy(true) fires FIRST so the finished-ping deferral (ChatPanel) sees
       // busy before these empty emits.
       resetBackground();
+      setError(null); // a fresh turn clears any stale card from a prior failure
       if (activeTools.size) {
         activeTools.clear();
         emitActivity();
@@ -331,6 +558,7 @@ export function createAcpConnection() {
             chat: chatId || undefined,
             model: model || undefined,
             effort: effort || undefined,
+            mode: mode || undefined,
           })
         );
         for (;;) {
@@ -369,7 +597,9 @@ export function createAcpConnection() {
   };
 }
 
-function lastUserText(messages) {
+/** The last user message's plain text — shared by the adapter's run() AND the
+ *  connection-problem card's "Try again" (Task C3), which re-sends it verbatim. */
+export function lastUserText(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
     if (m.role !== 'user') continue;
@@ -512,7 +742,15 @@ function expandPasteChips(text, map) {
  * parts, preserving the order in which the agent emits them. `available_commands_update`
  * and `usage_update` are intentionally dropped (chrome noise, not chat content).
  */
-export function makeAcpAdapter(conn, getChatId, getModel, getEffort, getAttachments, getContext) {
+export function makeAcpAdapter(
+  conn,
+  getChatId,
+  getModel,
+  getEffort,
+  getAttachments,
+  getContext,
+  getMode
+) {
   return {
     async *run({ messages, abortSignal }) {
       // Let any in-flight clipboard-image upload finish so its chip expands to a
@@ -540,7 +778,8 @@ export function makeAcpAdapter(conn, getChatId, getModel, getEffort, getAttachme
         getChatId(),
         abortSignal,
         getModel?.(),
-        getEffort?.()
+        getEffort?.(),
+        getMode?.()
       )) {
         if (frame.t !== 'update') continue;
         applyUpdate(parts, toolIndex, frame.update);

package/apps/studio/client/panels/acp-usage.js

@@ -0,0 +1,65 @@
+// Pure parser for the `usage` WS frame (Milestone D — context-window meter +
+// cost + single-window rate-limit banner). Scope is deliberately the genuinely
+// dynamic subset the ACP adapter exposes today (see the plan's Milestone D
+// research): a context-window gauge + session cost (from `usage_update`) and
+// an event-driven SINGLE-window rate-limit signal (`SDKRateLimitInfo` riding
+// `_meta["_claude/rateLimit"]`). The full multi-window "Plan usage limits"
+// panel is explicitly OUT of scope — that data isn't reachable through the
+// pinned adapter version; do not fabricate it here.
+
+const RATE_LIMIT_LABELS = {
+  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',
+};
+
+/** A friendly label for an `SDKRateLimitInfo.rateLimitType` — an unrecognized
+ *  or missing type falls back to a generic label rather than `undefined`, so
+ *  a future rate-limit-type the adapter adds still renders something sane. */
+function rateLimitLabel(type) {
+  return RATE_LIMIT_LABELS[type] || 'Usage limit';
+}
+
+/**
+ * `{ used, size, cost?, rateLimit? }` (the bridge's `BridgeUsage` shape, sent
+ * verbatim in a `{t:'usage', usage}` frame) → the render-ready shape:
+ *   { context: { used, size, pct } | null, cost: {amount,currency} | null,
+ *     rateLimit: { type, label, pct, resetsAt, status } | null, asOf }
+ * Tolerant of a missing/malformed frame or `_meta` — always returns a valid,
+ * renderable (if mostly-null) shape rather than throwing. `now` defaults to
+ * `Date.now()`; callers (tests) can inject a fixed value for determinism.
+ */
+export function parseUsage(frame, now = Date.now()) {
+  const usage = frame && typeof frame === 'object' ? frame.usage : null;
+  const asOf = now;
+  if (!usage || typeof usage !== 'object') {
+    return { context: null, cost: null, rateLimit: null, asOf };
+  }
+  const used = typeof usage.used === 'number' ? usage.used : null;
+  const size = typeof usage.size === 'number' ? usage.size : null;
+  const context =
+    used != null && size != null && size > 0
+      ? { used, size, pct: Math.max(0, Math.min(100, Math.round((used / size) * 100))) }
+      : null;
+  const cost =
+    usage.cost && typeof usage.cost === 'object' && typeof usage.cost.amount === 'number'
+      ? { amount: usage.cost.amount, currency: usage.cost.currency || 'USD' }
+      : null;
+
+  const raw = usage.rateLimit;
+  let rateLimit = null;
+  if (raw && typeof raw === 'object' && typeof raw.status === 'string') {
+    rateLimit = {
+      type: raw.rateLimitType || null,
+      label: rateLimitLabel(raw.rateLimitType),
+      pct: typeof raw.utilization === 'number' ? Math.max(0, Math.min(100, Math.round(raw.utilization))) : null,
+      resetsAt: raw.resetsAt || null,
+      status: raw.status,
+    };
+  }
+
+  return { context, cost, rateLimit, asOf };
+}