@1agh/maude 0.30.0 → 0.31.0

package/apps/studio/client/panels/RepoBranchSwitcher.jsx

@@ -0,0 +1,349 @@
+// Phase 29 (epic E4) Task 4 — the persistent project + draft switcher.
+//
+// REDESIGNED to match .design/ui/RepoBranchSwitcher.tsx: not a top header — a
+// compact ONE-LINE dock at the BOTTOM of the sidebar (mounted directly above the
+// IdentityBar avatar, so the two form one bottom dock — the gi-rail/gi-menu
+// anatomy). The trigger reads "📁 <project> · <version> ⌃" and opens ONE popup
+// UPWARD with a Project section (recents + Open another folder…) and a Version
+// section (Shared version / drafts / the fold-back CTA / New draft).
+//
+// Vocabulary contract: a git branch is a "draft", main/master is the "Shared
+// version" — no branch/checkout/main/merge jargon. Project switch → open_local_project
+// (Tauri) reloads the webview; draft switch → POST /_api/git/checkout then reload
+// (the git-lifecycle HEAD-watcher flushes Yjs first — DDR-051, not duplicated here);
+// "Add this draft to the Shared version" → POST /_api/git/fold. Renders nothing
+// until the project is a git repo. CSS (rb-*) in 3-shell-maude.css.
+
+import { useEffect, useRef, useState } from 'react';
+
+import { appRecentProjects, isNativeApp, openLocalProject, pickDirectory } from '../github.js';
+
+const SHARED = new Set(['main', 'master']);
+
+function Icon({ name, size = 16, className }) {
+  const p = {
+    check: <polyline points="3 8.2 6.4 11.5 13 4.2" />,
+    'chevron-up': <polyline points="3.5 10 8 5.5 12.5 10" />,
+    'chevron-down': <polyline points="3.5 6 8 10.5 12.5 6" />,
+    'chevron-right': <polyline points="6 3.5 10.5 8 6 12.5" />,
+    folder: <path d="M2 4.5h4l1.3 1.5H14V13H2z" />,
+    'folder-open': (<><path d="M2 4.5h4l1.3 1.5H14" /><path d="M2 6h12.5l-1.4 7H3.4z" /></>),
+    share: (<><circle cx="4" cy="8" r="1.6" /><circle cx="12" cy="4" r="1.6" /><circle cx="12" cy="12" r="1.6" /><line x1="5.4" y1="7.2" x2="10.6" y2="4.6" /><line x1="5.4" y1="8.8" x2="10.6" y2="11.4" /></>),
+    draft: (<><path d="M3 11.5 11 3.5l1.5 1.5L4.5 13l-2 .5z" /><line x1="9.5" y1="5" x2="11" y2="6.5" /></>),
+    // git-branch glyph — only the web read-only badge uses it (git vocab there).
+    branch: (<><circle cx="4.5" cy="4" r="1.4" /><circle cx="4.5" cy="12" r="1.4" /><circle cx="11.5" cy="6.5" r="1.4" /><line x1="4.5" y1="5.4" x2="4.5" y2="10.6" /><path d="M4.5 8.6h2.6a3 3 0 0 0 3-1.6" /></>),
+    plus: (<><line x1="8" y1="3" x2="8" y2="13" /><line x1="3" y1="8" x2="13" y2="8" /></>),
+    // "lift this draft up into the Shared version" — the fold-back action.
+    'arrow-up-to-line': (<><line x1="3.5" y1="3" x2="12.5" y2="3" /><line x1="8" y1="13" x2="8" y2="6" /><polyline points="5 8.5 8 5.5 11 8.5" /></>),
+    spinner: <path d="M8 2.2a5.8 5.8 0 1 0 5.8 5.8" />,
+  }[name];
+  return (
+    <svg className={className} width={size} height={size} viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      {p}
+    </svg>
+  );
+}
+
+function basename(p) {
+  return String(p).replace(/[/\\]+$/, '').split(/[/\\]/).pop() || String(p);
+}
+function slugify(s) {
+  return s.trim().toLowerCase().replace(/[^a-z0-9._/-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+async function getJson(url) {
+  const r = await fetch(url);
+  return r.json();
+}
+async function postJson(url, body) {
+  const r = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  let json = null;
+  try { json = await r.json(); } catch { /* no body */ }
+  return { ok: r.ok, status: r.status, json };
+}
+
+export default function RepoBranchSwitcher({ project, liveBranch }) {
+  const native = isNativeApp();
+  const [status, setStatus] = useState(null); // { repo, branch }
+  const [branches, setBranches] = useState([]);
+  const [recents, setRecents] = useState([]);
+  const [open, setOpen] = useState(false);
+  const [newDraft, setNewDraft] = useState(false);
+  const [draftName, setDraftName] = useState('');
+  const [foldConfirm, setFoldConfirm] = useState(false);
+  const [folding, setFolding] = useState('');
+  const [busy, setBusy] = useState(false);
+  const [switching, setSwitching] = useState('');
+  const [err, setErr] = useState('');
+  const rootRef = useRef(null);
+
+  useEffect(() => {
+    let alive = true;
+    (async () => {
+      try {
+        const s = await getJson('/_api/git/status');
+        if (!alive) return;
+        setStatus(s);
+        // Branches drive the native dock's draft picker only — the web badge is
+        // read-only, so skip the extra request there.
+        if (s.repo && native) {
+          const b = await getJson('/_api/git/branches');
+          if (alive) setBranches(b.branches || []);
+        }
+      } catch { /* not a repo / offline */ }
+    })();
+    if (native) appRecentProjects().then((r) => alive && setRecents(r || [])).catch(() => {});
+    return () => { alive = false; };
+  }, [native]);
+
+  useEffect(() => {
+    if (!open && !newDraft) return undefined;
+    const onDoc = (e) => { if (rootRef.current && !rootRef.current.contains(e.target)) { setOpen(false); setNewDraft(false); } };
+    document.addEventListener('mousedown', onDoc);
+    return () => document.removeEventListener('mousedown', onDoc);
+  }, [open, newDraft]);
+
+  // Only meaningful for a versioned project (drafts need git).
+  if (!status?.repo) return null;
+
+  // Prefer the live branch from the git-status broadcast (kept current as the
+  // dev runs `git checkout` in their terminal) over the one-shot mount fetch.
+  const branch = liveBranch || status.branch || 'main';
+  const onShared = SHARED.has(branch);
+  const sharedName = branches.find((b) => SHARED.has(b.name))?.name || 'main';
+  const drafts = branches.filter((b) => !SHARED.has(b.name));
+  const otherDrafts = drafts.filter((b) => b.name !== branch);
+  const projectName = project || basename(recents[0] || 'Project');
+
+  // Web studio (browser, CLI-launched inside a repo): the switcher is awareness
+  // only. The developer owns the workspace from their terminal — switching repos
+  // and branches happens there — so render a compact, read-only "📁 project ·
+  // branch: X" badge in git vocab (not "draft"/"Shared version"), kept live by
+  // the same git-status broadcast that drives the Changes panel. No actions: a
+  // UI checkout would rewrite the dev's working tree under their hands and
+  // collide with their editor (DDR-119 — native owns the workspace; web is a
+  // repo-bound companion).
+  if (!native) {
+    return (
+      <div className="rb-dock-wrap">
+        <div className="rb-dock rb-dock--ro">
+          <span
+            className="rb-trigger rb-trigger--ro"
+            title={`${projectName} · branch: ${branch} — switch branches in your terminal`}
+          >
+            <span className="rb-trigger-icon"><Icon name="folder" size={14} /></span>
+            <span className="rb-trigger-proj">{projectName}</span>
+            <span className="rb-trigger-sep" aria-hidden="true">·</span>
+            <span className="rb-trigger-ver rb-trigger-ver--ro">
+              <Icon name="branch" size={12} />
+              <span className="rb-trigger-ver-name">branch: {branch}</span>
+            </span>
+          </span>
+        </div>
+      </div>
+    );
+  }
+
+  async function switchDraft(name) {
+    setOpen(false);
+    if (name === branch) return;
+    setSwitching(name === sharedName ? 'the shared version' : name);
+    setErr('');
+    const r = await postJson('/_api/git/checkout', { name });
+    if (r.ok && r.json?.ok) window.location.reload();
+    else { setErr(r.json?.error || 'Could not switch.'); setSwitching(''); }
+  }
+
+  async function createDraft() {
+    const name = slugify(draftName);
+    if (!name) return;
+    setBusy(true); setErr('');
+    const r = await postJson('/_api/git/branch', { name });
+    if (r.ok && r.json?.ok) window.location.reload();
+    else { setErr(r.json?.error || 'Could not create the draft.'); setBusy(false); }
+  }
+
+  // "Add this draft to the Shared version" (Task 7) — merge + publish, then remove.
+  async function foldDraft() {
+    setFoldConfirm(false);
+    setFolding(branch);
+    setErr('');
+    const r = await postJson('/_api/git/fold', { name: branch });
+    if (r.ok && r.json?.ok) window.location.reload();
+    else {
+      setErr(r.status === 401 ? 'Sign in with GitHub to publish the Shared version.' : r.json?.error || 'Could not add the draft.');
+      setFolding('');
+    }
+  }
+
+  async function switchRepo(path) {
+    setOpen(false);
+    if (!native) return;
+    setSwitching(basename(path));
+    try { await openLocalProject(path); }
+    catch (e) { setErr(String(e?.message || e || 'Could not open that project.')); setSwitching(''); }
+  }
+
+  async function openAnother() {
+    setOpen(false);
+    if (!native) return;
+    try {
+      const dir = await pickDirectory();
+      if (!dir) return;
+      setSwitching(basename(dir));
+      await openLocalProject(dir);
+    } catch (e) { setErr(String(e?.message || e || 'Could not open that folder.')); setSwitching(''); }
+  }
+
+  const slug = slugify(draftName);
+  const currentDraft = onShared ? null : branches.find((b) => b.current);
+
+  return (
+    <div className="rb-dock-wrap">
+      <div className="rb-dock" ref={rootRef}>
+        {open && (
+          <div className="rb-pop rb-pop--up" id="rb-switch-pop" role="menu" aria-label="Switch project or version">
+            {/* ── Project ── */}
+            <div className="rb-pop-hd">Project</div>
+            {native && recents.length > 0 ? (
+              recents.map((p, i) => (
+                <button type="button" key={p} className={'rb-pop-item' + (i === 0 ? ' is-current' : '')} role="menuitem" onClick={() => switchRepo(p)}>
+                  <span className="rb-pop-icon"><Icon name="folder" size={14} /></span>
+                  <span className="rb-pop-tx">
+                    <span className="rb-pop-name">{basename(p)}</span>
+                    <span className="rb-pop-sub">{p}</span>
+                  </span>
+                  {i === 0 ? <Icon name="check" size={14} className="rb-pop-check" /> : null}
+                </button>
+              ))
+            ) : (
+              <div className="rb-pop-sub" style={{ padding: 'var(--space-2) var(--space-3)' }}>{native ? 'No other recent projects.' : 'Open another project from the desktop app.'}</div>
+            )}
+            {native && (
+              <button type="button" className="rb-pop-item rb-pop-item--action" role="menuitem" onClick={openAnother}>
+                <span className="rb-pop-icon"><Icon name="folder-open" size={14} /></span>
+                <span className="rb-pop-tx"><span className="rb-pop-name">Open another folder…</span></span>
+              </button>
+            )}
+
+            <div className="rb-pop-sep" />
+            <div className="rb-pop-hd">Version</div>
+
+            {onShared ? (
+              <>
+                <button type="button" className="rb-pop-item is-current" role="menuitem" aria-current="true" onClick={() => switchDraft(sharedName)}>
+                  <span className="rb-pop-icon rb-pop-icon--shared"><Icon name="share" size={14} /></span>
+                  <span className="rb-pop-tx">
+                    <span className="rb-pop-name">Shared version</span>
+                    <span className="rb-pop-sub">what everyone sees</span>
+                  </span>
+                  <Icon name="check" size={14} className="rb-pop-check" />
+                </button>
+                {drafts.length > 0 && <div className="rb-pop-grouplabel">Drafts</div>}
+                {drafts.map((b) => (
+                  <button type="button" key={b.name} className="rb-pop-item" role="menuitem" onClick={() => switchDraft(b.name)}>
+                    <span className="rb-pop-icon rb-pop-icon--draft"><Icon name="draft" size={14} /></span>
+                    <span className="rb-pop-tx"><span className="rb-pop-name">{b.name}</span></span>
+                  </button>
+                ))}
+              </>
+            ) : (
+              <>
+                {/* On a draft — it's the current row, and the one strong action is
+                    folding it back into the Shared version (Task 7). */}
+                <button type="button" className="rb-pop-item is-current" role="menuitem" aria-current="true">
+                  <span className="rb-pop-icon rb-pop-icon--draft"><Icon name="draft" size={14} /></span>
+                  <span className="rb-pop-tx">
+                    <span className="rb-pop-name">{currentDraft?.name || branch}</span>
+                    <span className="rb-pop-sub">your draft</span>
+                  </span>
+                  <Icon name="check" size={14} className="rb-pop-check" />
+                </button>
+                <button type="button" className="rb-fold" role="menuitem" onClick={() => { setOpen(false); setFoldConfirm(true); }}>
+                  <span className="rb-fold-icon"><Icon name="arrow-up-to-line" size={15} /></span>
+                  <span className="rb-fold-tx">
+                    <span className="rb-fold-title">Add this draft to the Shared version</span>
+                    <span className="rb-fold-sub">make it the version everyone works from</span>
+                  </span>
+                </button>
+                <div className="rb-pop-grouplabel">Switch to</div>
+                <button type="button" className="rb-pop-item" role="menuitem" onClick={() => switchDraft(sharedName)}>
+                  <span className="rb-pop-icon rb-pop-icon--shared"><Icon name="share" size={14} /></span>
+                  <span className="rb-pop-tx">
+                    <span className="rb-pop-name">Shared version</span>
+                    <span className="rb-pop-sub">what everyone sees</span>
+                  </span>
+                </button>
+                {otherDrafts.map((b) => (
+                  <button type="button" key={b.name} className="rb-pop-item" role="menuitem" onClick={() => switchDraft(b.name)}>
+                    <span className="rb-pop-icon rb-pop-icon--draft"><Icon name="draft" size={14} /></span>
+                    <span className="rb-pop-tx"><span className="rb-pop-name">{b.name}</span></span>
+                  </button>
+                ))}
+              </>
+            )}
+
+            <button type="button" className="rb-pop-item rb-pop-item--action" role="menuitem" onClick={() => { setOpen(false); setNewDraft(true); }}>
+              <span className="rb-pop-icon"><Icon name="plus" size={14} /></span>
+              <span className="rb-pop-tx">
+                <span className="rb-pop-name">New draft</span>
+                <span className="rb-pop-sub">a separate line of work, just yours for now</span>
+              </span>
+            </button>
+          </div>
+        )}
+
+        {newDraft && (
+          <div className="rb-newdraft rb-newdraft--up">
+            <label className="rb-newdraft-field">
+              <span className="rb-newdraft-label">Name your draft</span>
+              <input className="input rb-newdraft-input" type="text" value={draftName} placeholder="Nav redesign" aria-label="Draft name" autoFocus onChange={(e) => setDraftName(e.target.value)} onKeyDown={(e) => { if (e.key === 'Enter' && slug) createDraft(); if (e.key === 'Escape') { setNewDraft(false); setDraftName(''); } }} />
+              {slug && <span className="rb-pop-sub">Creates a draft called <b>{slug}</b></span>}
+            </label>
+            {err && <span className="rb-newdraft-err">{err}</span>}
+            <div className="rb-newdraft-actions">
+              <button type="button" className="btn btn--ghost btn--sm" onClick={() => { setNewDraft(false); setDraftName(''); setErr(''); }} disabled={busy}>Cancel</button>
+              <button type="button" className="btn btn--primary btn--sm" onClick={createDraft} disabled={busy || !slug}><Icon name="draft" size={13} /> {busy ? 'Creating…' : 'Create draft'}</button>
+            </div>
+            <p className="rb-newdraft-hint">A draft is your own copy to try things in. Add it to the Shared version when you're happy, or throw it away — nothing else changes.</p>
+          </div>
+        )}
+
+        {switching ? (
+          <div className="rb-switching" role="status" aria-live="polite">
+            <Icon name="spinner" size={14} className="rb-spin" />
+            <span>{folding ? <>Adding <b>{folding}</b> to the Shared version…</> : <>Opening <b>{switching}</b>…</>}</span>
+          </div>
+        ) : (
+          <button type="button" className={'rb-trigger' + (open ? ' is-open' : '')} aria-expanded={open} aria-haspopup="menu" aria-controls="rb-switch-pop" onClick={() => { setOpen((v) => !v); setNewDraft(false); }} title={`${projectName} · ${onShared ? 'Shared version' : branch}`}>
+            <span className="rb-trigger-icon"><Icon name="folder" size={14} /></span>
+            <span className="rb-trigger-proj">{projectName}</span>
+            <span className="rb-trigger-sep" aria-hidden="true">·</span>
+            <span className={'rb-trigger-ver' + (onShared ? '' : ' is-draft')}>
+              <Icon name={onShared ? 'share' : 'draft'} size={12} />
+              <span className="rb-trigger-ver-name">{onShared ? 'Shared version' : branch}</span>
+            </span>
+            <Icon name="chevron-up" size={13} className="rb-trigger-caret" />
+          </button>
+        )}
+        {err && !newDraft && !switching && <div className="rb-switcher-err" role="alert">{err}</div>}
+      </div>
+
+      {/* Fold-back confirm — the one modal in this surface. Plain words, no merge UI. */}
+      {foldConfirm && (
+        <div className="rb-scrim" role="presentation" onClick={() => setFoldConfirm(false)}>
+          <div className="rb-sheet" role="dialog" aria-modal="true" aria-labelledby="rb-sheet-title" aria-describedby="rb-sheet-body" onClick={(e) => e.stopPropagation()} onKeyDown={(e) => { if (e.key === 'Escape') setFoldConfirm(false); }}>
+            <span className="rb-sheet-icon"><Icon name="arrow-up-to-line" size={20} /></span>
+            <h2 className="rb-sheet-title" id="rb-sheet-title">Add this draft to the Shared version</h2>
+            <p className="rb-sheet-body" id="rb-sheet-body">Everything in <b>“{currentDraft?.name || branch}”</b> will become part of the Shared version everyone sees.</p>
+            <p className="rb-sheet-meta">Everyone else picks it up the next time they Pull changes, and this draft is then removed. Nothing else changes.</p>
+            {err && <p className="rb-newdraft-err">{err}</p>}
+            <div className="rb-sheet-actions">
+              <button type="button" className="btn btn--ghost" onClick={() => { setFoldConfirm(false); setErr(''); }}>Cancel</button>
+              <button type="button" className="btn btn--primary" onClick={foldDraft}><Icon name="arrow-up-to-line" size={15} /> Add to the Shared version</button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

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

@@ -0,0 +1,286 @@
+// Phase 31 (DDR-123) — client glue between assistant-ui's local runtime and the
+// dev-server ACP bridge (`/_ws/acp`). One persistent socket per ChatPanel mount;
+// the bridge lazy-spawns the user's `claude` on the first prompt, so just opening
+// the panel costs nothing. A custom `ChatModelAdapter` translates the bridge's
+// JSON frames into the streamed assistant message parts assistant-ui renders.
+
+const WS_PATH = '/_ws/acp';
+
+/** Connection wrapper around the loopback `/_ws/acp` socket. */
+export function createAcpConnection() {
+  let ws = null;
+  let openPromise = null;
+  let turnHandler = null; // the in-flight run()'s frame sink
+  const statusListeners = new Set();
+  const status = { available: null, reason: undefined, ready: false };
+
+  // Live "what's running now" — in-flight tool calls (a tool_call with no
+  // completed/failed tool_call_update yet). Surfaced as the activity bar so
+  // background work is visible at a glance, not only buried in the text.
+  const activityListeners = new Set();
+  const activeTools = new Map(); // toolCallId → { title, kind }
+
+  // Turn-busy signal — true while a prompt turn is in flight. Drives the
+  // menubar Assistant badge + the "finished" notification.
+  const busyListeners = new Set();
+  let busy = false;
+
+  function emitStatus() {
+    for (const fn of statusListeners) fn({ ...status });
+  }
+
+  function setBusy(next) {
+    if (busy === next) return;
+    busy = next;
+    for (const fn of busyListeners) fn(busy);
+  }
+
+  function emitActivity() {
+    const snapshot = [...activeTools.values()];
+    for (const fn of activityListeners) fn(snapshot);
+  }
+
+  function trackActivity(frame) {
+    if (frame.t === 'update') {
+      const u = frame.update;
+      if (u.sessionUpdate === 'tool_call') {
+        activeTools.set(u.toolCallId, { title: u.title || u.kind || 'tool', kind: u.kind });
+        emitActivity();
+      } else if (
+        u.sessionUpdate === 'tool_call_update' &&
+        (u.status === 'completed' || u.status === 'failed')
+      ) {
+        if (activeTools.delete(u.toolCallId)) emitActivity();
+      }
+    } else if (frame.t === 'turn-end' || frame.t === 'error') {
+      if (activeTools.size) {
+        activeTools.clear();
+        emitActivity();
+      }
+    }
+  }
+
+  function onFrame(frame) {
+    if (frame.t === 'ready') {
+      status.ready = true;
+      status.available = frame.available;
+      status.reason = frame.reason;
+      emitStatus();
+      return;
+    }
+    // Everything else belongs to the active prompt turn.
+    trackActivity(frame);
+    if (turnHandler) turnHandler(frame);
+  }
+
+  function ensureOpen() {
+    if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+      return openPromise;
+    }
+    openPromise = new Promise((resolve, reject) => {
+      const scheme = location.protocol === 'https:' ? 'wss' : 'ws';
+      const sock = new WebSocket(`${scheme}://${location.host}${WS_PATH}`);
+      ws = sock;
+      sock.onopen = () => resolve();
+      sock.onerror = () => reject(new Error('Could not reach the Claude bridge.'));
+      sock.onclose = () => {
+        ws = null;
+        status.ready = false;
+        emitStatus();
+      };
+      sock.onmessage = (e) => {
+        try {
+          onFrame(JSON.parse(e.data));
+        } catch {
+          /* ignore malformed frame */
+        }
+      };
+    });
+    return openPromise;
+  }
+
+  return {
+    onStatus(fn) {
+      statusListeners.add(fn);
+      fn({ ...status });
+      return () => statusListeners.delete(fn);
+    },
+
+    onActivity(fn) {
+      activityListeners.add(fn);
+      fn([...activeTools.values()]);
+      return () => activityListeners.delete(fn);
+    },
+
+    /**
+     * Drive one prompt turn. Async-generates the bridge's `update` frames until
+     * `turn-end`; throws on `error`; sends `cancel` when `abortSignal` aborts.
+     */
+    async *prompt(text, chatId, abortSignal, model, effort) {
+      await ensureOpen();
+      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
+        if (wake) {
+          const w = wake;
+          wake = null;
+          w();
+        }
+      };
+      const cancel = () => {
+        try {
+          ws?.send(JSON.stringify({ t: 'cancel' }));
+        } catch {
+          /* socket already gone */
+        }
+      };
+      abortSignal?.addEventListener('abort', cancel, { once: true });
+      setBusy(true);
+      try {
+        ws.send(
+          JSON.stringify({
+            t: 'prompt',
+            text,
+            chat: chatId || undefined,
+            model: model || undefined,
+            effort: effort || undefined,
+          })
+        );
+        for (;;) {
+          while (queue.length) yield queue.shift();
+          if (failure) throw new Error(failure);
+          if (ended) return;
+          await new Promise((r) => {
+            wake = r;
+          });
+        }
+      } finally {
+        turnHandler = null;
+        setBusy(false);
+        abortSignal?.removeEventListener('abort', cancel);
+      }
+    },
+
+    onBusy(fn) {
+      busyListeners.add(fn);
+      fn(busy);
+      return () => busyListeners.delete(fn);
+    },
+
+    get busy() {
+      return busy;
+    },
+
+    close() {
+      try {
+        ws?.close();
+      } catch {
+        /* already closed */
+      }
+      ws = null;
+    },
+  };
+}
+
+function lastUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== 'user') continue;
+    return (m.content || [])
+      .filter((p) => p.type === 'text')
+      .map((p) => p.text)
+      .join('')
+      .trim();
+  }
+  return '';
+}
+
+function safeJson(value) {
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return '{}';
+  }
+}
+
+/**
+ * assistant-ui `ChatModelAdapter` over the ACP bridge. Streams text + tool-call
+ * 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) {
+  return {
+    async *run({ messages, abortSignal }) {
+      const text = lastUserText(messages);
+      if (!text) return;
+
+      const parts = [];
+      const toolIndex = new Map();
+
+      for await (const frame of conn.prompt(
+        text,
+        getChatId(),
+        abortSignal,
+        getModel?.(),
+        getEffort?.()
+      )) {
+        if (frame.t !== 'update') continue;
+        const u = frame.update;
+        switch (u.sessionUpdate) {
+          case 'agent_message_chunk': {
+            if (u.content?.type !== 'text') break;
+            const last = parts[parts.length - 1];
+            if (last && last.type === 'text') {
+              parts[parts.length - 1] = { ...last, text: last.text + u.content.text };
+            } else {
+              parts.push({ type: 'text', text: u.content.text });
+            }
+            break;
+          }
+          case 'agent_thought_chunk': {
+            // Extended-thinking — rendered as a collapsed "Thinking" disclosure
+            // (assistant-ui reasoning part) so it's available but not in the way.
+            if (u.content?.type !== 'text') break;
+            const last = parts[parts.length - 1];
+            if (last && last.type === 'reasoning') {
+              parts[parts.length - 1] = { ...last, text: last.text + u.content.text };
+            } else {
+              parts.push({ type: 'reasoning', text: u.content.text });
+            }
+            break;
+          }
+          case 'tool_call': {
+            toolIndex.set(u.toolCallId, parts.length);
+            parts.push({
+              type: 'tool-call',
+              toolCallId: u.toolCallId,
+              toolName: u.title || u.kind || 'tool',
+              args: u.rawInput ?? {},
+              argsText: safeJson(u.rawInput),
+              result: undefined,
+            });
+            break;
+          }
+          case 'tool_call_update': {
+            const idx = toolIndex.get(u.toolCallId);
+            if (idx == null) break;
+            parts[idx] = {
+              ...parts[idx],
+              result: u.rawOutput ?? parts[idx].result,
+              isError: u.status === 'failed',
+            };
+            break;
+          }
+          default:
+            break; // plan / thought / commands / usage — not rendered in v1
+        }
+        yield { content: parts.slice() };
+      }
+    },
+  };
+}