agentgui 1.0.956 → 1.0.958

package/.claude/workflows/gui-cohesion.js

@@ -0,0 +1,95 @@
+export const meta = {
+  name: 'gui-cohesion',
+  description: 'Drive a maximum-effort cohesion sweep of the agentgui GUI toward a single, polished claude.ai/code / cowork / Claude-Desktop-class chat-agent product: per-lens designer agents benchmark each surface against the real reference products, an adversarial verifier confirms each cohesion gap against the live source (kept-typography guard), a synthesizer orders them into a dependency-aware kit-vs-app build plan',
+  whenToUse: 'Run after the Claude-Desktop redesign AND the predictability-polish sweep have landed (WorkspaceShell + ConversationList + Files + Live dashboard + ContextPane + sort/filter/jump/message-actions all exist). Distinct from the three prior workflows: gui-audit hunts JANK, gui-overhaul DESIGNS new surfaces, gui-predictability-polish polishes the SHIPPED shell. This one hunts the COHESION / product-feel gap - whether all the surfaces read as ONE polished chat-agent product rather than a kit of parts, measured against claude.ai/code, cowork, and Claude Desktop as explicit benchmarks. It treats the three user-named must-haves as first-class lenses: (1) the chat thread feels like a chat agent, (2) folder browsing is an fsbrowse-grade file view, (3) all live sessions are viewable and manageable simultaneously. All visual/component work lands in c:\\dev\\anentrypoint-design; the app keeps wiring; no new index.html !important overrides.',
+  phases: [
+    { title: 'Benchmark', detail: 'one designer per cohesion lens benchmarks the surface against the real reference products + names concrete gaps' },
+    { title: 'Verify', detail: 'adversarially confirm each cohesion gap is real against the live source (kept-typography guard)' },
+    { title: 'Plan', detail: 'synthesize confirmed gaps into a dependency-ordered kit-vs-app build plan' },
+  ],
+};
+
+// Shared grounding: every lens reads the REAL post-redesign + post-polish source.
+// The shell, rail, files, live dashboard, chat, and context pane all EXIST and
+// are already polished once - this sweep hunts the COHESION gap, not from-scratch
+// redesign and not the primitive edges the polish sweep already closed.
+const GROUND =
+  ' GROUND IN REAL SOURCE (read, do not guess - the redesign AND the predictability-polish sweep HAVE shipped): agentgui front-end c:\\dev\\agentgui\\site\\app\\js\\app.js (view/sessionsColumn/workspaceRail/filesMain/liveMain/chatMain/historyMain/settingsMain/sendChat/sessionGroups) + backend.js + index.html. The kit c:\\dev\\anentrypoint-design\\src\\components\\{shell.js (WorkspaceShell/WorkspaceRail),sessions.js (ConversationList/SessionDashboard/SessionCard),agent-chat.js,chat.js,files.js,files-modals.js,context-pane.js,content.js} + root css {app-shell.css,chat.css,colors_and_type.css}. Server c:\\dev\\agentgui\\lib\\http-handler.js. Reference products to benchmark AGAINST (describe from product knowledge - these are the bar): claude.ai/code, cowork, Claude Desktop. The fsbrowse reference file manager lives at c:\\dev\\fsbrowse (server.js + public/ + index.js) - read it for the file-view bar.' +
+  ' POLICY: the components ALREADY EXIST and are polished once - find the COHESION gap (does the whole thing read as ONE product), the remaining feel gap vs the reference products, and any surface that still reads as primitive/kit-of-parts. ALL visual/component work lands in the KIT as correct defaults/props; the app keeps state + callback wiring; NEVER new index.html !important overrides (convert any to a kit default); use kit color/type tokens not hardcoded hex; NO decorative glyphs (arrows/box-drawing/bullets/checks/status-dot chars/emoji) - ASCII words + the CSS .status-dot-disc, but KEEP the typographic product set (middot, ellipsis, em/en-dash); every surface needs a11y (roles/aria/focus/44x44/keyboard), responsive (<640 + 420px), and explicit empty/loading/error states.';
+
+// Each lens is a cohesion dimension, not a single surface - it asks whether the
+// product as a whole clears the reference-product bar on that dimension.
+const LENSES = [
+  { key: 'chat-agent-feel', prompt: 'COHESION LENS - does the CHAT THREAD feel like a real chat agent (claude.ai/code / Claude Desktop)? Benchmark the whole conversation experience, not one widget: message rhythm + vertical spacing + readable measure (max-width), clear assistant-vs-user distinction (role label / subtle background / avatar-or-mark), code blocks with language label + copy button + syntax highlight, inline tool cards that read as a coherent run log (not raw JSON), markdown typography matching the reference, a stream caret + smooth non-janky streaming, per-message actions (copy/retry/edit-resend) that feel native, a composer that auto-grows with Enter=send / Shift+Enter=newline and an inline agent+model+cwd affordance, an inviting empty state, and contextual follow-up suggestions. Name every place the thread still reads as primitive vs the bar.' + GROUND },
+  { key: 'fsbrowse-file-view', prompt: 'COHESION LENS - is FOLDER BROWSING an fsbrowse-grade file view? READ c:\\dev\\fsbrowse (server.js + public/ + index.js) for the bar, then compare agentgui Files. Benchmark: breadcrumb nav + roots picker, dir-first sort by name/size/modified, type-distinguishing icons (ASCII/CSS not glyphs), a real preview (text/code with syntax highlight + image) ideally as a persistent side pane not a modal, keyboard nav (arrows/Enter/Backspace/Home/End), loading skeleton, empty-dir + error + permission-denied states, large-dir handling (virtualize/paginate), and a discoverable use-as-chat-cwd flow that ties the file view back into the chat agent. Name every gap vs fsbrowse + vs a Claude-Desktop file pane.' + GROUND },
+  { key: 'simultaneous-live-sessions', prompt: 'COHESION LENS - can a user VIEW ALL LIVE SESSIONS and MANAGE THEM SIMULTANEOUSLY (claude.ai/code parallel-agents feel)? Benchmark the Live dashboard + the conversation rail as one oversight surface: per-session live metrics (events/tokens/elapsed/current-tool/status with words+disc, busy-vs-stuck-vs-idle distinguishable at a glance), real-time updates with no flicker, per-session stop/open/resume, bulk select + stop-all, sort/filter sessions, running sessions pinned, a clear empty vs offline distinction, and the ability to jump between active sessions without losing place. Does it actually let you run and oversee several agents at once, or only show one? Name every gap.' + GROUND },
+  { key: 'shell-navigation-cohesion', prompt: 'COHESION LENS - does the WorkspaceShell + rail + ContextPane read as ONE app (Claude Desktop three-pane feel)? Benchmark: rail/sessions/main/pane proportions + collapse persistence + responsive reflow with NO dead column at any breakpoint, collapsed icon-rail keeps accessible names + announced keyboard collapse toggle, mobile (<900px) drawers with focus-trap + Esc + backdrop dismiss + auto-close-on-select, the ContextPane is informative (usage/last-turn tokens-cost-turns-duration, session metadata, recent files) not a dead static panel, the crumb/header/status vocab is identical across tabs, and navigation between Chat/History/Files/Live/Settings preserves state + feels instant. Name every place it reads as a kit of separate pages rather than one shell.' + GROUND },
+  { key: 'visual-system-cohesion', prompt: 'COHESION LENS - is there ONE visual system across every surface (the thing that makes a product feel designed)? Benchmark: consistent type scale + spacing rhythm + radius + elevation/shadow + color tokens (no hardcoded hex, no per-surface drift), uniform status vocab (connected/connecting/offline) + rail tone semantics (green=ok/selected, purple=subagent, flame=error) + relative-time format + empty-state copy across Files/Live/ContextPane/ConversationList/chat/history/settings, identical button/row/card primitives reused (not re-styled per surface), and ZERO decorative glyphs (KEEP only middot/ellipsis/em-en-dash; one sighting -> codebase-wide list). Also enumerate every index.html !important / local override of a kit rule and the KIT default that eliminates it. List each divergence + the unifying kit fix.' + GROUND },
+  { key: 'crosscut-perf-a11y-responsive-security', prompt: 'CROSS-CUTTING - performance + a11y + responsive + security across ALL surfaces (a product that janks or 403-leaks does not feel polished). Perf: audit scheduleRender/scheduleStreamRender coalescing, render purity (no fetch/loadDir in render), the 3s chat.active poll re-rendering ConversationList + SessionDashboard every tick, EventList/FileGrid building full bodies for hundreds of rows - find per-frame O(n) waste + a fix (change-diff / virtualize / pagination). A11y: each surface needs roles (listbox/tablist/dialog), aria, focus management + focus-visible, skip-link reach, modal focus-trap, WCAG colour-not-only status, 44x44 tap targets, prefers-reduced-motion - list gaps. Responsive: every surface at 420px + 1440px - no h-scroll, columns reflow. Security: re-audit /api/list + /api/image + /api/file allowlist confinement (normalize + fs.realpathSync resolved-prefix, 403 outside roots, symlink-escape fails closed), CORS gating under PASSWORD, markdown XSS (safeUrl + DOMPurify in the inline renderer that bypasses DOMPurify), WS token threading - confirm each holds or name the hole with file:line.' + GROUND },
+];
+
+const GAP_SCHEMA = {
+  type: 'object',
+  required: ['lens', 'gaps'],
+  properties: {
+    lens: { type: 'string' },
+    gaps: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: ['title', 'where', 'fixLocation', 'fix', 'severity'],
+        properties: {
+          title: { type: 'string', description: 'the cohesion / feel gap vs the reference product bar' },
+          where: { type: 'string', description: 'file:line or component the gap lives in' },
+          fixLocation: { type: 'string', enum: ['kit', 'app', 'server', 'kit+app'], description: 'where the fix lands' },
+          fix: { type: 'string', description: 'the concrete change: component/prop/css/wiring' },
+          benchmark: { type: 'string', description: 'which reference product (claude.ai/code, cowork, Claude Desktop, fsbrowse) sets the bar this gap fails' },
+          severity: { type: 'string', enum: ['high', 'medium', 'low'] },
+          keptTypography: { type: 'boolean', description: 'true if this touches the middot/ellipsis/dash set - which must NOT be flagged as a glyph violation' },
+        },
+      },
+    },
+  },
+};
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  required: ['title', 'real', 'reason'],
+  properties: {
+    title: { type: 'string' },
+    real: { type: 'boolean', description: 'true if the gap is real and the fix is sound against the live source' },
+    reason: { type: 'string', description: 'why - cite the source you read' },
+  },
+};
+
+phase('Benchmark');
+// Pipeline: each lens is benchmarked, then every gap it found is adversarially
+// verified the moment that lens returns - no barrier between phases.
+const verified = await pipeline(
+  LENSES,
+  (l) => agent(l.prompt, { label: 'benchmark:' + l.key, phase: 'Benchmark', schema: GAP_SCHEMA }),
+  (report, l) => parallel((report?.gaps || []).map((g) => () =>
+    agent(
+      'Adversarially verify this GUI cohesion gap against the REAL source (read the cited file - do not trust the claim). '
+      + 'KEPT-TYPOGRAPHY GUARD: the middot, ellipsis, and em/en-dash are intentional product typography - if the "gap" is merely flagging one of those as a decorative glyph, it is NOT real (real=false). '
+      + 'A gap is real only if it genuinely exists in the shipped source AND clearing it measurably moves the product toward the cited reference-product bar AND the proposed fix is sound and lands in the right place (kit vs app vs server). '
+      + 'Reject vague "make it nicer" gaps with no concrete source-grounded fix. '
+      + 'Gap: ' + JSON.stringify(g),
+      { label: 'verify:' + (g.title || '').slice(0, 32), phase: 'Verify', schema: VERDICT_SCHEMA }
+    ).then((v) => ({ ...g, lens: report.lens, verdict: v }))
+  ))
+);
+
+const confirmed = verified.flat().filter(Boolean).filter((g) => g.verdict && g.verdict.real);
+log('confirmed ' + confirmed.length + ' real cohesion gaps across ' + LENSES.length + ' lenses');
+
+phase('Plan');
+const plan = await agent(
+  'Synthesize these adversarially-confirmed GUI cohesion gaps into a dependency-ordered, kit-vs-app build plan for agentgui + the anentrypoint-design kit, aimed at making the whole product read as ONE polished claude.ai/code / cowork / Claude-Desktop-class chat agent. '
+  + 'Group by fixLocation (kit first - they unblock app wiring), order so shared kit components (ConversationList, SessionDashboard, SessionCard, AgentChat, ChatMessage, FileGrid, WorkspaceShell, ContextPane) are each edited ONCE with all their changes batched, then app wiring, then server changes, then the single build->vendor->witness step. '
+  + 'Call out which gaps share a component (batch them), which are independent (parallelizable), which conflict, and the highest-leverage few that most move the product toward the reference bar. '
+  + 'Confirmed gaps: ' + JSON.stringify(confirmed),
+  { label: 'synthesize-plan', phase: 'Plan' }
+);
+
+return { confirmed, plan, lensCount: LENSES.length, confirmedCount: confirmed.length };

package/AGENTS.md

@@ -1,12 +1,26 @@
 # AgentGUI — Agent Notes
 
-## GUI predictability + polish sweep (2026-06-05) — fifth maximum-effort run
+## GUI cohesion sweep (2026-06-10) — seventh maximum-effort run
+
+The GUI reads as ONE polished chat-agent product (claude.ai/code / cowork / Claude-Desktop), not a kit of parts. New workflow deliverable `.claude/workflows/gui-cohesion.js` — 6 cohesion *lenses* (chat-agent-feel, fsbrowse-file-view, simultaneous-live-sessions, shell-navigation, visual-system, crosscut-perf-a11y-security) benchmark each surface against the real reference products, an adversarial verifier confirms each gap (kept-typography guard), a synthesizer orders them. Distinct from `gui-audit` (jank), `gui-overhaul` (new surfaces), `gui-predictability-polish` (primitive edges) — this one hunts the **product-cohesion/feel gap**. Ran 61 agents -> 40 confirmed gaps (`PUNCHLIST-COHESION.md`).
+
+**Chat reads like a chat agent.** Every fenced code block has a per-block copy button: kit `chat.js` `injectCodeCopy()` wraps each rendered-markdown `<pre>` in `.chat-code-block` and injects a reveal-on-hover `.chat-code-copy` (idempotent via `data-copy-wired`, label flips copy->copied); the structured `CodeNode` head and `FilePreviewCode` header carry the same control. `ChatMessage` per-message actions render a text label beside the icon and use a real `copy` icon (not `page`). Mid-stream prose containing a code fence renders as a monospaced `<pre>` shell (`agent-chat.js` sets `preShell`, `chat.js` text renderer honors it) so it does not reflow prose->block on settle. `ChatComposer` shows a `context` line (agent · model · cwd) at the point of typing; `AgentChat` threads a stable per-agent `avatar` and `followups` chips after a settled turn.
+
+**Files is an fsbrowse-grade browser.** Kit `files.js` `FileGrid` caps a large dir at `FILE_GRID_CAP=200` with a `shown`/`onShowMore` "show N more" row, uses `role=group` (NOT `listbox` — the rows host real action `<button>`s, which is invalid listbox/option semantics), `FileRow` shows a `permissions`/`locked` ASCII tag (`read-only`/`no access`) and disables open for EACCES, and a `RootsPicker` segmented control replaces the borrowed history `.pill`. `files-modals.js` ships `FilePreviewPane` (a non-modal split-view region for the shell pane) alongside the modal `FileViewer` (kept as the `<900px` fallback), both with an ASCII `prev`/`next` stepper (`onPrev`/`onNext` + ArrowLeft/Right). The app renders the preview INTO the WorkspaceShell pane when wide, modal only when narrow.
+
+**All live sessions, managed at once.** Kit `sessions.js` `SessionCard` gains a `stale` status (`idle` word + non-pulsing `.status-dot-stale`, so a stuck agent differs from a busy one), a `selectable` checkbox (`role=checkbox`), and an `active` accent. `SessionDashboard` gains a sort `Select` (status/elapsed/activity/errors) + filter `SearchInput` + errors-only toggle, `stop-selected` bulk control, and a `streamState` line (the dashboard is listening even at 0 running). App `liveMain` derives `stale` (no activity >45s and no running tool), floats error-then-stale to the front, and keeps a per-sid `state.live.tally` incremented straight off the SSE stream so a brand-new chat shows motion before it lands in the history index.
 
-A polish sweep on top of the shipped Claude-Desktop redesign (workflow `wf_980345e1-201`, 65 agents -> 44 adversarially-confirmed gaps, punch-list `PUNCHLIST-POLISH.md`). New workflow deliverable `.claude/workflows/gui-predictability-polish.js` (per-surface polish -> adversarial verify with kept-typography guard -> dependency-ordered plan; distinct from `gui-audit` which hunts jank and `gui-overhaul` which designs new surfaces — this one hunts the *primitive/half-wired* edge in the SHIPPED shell).
+**One shell, one visual system.** Kit `shell.js` `WorkspaceShell` `stableFrame` keeps the pane grid TRACK present (width 0) when a tab has no pane, so the column geometry does not re-flow across tabs. There is ONE canonical `.status-dot-disc` (`status-dot-live` pulses via `color-mix`, `-error`/`-connecting`/`-stale` static, reduced-motion guarded) — `index.html`'s `.status-dot`/`agentgui-pulse` override is deleted and the crumb dot uses the kit modifier classes. `.ds-session-row.rail-*` tones now match `.row.rail-*` (accent/purple-2/flame). The rail footer pins a `ThemeToggle`; page titles are sentence-case. Touch targets floor to 44px under `@media (pointer:coarse)`.
 
-**Kit changes (`c:\dev\anentrypoint-design`, rebuilt + vendored into `site/app/vendor/`).** (1) **files.js** — `FileGrid` gained `sort{key,dir,onSort}` + clickable column header (`FileSortHeader`, ASCII `asc/desc` not glyphs), `filter`, `loading` (renders new `FileSkeleton` shimmer), and keyboard nav (`role=listbox` + roving focus over `.ds-file-open`, Arrow/Home/End + Backspace->`onUp`); new exports `FileSkeleton`+`sortFiles` (dirs-first stable sort). (2) **sessions.js** — `SessionCard` adds a words+disc status (`.ds-dash-status`, WCAG 1.4.1 — was colour-only), `lastActivity`+`currentTool` (`.ds-dash-activity`, so stuck vs busy differ), composes `counter`; `SessionDashboard` gained an `onStopAll` bulk header (`.ds-dash-header` count + stop-all). (3) **chat.js** — `ChatMessage` `streaming` prop -> blinking `.chat-stream-caret`; `actions[]` -> hover `.chat-msg-actions` row. (4) **agent-chat.js** — `.agentchat-thread-wrap` + `.agentchat-jump` (scroll-listener reveals jump-to-latest when scrolled up; scroll-anchoring no longer fights a reading user); wires `onCopyMessage/onRetryMessage/onEditMessage` + `streaming`. (5) **context-pane.js** — `usage` prop -> a `last turn` panel (tokens/cost/turns/duration — the dropped `result` event). (6) **shell.js (LOAD-BEARING mobile fix)** — the `<900px` sessions + pane drawers were DEAD (`.ws-sessions-open`/`.ws-pane-open` never toggled, no scrim): added `toggleWsDrawer`/`closeWsDrawers` + a `.ws-scrim` + crumb-hosted drawer toggles + Esc-close + auto-close-on-select; pane mobile reveal now keys off `.ws-pane-open` not `:not(.ws-pane-collapsed)`; rail/pane toggle aria-labels flip expand/collapse (were stale). chat.css: `.ds-session-group`/`-rows`/sticky label, session new+search bumped to 44px touch targets.
+**Server.** `lib/http-handler.js` `/api/list` reports a per-entry `permissions` (`['read','write']` | `'EACCES'`) via `fs.accessSync`. New confined `/api/download` (raw bytes, `confineToRoots` realpath, 50MB cap, attachment disposition) — verified to 403 both out-of-roots and traversal. `backend.js` `listDir` carries `r.status` so the app maps 403/404 to plain copy; `downloadUrl()` is token-threaded.
+
+**Scope cuts (documented in punch-list, not gaps).** File rename/delete (read-only browser, no mutation endpoints), upload/DropZone (legacy `routes-upload.js` is conversationId-keyed, not reusable), retry kept last-turn-only (mid-thread retry would destroy history).
+
+**Witness.** localhost:3000/gm/ 0 console/page errors across chat/files/live/settings/history; per-block code copy + preview pane (opens with prev/next stepper) + dashboard stream line render; whole-DOM decorative-glyph count 0 (kept middot/ellipsis/dash); no h-scroll; a11y skip-link/`role=group`/`role=checkbox`/44px verified. Kit `lint-tokens`+`lint-glyphs` pass on build. **The app.js `C` destructure MUST list every kit component it calls (`Icon`/`RootsPicker`/`FilePreviewPane` were missing — the browser witness caught `Icon is not defined`).** Update flow unchanged: edit kit -> `node scripts/build.mjs` -> copy `dist/247420.{js,css}` into `site/app/vendor/anentrypoint-design/` -> witness -> push kit (rebase + rebuild dist when remote advances).
+
+## GUI predictability + polish sweep (2026-06-05) — fifth maximum-effort run
 
-**App wiring (`site/app/js/app.js`).** `sessionGroups()` -> kit `groups` (Running pinned + Today/Yesterday/This-week/Earlier); chat-tab inline search now shows server hits in the rail on BOTH tabs (was a dead control); `liveMain` fills per-session metrics/last-activity/current-tool from `sessionsBySid` + `stopAllActive`; `startLiveTick()` 1s elapsed advance; `filesMain` sort/filter/skeleton/roots-picker/always-toolbar/keyboard-up; initial `loadDir`/preview-fetch moved OUT of render (`navTo('files')` effect + scheduled microtasks) — render is pure; `sendChat` captures `result.usage` -> `state.chat.usage`; `copyMessageText/retryLastTurn/editAndResend` message actions; `refreshActive` diffs `activeSig()` so the 3s poll only re-renders on real change.
+Polish sweep on the shipped Claude-Desktop redesign (`wf_980345e1-201`, 65 agents -> 44 gaps, `PUNCHLIST-POLISH.md`); new workflow `.claude/workflows/gui-predictability-polish.js`. Landed `FileGrid` sort/filter/skeleton/keyboard, `SessionCard` words+disc status + last-activity/current-tool + `onStopAll`, `ChatMessage` streaming caret + `.chat-msg-actions`, `AgentChat` jump-to-latest, `ContextPane` last-turn usage, the load-bearing `<900px` drawer fix (`.ws-scrim` + `toggleWsDrawer`), and `confineToRoots()` realpath symlink-confinement on `/api/list,file,image`. The 7th run (above) supersedes/extends most of these. Full detail in rs-learn (recall "agentgui GUI predictability+polish sweep").
 
 **Security (`lib/http-handler.js`).** New `confineToRoots()` shared helper adds `fs.realpathSync` re-confinement to `/api/list`, `/api/file`, `/api/image` — a symlink living inside an allowed root but pointing OUTSIDE it passed the lexical prefix check but the resolved target now fails closed (symlink-escape / link-traversal, the workflow's one high-severity server gap).
 

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [Unreleased] - GUI cohesion sweep: one-product chat-agent feel (kit 9ef409a, app 15b626c)
+
+- new workflow `.claude/workflows/gui-cohesion.js` (6 cohesion lenses -> adversarial verify -> ordered plan; 61 agents -> 40 confirmed gaps, `PUNCHLIST-COHESION.md`) — hunts the product-cohesion/feel gap vs claude.ai/code / cowork / Claude-Desktop, distinct from the audit/overhaul/predictability-polish workflows. Why: the shipped surfaces still read as a kit of parts.
+- kit: per-block code copy buttons; fence-aware streaming (no prose->block reflow); composer context line + per-agent avatar + follow-up chips; SessionCard stale/idle status + select + active, SessionDashboard sort/filter/errors-only + stop-selected + stream-state; FileGrid large-dir cap + role=group + permissions tag + RootsPicker; FilePreviewPane split-view + prev/next stepper; ContextPane empty state; WorkspaceShell stable column geometry; one canonical status disc + unified rail tones + 44px touch targets. Why: close the cohesion gaps as correct kit defaults.
+- app: inline file preview pane, live-session stale detection + per-sid SSE tally + bulk select, stable shell frame, sentence-case titles, rail ThemeToggle footer; deleted the index.html status-dot override (kit owns the disc). Server: `/api/list` per-entry permissions + confined `/api/download`. Why: wire the kit and eliminate the last app-layer override.
+- witnessed localhost:3000/gm/ 0 console/page errors across all tabs, 0 decorative glyphs, no h-scroll, a11y verified.
+
 ## [Unreleased] - GUI moved into the anentrypoint-design kit, loaded from unpkg
 
 - the chat GUI now lives in the design kit: added a reusable `AgentChat` component to anentrypoint-design (agent-then-model picker + AICat auto-scroll/thinking + tool parts + cwd bar + caret-stable composer), pure props-in/vnode-out with all transport as host callbacks. Published via the kit's CI to npm -> unpkg.