From 6ba739f8bdbd59e2173d886fb4cb437cb249059e Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Tue, 25 Aug 2026 10:27:33 -0700
Subject: [PATCH 1/6] Add tests for tool-activity chip sentences and action
 glyphs

---
 packages/chat-ui/src/tool-activity.test.ts    | 163 ++++++++++++++++--
 .../chat-ui/test/tool-activity-view.test.tsx  |  30 +++-
 2 files changed, 181 insertions(+), 12 deletions(-)

diff --git a/packages/chat-ui/src/tool-activity.test.ts b/packages/chat-ui/src/tool-activity.test.ts
index 01627d94f..5defb56c4 100644
--- a/packages/chat-ui/src/tool-activity.test.ts
+++ b/packages/chat-ui/src/tool-activity.test.ts
@@ -31,13 +31,18 @@ describe("resolveToolIdentity", () => {
         server: "notion",
         tool: "search_pages",
       }),
-    ).toEqual({ provider: "notion", words: ["search", "pages"] });
+    ).toEqual({
+      provider: "notion",
+      words: ["search", "pages"],
+      toolName: "search_pages",
+    });
   });
 
   test("splits a provider-namespaced tool on its double underscore", () => {
     expect(resolveToolIdentity("slack__post_message", {})).toEqual({
       provider: "slack",
       words: ["post", "message"],
+      toolName: "post_message",
     });
   });
 
@@ -45,6 +50,7 @@ describe("resolveToolIdentity", () => {
     expect(resolveToolIdentity("linear.save_issue", {})).toEqual({
       provider: "linear",
       words: ["save", "issue"],
+      toolName: "save_issue",
     });
   });
 
@@ -52,6 +58,7 @@ describe("resolveToolIdentity", () => {
     expect(resolveToolIdentity("webSearch", {})).toEqual({
       provider: undefined,
       words: ["web", "search"],
+      toolName: "webSearch",
     });
   });
 
@@ -59,6 +66,7 @@ describe("resolveToolIdentity", () => {
     expect(resolveToolIdentity("mcp_read", { server: "notion" })).toEqual({
       provider: undefined,
       words: ["mcp", "read"],
+      toolName: "mcp_read",
     });
   });
 });
@@ -116,13 +124,76 @@ describe("describeToolCall", () => {
 
   test("an unknown verb still loses its underscores rather than leaking raw", () => {
     const phrase = describeToolCall("acme__frobnicate_widget", {}, "past");
-    expect(phrase).toBe("Frobnicate widget in Acme");
+    expect(phrase).toBe("Frobnicate widget");
     expect(phrase).not.toContain("_");
   });
 
   test("a plural object drops the article", () => {
     expect(describeToolCall("list_files", {}, "past")).toBe("Listed files");
   });
+
+  test("a colon-namespaced GitHub tool still names the provider, not the id", () => {
+    expect(describeToolCall("github:get_issue", {}, "past")).toBe(
+      "Retrieved an issue in GitHub",
+    );
+    expect(describeToolCall("github__get_issue", {}, "past")).toBe(
+      "Retrieved an issue in GitHub",
+    );
+  });
+
+  test("a bare search names the query and never the identifier", () => {
+    expect(describeToolCall("search", { q: "x" }, "past")).toBe(
+      'Searched for "x"',
+    );
+  });
+
+  test("an unknown colon-namespaced verb title-cases the end name, not the package", () => {
+    expect(describeToolCall("acme:frobnicate_widget", {}, "past")).toBe(
+      "Frobnicate widget",
+    );
+  });
+
+  test("an Interchange memory search is a layman sentence, not a qualified id", () => {
+    const phrase = describeToolCall(
+      "@corbits/memory-tools/memory:memory_search",
+      { query: "outbound" },
+      "past",
+    );
+    expect(phrase).toBe('Searched memory for "outbound"');
+    expect(phrase).not.toContain("@");
+    expect(phrase).not.toContain("/");
+    expect(phrase).not.toContain(":");
+  });
+
+  test("an Interchange memory search still running has no query to name", () => {
+    expect(
+      describeToolCall(
+        "@corbits/memory-tools/memory:memory_search",
+        {},
+        "present",
+      ),
+    ).toBe("Searching memory");
+  });
+
+  test("an Interchange list-agents call pluralizes without a package path", () => {
+    expect(
+      describeToolCall(
+        "@corbits/agent-directory-tools/ad:list_agents",
+        {},
+        "past",
+      ),
+    ).toBe("Listed agents");
+  });
+
+  test("an Interchange ask-user call is a question, not the tool id", () => {
+    expect(
+      describeToolCall(
+        "@corbits/interaction-tools/ask-user:ask_user",
+        {},
+        "past",
+      ),
+    ).toBe("Asked a question");
+  });
 });
 
 describe("plainTextOfOutput", () => {
@@ -200,6 +271,82 @@ describe("toToolActivityRow", () => {
     expect(row.phrase).toBe('Searching the web for "x"');
     expect(row.detail).toBeUndefined();
   });
+
+  test("an Interchange memory search carries the end name, no provider, and a search glyph", () => {
+    const row = toToolActivityRow(
+      trace({
+        name: "@corbits/memory-tools/memory:memory_search",
+        input: { query: "outbound" },
+        status: "success",
+      }),
+      "k",
+    );
+    expect(row.phrase).toBe('Searched memory for "outbound"');
+    expect(row.provider).toBeUndefined();
+    expect(row.toolName).toBe("memory_search");
+    expect(["search", "memory"]).toContain(row.glyph);
+    expect(row.phrase).not.toContain("@");
+    expect(row.phrase).not.toContain("/");
+    expect(row.phrase).not.toContain(":");
+  });
+
+  test("ask_user success never opens onto the model-facing instruction", () => {
+    const row = toToolActivityRow(
+      trace({
+        name: "@corbits/interaction-tools/ask-user:ask_user",
+        status: "success",
+        output:
+          "The question has been shown to the user. Do not repeat the question.",
+      }),
+      "k",
+    );
+    expect(row.phrase).toBe("Asked a question");
+    expect(row.detail).toBeUndefined();
+    expect(row.toolName).toBe("ask_user");
+    expect(row.glyph).toBe("ask");
+  });
+
+  test("a JSON items payload becomes a result count, not the JSON", () => {
+    const json = JSON.stringify({ items: [{}, {}, {}] });
+    const row = toToolActivityRow(
+      trace({
+        name: "memory_search",
+        status: "success",
+        output: json,
+      }),
+      "k",
+    );
+    expect(row.detail).toBe("3 results.");
+    expect(row.detail).not.toContain("{");
+    expect(row.detail).not.toContain("items");
+  });
+
+  test("JSON sitting inside a content-block text field is still a count, not the JSON", () => {
+    const row = toToolActivityRow(
+      trace({
+        name: "memory_search",
+        status: "success",
+        output: [
+          {
+            type: "text",
+            text: JSON.stringify({ items: [{}, {}] }),
+          },
+        ],
+      }),
+      "k",
+    );
+    expect(row.detail).toBe("2 results.");
+    expect(row.detail).not.toContain("{");
+  });
+
+  test("an unknown colon leftover is not a provider", () => {
+    const row = toToolActivityRow(
+      trace({ name: "acme:frobnicate_widget", status: "success" }),
+      "k",
+    );
+    expect(row.provider).toBeUndefined();
+    expect(row.phrase).toBe("Frobnicate widget");
+  });
 });
 
 describe("providerTile", () => {
@@ -214,15 +361,9 @@ describe("providerTile", () => {
     });
   });
 
-  test("an unrecognized provider still gets a tile, neutral and initialed", () => {
-    const tile = providerTile("acme");
-    expect(tile.initials).toBe("Ac");
-    expect(tile.color).toBe("var(--muted-foreground)");
-  });
-
-  test("a bare local tool with no provider namespace still gets a tile", () => {
-    const tile = providerTile(undefined);
-    expect(tile.initials.length).toBeGreaterThan(0);
+  test("an unrecognized leftover is not a brand tile", () => {
+    expect(providerTile("acme")).toBeUndefined();
+    expect(providerTile("memory")).toBeUndefined();
   });
 });
 
diff --git a/packages/chat-ui/test/tool-activity-view.test.tsx b/packages/chat-ui/test/tool-activity-view.test.tsx
index 8230b6c5b..318a8e591 100644
--- a/packages/chat-ui/test/tool-activity-view.test.tsx
+++ b/packages/chat-ui/test/tool-activity-view.test.tsx
@@ -142,7 +142,7 @@ describe("ToolActivityGroup", () => {
     expect(el.textContent).toContain("Repository not found");
   });
 
-  test("every chip carries a provider tile", () => {
+  test("a known-provider chip uses brand initials, not a dash", () => {
     const el = mount([
       trace({ name: "slack__post_message", input: { channel: "general" } }),
     ]);
@@ -150,4 +150,32 @@ describe("ToolActivityGroup", () => {
       "Sl",
     );
   });
+
+  test("a qualified memory search chip is a layman sentence, not a package path", () => {
+    const el = mount([
+      trace({
+        name: "@corbits/memory-tools/memory:memory_search",
+        input: { query: "outbound" },
+      }),
+    ]);
+    expect(el.textContent).toContain("Searched memory");
+    expect(el.textContent).not.toContain("@corbits");
+    expect(el.textContent).not.toContain("memory-tools");
+    expect(el.innerHTML).not.toContain("—");
+    expect(el.querySelector('[data-status="success"]')).not.toBeNull();
+    expect(el.querySelector(".chat-tool-activity-tile svg")).not.toBeNull();
+  });
+
+  test("a local tool still running keeps a status of running and a leading glyph", () => {
+    const el = mount([
+      trace({
+        name: "memory_search",
+        input: {},
+        status: "running",
+      }),
+    ]);
+    expect(el.querySelector('[data-status="running"]')).not.toBeNull();
+    expect(el.innerHTML).not.toContain("—");
+    expect(el.querySelector(".chat-tool-activity-tile svg")).not.toBeNull();
+  });
 });

From ee2f77f4f23dd15117161bb4979729136832fe65 Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Tue, 25 Aug 2026 10:27:36 -0700
Subject: [PATCH 2/6] Restyle tool-activity chips as layman sentences with
 action glyphs

---
 packages/chat-ui/src/styles.css             | 135 +++++--
 packages/chat-ui/src/tool-activity-view.tsx | 147 +++++--
 packages/chat-ui/src/tool-activity.ts       | 402 +++++++++++++++-----
 packages/chat-ui/src/turn-activity.tsx      |   7 +-
 4 files changed, 516 insertions(+), 175 deletions(-)

diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index 57df5848b..0b34902d7 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -2146,18 +2146,16 @@
 
 /* Tool-use chips (CL-6466, conforming to mock-spec §12.3): inline chips
    stacked under the agent's prose, one per call — never collapsibles.
-   `.chat-tool-activity` is the stack; each `.chat-tool-activity-row` is one
-   chip, `width:max-content` so a wall of calls reads as short tags, not a
-   list. Radius uses the shared `--radius` token (§1's 8px base), matching
-   every other chip in the app instead of the zero-radius the old
-   generative-UI framing called for. */
+   `.chat-tool-activity` is the stack; each `.chat-tool-activity-row` wraps
+   one chip plus optional detail. The chip hugs its content so a wall of
+   calls reads as short tags, not a list. Radius follows `--radius`. */
 .chat-tool-activity {
   display: flex;
   flex-direction: column;
   align-items: flex-start;
   gap: 0.5rem;
   padding: 0.15rem 0;
-  font-size: 0.72rem;
+  font-size: 0.8125rem;
   color: var(--muted-foreground);
 }
 
@@ -2168,9 +2166,7 @@
 }
 
 /* The row is the outer wrapper — chip on top, its optional detail
-   underneath. The chip itself (this selector plus `.chat-tool-activity-
-   trigger`) is what's `width:max-content`: it hugs its content so a wall
-   of calls reads as a stack of short tags, never spanning the column. */
+   underneath. `.chat-tool-activity-chip` is what's `width:max-content`. */
 .chat-tool-activity-row {
   display: flex;
   flex-direction: column;
@@ -2182,19 +2178,23 @@
   margin-left: 0.18rem;
 }
 
-.chat-tool-activity-row:not(:has(.chat-tool-activity-trigger)),
-.chat-tool-activity-trigger {
+.chat-tool-activity-chip {
   display: flex;
   flex-direction: row;
   align-items: center;
   gap: 0.5rem;
   width: max-content;
   max-width: 100%;
-  flex-wrap: wrap;
-  border: 1px solid var(--border);
-  background: var(--card, var(--background));
+  flex-wrap: nowrap;
+  border: 1px solid color-mix(in srgb, var(--foreground) 12%, transparent);
+  background: color-mix(in srgb, var(--muted) 72%, transparent);
   border-radius: var(--radius);
-  padding: 0.4rem 0.65rem;
+  padding: 0.35rem 0.75rem 0.35rem 0.4rem;
+  transition:
+    transform var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    background-color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    border-color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1));
 }
 
 .chat-tool-activity-trigger {
@@ -2225,6 +2225,10 @@
   outline-offset: 2px;
 }
 
+.chat-tool-activity-trigger:active:not(:disabled) {
+  transform: scale(0.97);
+}
+
 .chat-tool-activity-tile {
   display: inline-flex;
   flex: none;
@@ -2232,43 +2236,95 @@
   justify-content: center;
   width: 22px;
   height: 22px;
-  border-radius: 6px;
+  border-radius: var(--radius);
   font-size: 10px;
   font-weight: 800;
   color: #fff;
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, white 22%, transparent);
+}
+
+.chat-tool-activity-glyph {
+  background: color-mix(in srgb, var(--muted) 88%, var(--foreground) 6%);
+  color: var(--muted-foreground);
+  font-size: 13px;
+  font-weight: 400;
+  box-shadow: none;
+}
+
+.chat-tool-activity-glyph svg {
+  width: 1em;
+  height: 1em;
 }
 
 .chat-tool-activity-marker {
-  width: 0.4rem;
-  height: 0.4rem;
+  display: inline-flex;
   flex: none;
-  border-radius: 99px;
-  background: var(--muted-foreground);
-  opacity: 0.6;
+  align-items: center;
+  justify-content: center;
+  width: 12px;
+  height: 12px;
+  color: var(--muted-foreground);
+}
+
+.chat-tool-activity-marker svg {
+  width: 12px;
+  height: 12px;
 }
 
 .chat-tool-activity-marker[data-status="running"],
 .chat-tool-activity-marker[data-status="pending"] {
-  background: var(--muted-foreground);
-  opacity: 1;
-  animation: chat-block-pulse 1.6s ease infinite;
+  animation: chat-tool-activity-spin 0.8s linear infinite;
 }
 
-/* A failure is the one state that earns colour here — everything else in
-   this strip is deliberately quiet chrome. */
 .chat-tool-activity-marker[data-status="failed"] {
-  background: var(--destructive, #b42318);
-  opacity: 1;
+  color: var(--destructive, #b42318);
+}
+
+@keyframes chat-tool-activity-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .chat-tool-activity-chip,
+  .chat-tool-activity-trigger,
+  .chat-tool-activity-caret {
+    transition: none;
+  }
+
+  .chat-tool-activity-trigger:active:not(:disabled) {
+    transform: none;
+  }
+
+  .chat-tool-activity-marker[data-status="running"],
+  .chat-tool-activity-marker[data-status="pending"] {
+    animation: none;
+  }
 }
 
 .chat-tool-activity-row[data-status="failed"] .chat-tool-activity-phrase {
   color: var(--destructive, #b42318);
+  opacity: 1;
+}
+
+.chat-tool-activity-row[data-status="running"] .chat-tool-activity-phrase,
+.chat-tool-activity-row[data-status="pending"] .chat-tool-activity-phrase {
+  color: var(--foreground);
+  opacity: 0.7;
 }
 
 .chat-tool-activity-phrase {
   min-width: 0;
   flex: 1 1 auto;
-  overflow-wrap: anywhere;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 0.8125rem;
+  font-weight: 450;
+  letter-spacing: -0.01em;
+  color: var(--foreground);
+  opacity: 0.82;
 }
 
 .chat-tool-activity-meta {
@@ -2283,8 +2339,10 @@
   flex: none;
   width: 1em;
   height: 1em;
-  font-size: 0.75rem;
-  transition: transform 0.15s ease-out;
+  font-size: 11px;
+  color: var(--muted-foreground);
+  transition: transform var(--duration-standard, 180ms)
+    var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1));
 }
 
 .chat-tool-activity-caret[data-open="true"] {
@@ -2293,15 +2351,21 @@
 
 .chat-tool-activity-detail {
   margin: 0;
-  padding: 0.5rem 0.65rem;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
+  padding: 0.1rem 0.75rem 0.15rem 2.15rem;
   max-width: 100%;
   max-height: 12rem;
   overflow: auto;
   white-space: pre-wrap;
   overflow-wrap: anywhere;
   color: var(--muted-foreground);
+  font-size: 0.8125rem;
+}
+
+.chat-tool-activity-thinking,
+.chat-tool-activity-retry {
+  padding: 0.15rem 0.15rem 0.15rem 2.15rem;
+  font-size: 0.8125rem;
+  color: var(--muted-foreground);
 }
 
 .chat-tool-activity-thinking {
@@ -2328,8 +2392,7 @@
     }
   }
 
-  .chat-tool-activity-row:not(:has(.chat-tool-activity-trigger)),
-  .chat-tool-activity-trigger {
+  .chat-tool-activity-chip {
     animation: chat-tool-activity-in 160ms var(--chat-ease);
   }
 }
diff --git a/packages/chat-ui/src/tool-activity-view.tsx b/packages/chat-ui/src/tool-activity-view.tsx
index 4facf251b..3e55af253 100644
--- a/packages/chat-ui/src/tool-activity-view.tsx
+++ b/packages/chat-ui/src/tool-activity-view.tsx
@@ -3,48 +3,133 @@
 // One presentation serves both the live strip (`turn-activity.tsx`) and the
 // persisted transcript (`timeline.tsx`), so a call that reads one way while
 // it runs doesn't restyle itself the moment the turn ends. Chips, not
-// collapsibles: a provider tile, one sentence, a status marker, and — only
-// when there is something to show — a disclosure onto plain-text detail.
-// Calls stack one per call; nothing here ever folds several into a count.
-// The sentences come from `tool-activity.ts`; nothing here formats a
-// tool's own data.
+// collapsibles: a glyph, one sentence, a status icon, and — only when there
+// is something to show — a disclosure onto plain-text detail. Calls stack
+// one per call; nothing here ever folds several into a count. The sentences
+// come from `tool-activity.ts`; nothing here formats a tool's own data.
 
-import { CaretRight } from "@corbits/icons";
+import {
+  BookBookmark,
+  CaretRight,
+  ChatCircleDots,
+  Check,
+  CircleNotch,
+  Lightning,
+  ListBullets,
+  MagnifyingGlass,
+  PencilSimple,
+  Users,
+  WarningCircle,
+} from "@corbits/icons";
+import type { ReactNode } from "react";
 import { useState } from "react";
 
 import { CHAT_STRINGS } from "./strings";
 import {
   providerTile,
+  type ToolActivityGlyph,
   type ToolActivityRow,
   type ToolActivityStatus,
 } from "./tool-activity";
 
 function StatusMarker({ status }: { readonly status: ToolActivityStatus }) {
+  const icon =
+    status === "failed" ? (
+      <WarningCircle />
+    ) : status === "running" || status === "pending" ? (
+      <CircleNotch />
+    ) : (
+      <Check />
+    );
   return (
     <span
       className="chat-tool-activity-marker"
       data-status={status}
       aria-hidden="true"
-    />
+    >
+      {icon}
+    </span>
   );
 }
 
-/** The chip's leading brand mark — 22×22, provider-colored, two letters.
- * Present on every chip, per §12.3's anatomy; a bare local tool gets the
- * neutral fallback tile rather than no tile at all. */
-function ProviderTile({ provider }: { readonly provider: string | undefined }) {
-  const tile = providerTile(provider);
+function ActionGlyph({ glyph }: { readonly glyph: ToolActivityGlyph }) {
+  let icon: ReactNode;
+  switch (glyph) {
+    case "search":
+      icon = <MagnifyingGlass />;
+      break;
+    case "list":
+      icon = <ListBullets />;
+      break;
+    case "ask":
+      icon = <ChatCircleDots />;
+      break;
+    case "memory":
+      icon = <BookBookmark />;
+      break;
+    case "agents":
+      icon = <Users />;
+      break;
+    case "write":
+      icon = <PencilSimple />;
+      break;
+    default:
+      icon = <Lightning />;
+      break;
+  }
   return (
     <span
-      className="chat-tool-activity-tile"
-      style={{ background: tile.color }}
+      className="chat-tool-activity-tile chat-tool-activity-glyph"
       aria-hidden="true"
     >
-      {tile.initials}
+      {icon}
     </span>
   );
 }
 
+function LeadingMark({ row }: { readonly row: ToolActivityRow }) {
+  const tile =
+    row.provider === undefined ? undefined : providerTile(row.provider);
+  if (tile !== undefined) {
+    return (
+      <span
+        className="chat-tool-activity-tile"
+        style={{ background: tile.color }}
+        aria-hidden="true"
+      >
+        {tile.initials}
+      </span>
+    );
+  }
+  return <ActionGlyph glyph={row.glyph} />;
+}
+
+function ChipBody({
+  row,
+  open,
+}: {
+  readonly row: ToolActivityRow;
+  readonly open: boolean;
+}) {
+  return (
+    <>
+      <LeadingMark row={row} />
+      <span className="chat-tool-activity-phrase">{row.phrase}</span>
+      {row.meta === undefined ? null : (
+        <span className="chat-tool-activity-meta">{row.meta}</span>
+      )}
+      <StatusMarker status={row.status} />
+      {row.detail === undefined ? null : (
+        <CaretRight
+          className="chat-tool-activity-caret"
+          data-open={open}
+          aria-hidden="true"
+        />
+      )}
+    </>
+  );
+}
+
 function ToolActivityLine({
   row,
   indented,
@@ -62,12 +147,9 @@ function ToolActivityLine({
         data-status={row.status}
         data-indented={indented}
       >
-        <ProviderTile provider={row.provider} />
-        <span className="chat-tool-activity-phrase">{row.phrase}</span>
-        {row.meta === undefined ? null : (
-          <span className="chat-tool-activity-meta">{row.meta}</span>
-        )}
-        <StatusMarker status={row.status} />
+        <div className="chat-tool-activity-chip" title={row.toolName}>
+          <ChipBody row={row} open={false} />
+        </div>
       </div>
     );
   }
@@ -80,21 +162,12 @@ function ToolActivityLine({
     >
       <button
         type="button"
-        className="chat-tool-activity-trigger"
+        className="chat-tool-activity-chip chat-tool-activity-trigger"
         aria-expanded={open}
+        title={row.toolName}
         onClick={() => setOpen((value) => !value)}
       >
-        <ProviderTile provider={row.provider} />
-        <span className="chat-tool-activity-phrase">{row.phrase}</span>
-        {row.meta === undefined ? null : (
-          <span className="chat-tool-activity-meta">{row.meta}</span>
-        )}
-        <StatusMarker status={row.status} />
-        <CaretRight
-          className="chat-tool-activity-caret"
-          data-open={open}
-          aria-hidden="true"
-        />
+        <ChipBody row={row} open={open} />
       </button>
       {open ? <p className="chat-tool-activity-detail">{row.detail}</p> : null}
     </div>
@@ -114,7 +187,7 @@ export function ToolActivityGroup({
 }) {
   if (rows.length === 0) return null;
   return (
-    <div className="chat-tool-activity">
+    <div className="chat-tool-activity" data-slot="tool-activity">
       {rows.map((row) => (
         <ToolActivityLine key={row.key} row={row} indented={false} />
       ))}
@@ -137,7 +210,11 @@ export function LiveToolActivity({
 }) {
   if (rows.length === 0 && !thinking && retryCount === 0) return null;
   return (
-    <div className="chat-tool-activity chat-tool-activity-live" role="status">
+    <div
+      className="chat-tool-activity chat-tool-activity-live"
+      data-slot="tool-activity"
+      role="status"
+    >
       {rows.map((row) => (
         <ToolActivityLine key={row.key} row={row} indented={false} />
       ))}
diff --git a/packages/chat-ui/src/tool-activity.ts b/packages/chat-ui/src/tool-activity.ts
index e2641b4df..908867f0b 100644
--- a/packages/chat-ui/src/tool-activity.ts
+++ b/packages/chat-ui/src/tool-activity.ts
@@ -4,11 +4,15 @@
 // whatever the tool handed back (`ToolTracePart` in `@corbits/chat/parts`,
 // assembled by the chat orchestrator from `inferenceDoneBlocks` /
 // `toolDoneResult`). None of those three is fit to show anyone: the
-// identifier is a symbol (`slack__post_message`), the arguments are JSON,
-// and the result is usually a content-block array. This module is the one
-// place that translates all three into plain sentences — "Posted a message
-// in Slack", "Found 8 results", "Couldn't reach GitHub" — so no surface
-// downstream ever has to reach for `JSON.stringify` to say what happened.
+// identifier is a symbol (`slack__post_message`, or an Interchange qualified
+// id `@scope/package/export:tool`), the arguments are JSON, and the result
+// is usually a content-block array. This module is the one place that
+// translates all three into plain sentences — "Posted a message in Slack",
+// "Searched memory for "outbound"" — so no surface downstream ever has to
+// reach for `JSON.stringify` to say what happened. The phrase uses the
+// segment after the last colon (the end tool name); a leftover path is a
+// provider only when it maps onto a known brand, never `@corbits` or a
+// package stem like `memory-tools`.
 //
 // Both the live strip (`turn-activity.tsx`, mid-turn) and the persisted
 // transcript (`timeline.tsx`) render through here, which is why a phrase
@@ -20,15 +24,25 @@ import type { Part, ToolTracePart } from "@corbits/chat/parts";
 
 export type ToolActivityStatus = "pending" | "running" | "success" | "failed";
 
+export type ToolActivityGlyph =
+  | "search"
+  | "list"
+  | "ask"
+  | "memory"
+  | "agents"
+  | "write"
+  | "generic";
+
 /** One tool call, ready to render: no identifiers, no JSON, no tense
  * mismatch with its own status. */
 export type ToolActivityRow = {
   readonly key: string;
-  /** The raw tool identifier. Never rendered — carried so a row keeps its
-   * provenance for tests and debugging. */
+  /** The end tool name (`memory_search`), used as the chip's hover title. */
   readonly toolName: string;
+  /** Action glyph for a local tool. Known brand providers use a tile instead. */
+  readonly glyph: ToolActivityGlyph;
   /** The provider namespace a call belongs to, e.g. `"slack"` — undefined
-   * for a bare local tool. Feeds the chip's leading tile. */
+   * for a bare local tool. Feeds the chip's leading brand tile when known. */
   readonly provider: string | undefined;
   readonly phrase: string;
   /** The on-demand detail, already plain text. Undefined when the tool
@@ -44,16 +58,18 @@ export type ToolActivityRow = {
 const MAX_PHRASE_ARGUMENT = 48;
 const MAX_FAILURE_DETAIL = 240;
 const MAX_SUCCESS_DETAIL = 600;
+const MAX_SHORT_FIELD = 240;
 
 type Tense = "past" | "present";
 
 type Conjugation = { readonly past: string; readonly present: string };
 
-/** The verbs tool names actually start with, in the two forms a transcript
- * needs. Irregulars are why this is a table and not a suffix rule. */
+/** The verbs tool names actually start (or end) with, in the two forms a
+ * transcript needs. Irregulars are why this is a table and not a suffix rule. */
 const VERBS: Record<string, Conjugation> = {
   add: { past: "Added", present: "Adding" },
   archive: { past: "Archived", present: "Archiving" },
+  ask: { past: "Asked", present: "Asking" },
   browse: { past: "Browsed", present: "Browsing" },
   build: { past: "Built", present: "Building" },
   call: { past: "Called", present: "Calling" },
@@ -107,7 +123,7 @@ export type ProviderTile = {
 /** Brand mark for the chip's leading tile — two letters and the provider's
  * own color, the way the mock's `[Li #5E6AD2]` / `[GH #24292f]` read. Only
  * providers a person would recognise on sight get a fixed brand color;
- * anything else falls back to a neutral tile rather than guessing a color. */
+ * anything else is not a brand — the chip uses an action glyph. */
 const PROVIDER_TILES: Record<string, ProviderTile> = {
   github: { initials: "GH", color: "#24292f" },
   gitlab: { initials: "GL", color: "#fc6d26" },
@@ -117,26 +133,19 @@ const PROVIDER_TILES: Record<string, ProviderTile> = {
   slack: { initials: "Sl", color: "#4a154b" },
 };
 
-const FALLBACK_TILE_COLOR = "var(--muted-foreground)";
-
-function fallbackInitials(provider: string): string {
-  const word = provider.replace(/[_-]+/g, "").trim();
-  if (word.length >= 2) {
-    return `${word.charAt(0).toUpperCase()}${word.charAt(1).toLowerCase()}`;
-  }
-  return word.toUpperCase() || "?";
-}
-
-/** The tile a tool-use chip leads with. `undefined` (a bare local tool,
- * no provider namespace) reads as a neutral "-" tile rather than nothing —
- * the anatomy always has a tile. */
-export function providerTile(provider: string | undefined): ProviderTile {
-  if (provider === undefined) {
-    return { initials: "—", color: FALLBACK_TILE_COLOR };
-  }
-  const known = PROVIDER_TILES[provider.toLowerCase()];
-  if (known !== undefined) return known;
-  return { initials: fallbackInitials(provider), color: FALLBACK_TILE_COLOR };
+/** Path segments that look like a namespace but are not a brand provider. */
+const NOT_PROVIDERS = new Set([
+  "memory",
+  "ad",
+  "ask-user",
+  "corbits",
+  "@corbits",
+]);
+
+/** Brand mark for a known provider. Unknown leftovers are not brands —
+ * the chip uses an action glyph instead of inventing initials. */
+export function providerTile(provider: string): ProviderTile | undefined {
+  return PROVIDER_TILES[provider.toLowerCase()];
 }
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -172,11 +181,81 @@ function providerDisplayName(provider: string): string {
   return titleCase(provider.replace(/[_-]+/g, " "));
 }
 
-type ToolIdentity = {
+export type ToolIdentity = {
   readonly provider: string | undefined;
   readonly words: readonly string[];
+  readonly toolName: string;
 };
 
+function splitToolWords(name: string): readonly string[] {
+  const spaced = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return spaced
+    .split(/[_\-.\s]+/)
+    .map((word) => word.toLowerCase())
+    .filter((word) => word !== "");
+}
+
+function packageStem(segment: string): string {
+  const id = segment.replace(/^@/, "").toLowerCase();
+  return id.endsWith("-tools") ? id.slice(0, -"-tools".length) : id;
+}
+
+function knownBrandId(candidate: string): string | undefined {
+  const stemmed = packageStem(candidate);
+  if (stemmed === "" || NOT_PROVIDERS.has(stemmed)) return undefined;
+  if (
+    PROVIDER_NAMES[stemmed] !== undefined ||
+    PROVIDER_TILES[stemmed] !== undefined
+  ) {
+    return stemmed;
+  }
+  return undefined;
+}
+
+function providerFromLeftover(leftover: string | undefined): string | undefined {
+  if (leftover === undefined || leftover === "") return undefined;
+  const interchange = leftover.includes("/") || leftover.startsWith("@");
+  if (interchange) {
+    const segments = leftover.split("/").filter((segment) => segment !== "");
+    for (const segment of segments) {
+      const known = knownBrandId(segment);
+      if (known !== undefined) return known;
+    }
+    return undefined;
+  }
+  const known = knownBrandId(leftover);
+  if (known !== undefined) return known;
+  return undefined;
+}
+
+function splitQualifiedName(name: string): {
+  leftover: string | undefined;
+  toolName: string;
+} {
+  const colon = name.lastIndexOf(":");
+  if (colon !== -1) {
+    return {
+      leftover: name.slice(0, colon) || undefined,
+      toolName: name.slice(colon + 1),
+    };
+  }
+  const namespaced = name.split("__");
+  if (namespaced.length > 1 && namespaced[0] !== undefined) {
+    return {
+      leftover: namespaced[0],
+      toolName: namespaced.slice(1).join("_"),
+    };
+  }
+  const dotted = name.split(".");
+  if (dotted.length > 1 && dotted[0] !== undefined) {
+    return {
+      leftover: dotted[0],
+      toolName: dotted.slice(1).join("_"),
+    };
+  }
+  return { leftover: undefined, toolName: name };
+}
+
 /**
  * Splits a tool identifier into the provider it belongs to and the words
  * describing what it does.
@@ -186,6 +265,11 @@ type ToolIdentity = {
  * one of those two names, with the tool it actually invoked sitting in its
  * `{server, tool}` arguments — so those are read first, or a whole
  * conversation's worth of calls would all read alike.
+ *
+ * Interchange qualified ids (`@scope/package/export:tool`) take the
+ * segment after the last `:`. A leftover path is a provider only when a
+ * segment or `-tools` stem is a known brand; `memory`, `ad`, and
+ * `ask-user` never are.
  */
 export function resolveToolIdentity(
   name: string,
@@ -196,32 +280,33 @@ export function resolveToolIdentity(
     const server = readString(args, "server");
     const tool = readString(args, "tool");
     if (server !== undefined && tool !== undefined) {
-      return { provider: server, words: splitToolWords(tool) };
+      return {
+        provider: providerFromLeftover(server) ?? server,
+        words: splitToolWords(tool),
+        toolName: tool,
+      };
     }
   }
-  const namespaced = name.split("__");
-  if (namespaced.length > 1 && namespaced[0] !== undefined) {
-    return {
-      provider: namespaced[0],
-      words: splitToolWords(namespaced.slice(1).join("_")),
-    };
-  }
-  const dotted = name.split(".");
-  if (dotted.length > 1 && dotted[0] !== undefined) {
-    return {
-      provider: dotted[0],
-      words: splitToolWords(dotted.slice(1).join("_")),
-    };
-  }
-  return { provider: undefined, words: splitToolWords(name) };
+  const split = splitQualifiedName(name);
+  return {
+    provider: providerFromLeftover(split.leftover),
+    words: splitToolWords(split.toolName),
+    toolName: split.toolName,
+  };
 }
 
-function splitToolWords(name: string): readonly string[] {
-  const spaced = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
-  return spaced
-    .split(/[_\-.\s]+/)
-    .map((word) => word.toLowerCase())
-    .filter((word) => word !== "");
+export function toolActivityGlyph(
+  words: readonly string[],
+): ToolActivityGlyph {
+  const has = (candidates: readonly string[]) =>
+    words.some((word) => candidates.includes(word));
+  if (has(["search", "find", "query", "grep", "glob"])) return "search";
+  if (has(["list"])) return "list";
+  if (has(["ask"])) return "ask";
+  if (has(["memory"])) return "memory";
+  if (has(["agent", "agents"])) return "agents";
+  if (has(["write", "edit", "create", "add"])) return "write";
+  return "generic";
 }
 
 /** A file path's last segment — the part a person recognises. */
@@ -291,20 +376,47 @@ function argumentClause(input: unknown): string | undefined {
   return undefined;
 }
 
-function isWebSearch(identity: ToolIdentity): boolean {
-  const hasSearchVerb =
-    identity.words.includes("search") || identity.words.includes("browse");
-  const hasWebObject =
-    identity.words.includes("web") || identity.words.includes("internet");
-  return hasSearchVerb && hasWebObject;
+function pickVerb(words: readonly string[]): {
+  verb: string | undefined;
+  objectWords: readonly string[];
+} {
+  const first = words[0];
+  const last = words.length > 1 ? words[words.length - 1] : undefined;
+  if (first !== undefined && VERBS[first] !== undefined) {
+    return { verb: first, objectWords: words.slice(1) };
+  }
+  if (last !== undefined && VERBS[last] !== undefined) {
+    return { verb: last, objectWords: words.slice(0, -1) };
+  }
+  return { verb: undefined, objectWords: words };
+}
+
+function isPluralWord(word: string): boolean {
+  return word.endsWith("s") && !word.endsWith("ss");
+}
+
+function pluralize(word: string): string {
+  if (isPluralWord(word)) return word;
+  if (word.length > 1 && word.endsWith("y")) {
+    const beforeY = word.charAt(word.length - 2);
+    if (!"aeiou".includes(beforeY)) return `${word.slice(0, -1)}ies`;
+  }
+  return `${word}s`;
 }
 
-function objectPhrase(words: readonly string[]): string | undefined {
+function objectPhrase(
+  words: readonly string[],
+  verb: string | undefined,
+): string | undefined {
   if (words.length === 0) return undefined;
-  const joined = words.join(" ");
   const lastWord = words[words.length - 1] ?? "";
-  const isPlural = lastWord.endsWith("s") && !lastWord.endsWith("ss");
-  if (isPlural) return joined;
+  const rendered =
+    verb === "list" && !isPluralWord(lastWord)
+      ? [...words.slice(0, -1), pluralize(lastWord)]
+      : words;
+  const joined = rendered.join(" ");
+  const renderedLast = rendered[rendered.length - 1] ?? "";
+  if (isPluralWord(renderedLast)) return joined;
   const startsWithVowel = /^[aeiou]/.test(joined);
   return `${startsWithVowel ? "an" : "a"} ${joined}`;
 }
@@ -320,6 +432,32 @@ function buildClauseSuffix(
   return ` ${clause}`;
 }
 
+function domainHead(
+  words: readonly string[],
+  verb: string,
+  tense: Tense,
+): string | undefined {
+  const has = (word: string) => words.includes(word);
+  const conjugation = VERBS[verb];
+  if (conjugation === undefined) return undefined;
+  if (verb === "search" && (has("web") || has("internet"))) {
+    return tense === "past" ? "Searched the web" : "Searching the web";
+  }
+  if (verb === "search" && has("memory")) {
+    return tense === "past" ? "Searched memory" : "Searching memory";
+  }
+  if (verb === "list" && has("memory")) {
+    return tense === "past" ? "Listed memories" : "Listing memories";
+  }
+  if ((verb === "add" || verb === "create") && has("memory")) {
+    return tense === "past" ? "Saved a memory" : "Saving a memory";
+  }
+  if (verb === "ask" && has("user")) {
+    return tense === "past" ? "Asked a question" : "Asking a question";
+  }
+  return undefined;
+}
+
 /**
  * What this tool call did, as a sentence — in the tense its status calls
  * for. Never contains the tool's identifier, its argument JSON, or an
@@ -332,37 +470,43 @@ export function describeToolCall(
 ): string {
   const identity = resolveToolIdentity(name, input);
   const clause = argumentClause(input);
-
-  if (isWebSearch(identity)) {
-    const verb = tense === "past" ? "Searched" : "Searching";
-    const target = clause ?? "";
-    return `${verb} the web ${target}`.trim();
-  }
-
-  const verbWord = identity.words[0];
-  const conjugation = verbWord === undefined ? undefined : VERBS[verbWord];
+  const picked = pickVerb(identity.words);
   const providerSuffix =
     identity.provider === undefined
       ? ""
       : ` in ${providerDisplayName(identity.provider)}`;
 
-  if (conjugation === undefined) {
-    const fallback = identity.words.map((word) => word).join(" ");
-    const sentence = fallback === "" ? "Ran a step" : titleCase(fallback);
-    return `${sentence}${providerSuffix}`;
+  if (picked.verb !== undefined) {
+    const domain = domainHead(identity.words, picked.verb, tense);
+    if (domain !== undefined) {
+      return `${domain}${buildClauseSuffix(clause, false)}`;
+    }
+    const conjugation = VERBS[picked.verb];
+    if (conjugation !== undefined) {
+      const object = objectPhrase(picked.objectWords, picked.verb);
+      const head =
+        object === undefined
+          ? conjugation[tense]
+          : `${conjugation[tense]} ${object}`;
+      const clauseSuffix = buildClauseSuffix(clause, providerSuffix !== "");
+      return `${head}${providerSuffix}${clauseSuffix}`;
+    }
   }
 
-  const object = objectPhrase(identity.words.slice(1));
-  const head =
-    object === undefined
-      ? conjugation[tense]
-      : `${conjugation[tense]} ${object}`;
-  // The provider suffix is itself an "in …" clause, so a clause that is
-  // also locative ("in #general") drops its own preposition rather than
-  // stuttering — "Posted a message in Slack #general", never "… in Slack
-  // in #general".
-  const clauseSuffix = buildClauseSuffix(clause, providerSuffix !== "");
-  return `${head}${providerSuffix}${clauseSuffix}`;
+  const fallback = identity.words.join(" ");
+  const sentence = fallback === "" ? "Ran a step" : titleCase(fallback);
+  return `${sentence}${providerSuffix}`;
+}
+
+function decodeOutput(output: unknown): unknown {
+  if (typeof output !== "string") return output;
+  const trimmed = output.trim();
+  if (trimmed === "") return output;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return output;
+  }
 }
 
 /**
@@ -372,17 +516,18 @@ export function describeToolCall(
  * returns undefined rather than stringifying the third.
  */
 export function plainTextOfOutput(output: unknown): string | undefined {
-  if (typeof output === "string") {
-    const trimmed = output.trim();
+  const decoded = decodeOutput(output);
+  if (typeof decoded === "string") {
+    const trimmed = decoded.trim();
     return trimmed === "" ? undefined : trimmed;
   }
-  if (Array.isArray(output)) {
-    const texts = output
+  if (Array.isArray(decoded)) {
+    const texts = decoded
       .map((entry) => plainTextOfOutput(entry))
       .filter((text): text is string => text !== undefined);
     return texts.length === 0 ? undefined : texts.join("\n");
   }
-  const record = asRecord(output);
+  const record = asRecord(decoded);
   if (record === undefined) return undefined;
   const nested = record.content;
   if (nested !== undefined) {
@@ -396,11 +541,31 @@ export function plainTextOfOutput(output: unknown): string | undefined {
   );
 }
 
+function shortField(record: Record<string, unknown>, key: string): string | undefined {
+  const value = readString(record, key);
+  if (value === undefined) return undefined;
+  if (value.length > MAX_SHORT_FIELD) return truncate(value, MAX_SHORT_FIELD);
+  return value;
+}
+
 /** How many things a result was, when it was a list of them. */
 function countSummary(output: unknown): string | undefined {
-  if (!Array.isArray(output)) return undefined;
-  if (output.length === 0) return "Nothing found.";
-  return output.length === 1 ? "1 result." : `${output.length} results.`;
+  if (Array.isArray(output)) {
+    if (output.length === 0) return "Nothing found.";
+    return output.length === 1 ? "1 result." : `${output.length} results.`;
+  }
+  const record = asRecord(output);
+  const items = record?.items;
+  if (Array.isArray(items)) return countSummary(items);
+  return undefined;
+}
+
+function looksLikeContentBlocks(output: unknown): boolean {
+  if (!Array.isArray(output) || output.length === 0) return false;
+  return output.some((entry) => {
+    const record = asRecord(entry);
+    return record !== undefined && typeof record.type === "string";
+  });
 }
 
 /**
@@ -411,16 +576,47 @@ function countSummary(output: unknown): string | undefined {
 export function summarizeToolOutput(
   status: ToolActivityStatus,
   output: unknown,
+  toolName?: string,
 ): string | undefined {
-  const text = plainTextOfOutput(output);
+  if (toolName === "ask_user" && status !== "failed") return undefined;
+
+  const decoded = decodeOutput(output);
+
   if (status === "failed") {
+    const text = plainTextOfOutput(decoded);
     if (text === undefined) return "No reason given.";
     const firstLine = text.split("\n")[0] ?? text;
     return truncate(firstLine, MAX_FAILURE_DETAIL);
   }
   if (status !== "success") return undefined;
-  if (text !== undefined) return truncate(text, MAX_SUCCESS_DETAIL);
-  return countSummary(output);
+
+  if (!looksLikeContentBlocks(decoded)) {
+    const counted = countSummary(decoded);
+    if (counted !== undefined) return counted;
+  }
+
+  const record = asRecord(decoded);
+  if (record !== undefined && !("content" in record)) {
+    const field = shortField(record, "text") ?? shortField(record, "message");
+    if (field !== undefined) return field;
+    if (countSummary(decoded) === undefined) return undefined;
+  }
+
+  const text = plainTextOfOutput(decoded);
+  if (text === undefined) return countSummary(decoded);
+  const nested = decodeOutput(text);
+  if (typeof nested === "string") return truncate(nested, MAX_SUCCESS_DETAIL);
+  if (!looksLikeContentBlocks(nested)) {
+    const counted = countSummary(nested);
+    if (counted !== undefined) return counted;
+  }
+  const nestedRecord = asRecord(nested);
+  if (nestedRecord !== undefined) {
+    return (
+      shortField(nestedRecord, "text") ?? shortField(nestedRecord, "message")
+    );
+  }
+  return undefined;
 }
 
 function rowStatus(part: ToolTracePart): ToolActivityStatus {
@@ -436,12 +632,14 @@ export function toToolActivityRow(
   const status = rowStatus(part);
   const tense: Tense =
     status === "running" || status === "pending" ? "present" : "past";
+  const identity = resolveToolIdentity(part.name, part.input);
   return {
     key,
-    toolName: part.name,
-    provider: resolveToolIdentity(part.name, part.input).provider,
+    toolName: identity.toolName,
+    glyph: toolActivityGlyph(identity.words),
+    provider: identity.provider,
     phrase: describeToolCall(part.name, part.input, tense),
-    detail: summarizeToolOutput(status, part.output),
+    detail: summarizeToolOutput(status, part.output, identity.toolName),
     status,
   };
 }
diff --git a/packages/chat-ui/src/turn-activity.tsx b/packages/chat-ui/src/turn-activity.tsx
index c2fa57228..97d66560b 100644
--- a/packages/chat-ui/src/turn-activity.tsx
+++ b/packages/chat-ui/src/turn-activity.tsx
@@ -18,6 +18,7 @@ import { useEffect, useState } from "react";
 import {
   describeToolCall,
   resolveToolIdentity,
+  toolActivityGlyph,
   type ToolActivityRow,
 } from "./tool-activity";
 import { LiveToolActivity } from "./tool-activity-view";
@@ -388,10 +389,12 @@ export function toolActivityRows(
 ): readonly ToolActivityRow[] {
   return activity.toolCalls.map((call) => {
     const isRunning = call.status === "running";
+    const identity = resolveToolIdentity(call.name, call.input);
     const base = {
       key: call.callId,
-      toolName: call.name,
-      provider: resolveToolIdentity(call.name, call.input).provider,
+      toolName: identity.toolName,
+      glyph: toolActivityGlyph(identity.words),
+      provider: identity.provider,
       phrase: describeToolCall(
         call.name,
         call.input,

From 08ec6d3a2b72c3dac02d05962b4881763038a949 Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Tue, 25 Aug 2026 10:27:38 -0700
Subject: [PATCH 3/6] Update docs: tool-activity chips are sentences with
 action glyphs

---
 DESIGN.md | 95 +++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 65 insertions(+), 30 deletions(-)

diff --git a/DESIGN.md b/DESIGN.md
index 0dbb6d538..ef2bb6f89 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -221,38 +221,73 @@ screens. One action, one verb, everywhere that action appears.
 ## Tool Activity in the Conversation
 
 What an agent did between question and answer renders as sentences, never
-as the material it was made from. A tool call is described by what it
-accomplished — "Searched the web for 'pricing'", "Wrote a file —
-report.md", "Posted a message in Slack #general" — never by its
-identifier, its namespace, or a humanised spelling of either. A result is
-plain text: the prose the tool returned, or a count when it returned a
-list. Raw JSON never reaches a reader, expanded or not; the only
-exception is code the user actually asked for, which is prose, not
-machinery.
-
-Tense follows state: a call still running speaks in the present
-("Searching…"), a settled one in the past ("Searched…"). The same rows
-render mid-turn and in the persisted transcript, so nothing restyles
-itself the moment a turn ends.
+as the material it was made from. Tool activity is a **chip**, not a card,
+not a full-width AI-Elements collapsible with "Parameters" / "Result"
+headers, and not a JSON inspector. Live strip and timeline share this
+chip.
 
 Tool calls render as inline chips inside the agent's message body, stacked
-under the prose, one per call — never a collapsible, never a count.
-Consecutive calls do not fold into a summary line or a "3 steps" total: a
-count of implementation objects tells a reader nothing about what actually
-happened, and hides the one call among many that might matter (a public
-Slack post reads identically to three benign file reads once it's
-flattened to a number). Each chip is `width:max-content` — it hugs its own
-content rather than spanning the column, so a wall of calls reads as a
-stack of short tags, not a wall of prose.
-
-A chip's anatomy, left to right: a small provider tile (brand-colored,
-two-letter initials) so a reader can tell at a glance which system a call
-touched, then the sentence describing what happened, then a quiet status
-marker. Detail opens on demand, one click, on the individual chip that has
-something to show; a chip with nothing to disclose offers no control at
-all. A failure says so plainly, in words, on its own chip — it is the one
-state where colour appears; everything else in this strip is quiet
-chrome.
+under the prose, one per call. Consecutive chips stack; they never fold
+into "Used 3 tools" or a "3 steps" total — a count of implementation
+objects tells a reader nothing about what actually happened, and hides
+the one call among many that might matter. Each chip is
+`width: max-content` — it hugs its own content rather than spanning the
+column, so a wall of calls reads as a stack of short tags, not a wall of
+prose.
+
+**Phrase.** A sentence in tense, derived from the tool's *end name* —
+the segment after the last `:` in an Interchange qualified id, or after
+`__` in an MCP id — plus a few argument clauses (`for "…"`, `in #42`).
+Present while running or pending ("Searching memory"), past when done
+("Searched memory"). The same chips render mid-turn and in the persisted
+transcript, so nothing restyles itself the moment a turn ends. The
+qualified package path (`@scope/package/export`) never appears, even in
+expanded detail — never dump `@scope/package/export:tool` or title-case
+that path into a phrase.
+
+**Leading tile.** Known provider brands only — GitHub, GitLab, Linear,
+Notion, Postgres, Slack — get a brand-colored tile. Unknown leftovers
+(`memory`, `ad`, `ask-user`, `corbits`) are not brands. Local / first-party
+tools use an **action glyph** (search, list, ask, memory, agents, write,
+or generic lightning) on a quiet muted square — never a fake brand tile,
+never an em-dash, never a minus-in-a-dark-box.
+
+**Status glyph.** Check when done, a spinning CircleNotch while running
+or pending, WarningCircle when failed. Not a gray 6px dot. The sentence's
+tense already names the state; the glyph agrees. A failure also tints the
+phrase destructive.
+
+**Disclosure.** A caret exists only when there is human-readable detail.
+A chip with nothing to disclose offers no control at all. Expanded detail
+is quiet inset prose under that chip. Raw JSON, JSON strings, and
+model-facing instructions (e.g. ask_user's "do not repeat this in prose")
+never reach a reader — parse JSON into a count ("3 results.") or omit the
+disclosure. The only exception is code the user actually asked for, which
+is prose, not machinery.
+
+**Chrome.** Hit area ≥40px via an invisible `::before`. Radius
+`--radius`. Motion via `--duration-standard` / `--ease-out`. Scale-on-press
+~0.97 on the trigger. `prefers-reduced-motion` kills the spinner.
+
+Do:
+
+- End-name sentences with argument clauses; tense matches state.
+- Known-provider brand tiles; action glyphs on muted squares for local
+  tools.
+- Status Check / spinning CircleNotch / WarningCircle.
+- Quiet inset prose for detail; result counts when the payload is a list.
+
+Don't:
+
+- Dump `@scope/package/export:tool` or title-case it into a phrase.
+- Invent a brand from an unknown path segment.
+- Show a minus, dash, or empty tile as "the provider".
+- Show a gray status dot.
+- Render JSON, even when the tool returned a JSON string.
+- Copy Vercel AI Elements' full Parameters/Result collapsible — take the
+  status glyph and the quiet header, not the inspector.
+- Fold consecutive chips into "Used 3 tools".
+
 
 ## Message Alignment
 

From 4297916342bf375cabbb1670ca532ac9fe647425 Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Thu, 27 Aug 2026 15:37:45 -0700
Subject: [PATCH 4/6] Format tool-activity chip files

---
 DESIGN.md                             |  3 +--
 packages/chat-ui/src/styles.css       | 12 ++++++++----
 packages/chat-ui/src/tool-activity.ts | 21 +++++++++------------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/DESIGN.md b/DESIGN.md
index ef2bb6f89..bfef277f8 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -235,7 +235,7 @@ the one call among many that might matter. Each chip is
 column, so a wall of calls reads as a stack of short tags, not a wall of
 prose.
 
-**Phrase.** A sentence in tense, derived from the tool's *end name* —
+**Phrase.** A sentence in tense, derived from the tool's _end name_ —
 the segment after the last `:` in an Interchange qualified id, or after
 `__` in an MCP id — plus a few argument clauses (`for "…"`, `in #42`).
 Present while running or pending ("Searching memory"), past when done
@@ -288,7 +288,6 @@ Don't:
   status glyph and the quiet header, not the inspector.
 - Fold consecutive chips into "Used 3 tools".
 
-
 ## Message Alignment
 
 Own messages align right; everyone and everything else — other people,
diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index 0b34902d7..6e3d7dff5 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -2191,10 +2191,14 @@
   border-radius: var(--radius);
   padding: 0.35rem 0.75rem 0.35rem 0.4rem;
   transition:
-    transform var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
-    background-color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
-    border-color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
-    color var(--duration-standard, 180ms) var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1));
+    transform var(--duration-standard, 180ms)
+      var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    background-color var(--duration-standard, 180ms)
+      var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    border-color var(--duration-standard, 180ms)
+      var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1)),
+    color var(--duration-standard, 180ms)
+      var(--ease-out, cubic-bezier(0.2, 0.8, 0.3, 1));
 }
 
 .chat-tool-activity-trigger {
diff --git a/packages/chat-ui/src/tool-activity.ts b/packages/chat-ui/src/tool-activity.ts
index 908867f0b..87de58d8c 100644
--- a/packages/chat-ui/src/tool-activity.ts
+++ b/packages/chat-ui/src/tool-activity.ts
@@ -25,13 +25,7 @@ import type { Part, ToolTracePart } from "@corbits/chat/parts";
 export type ToolActivityStatus = "pending" | "running" | "success" | "failed";
 
 export type ToolActivityGlyph =
-  | "search"
-  | "list"
-  | "ask"
-  | "memory"
-  | "agents"
-  | "write"
-  | "generic";
+  "search" | "list" | "ask" | "memory" | "agents" | "write" | "generic";
 
 /** One tool call, ready to render: no identifiers, no JSON, no tense
  * mismatch with its own status. */
@@ -212,7 +206,9 @@ function knownBrandId(candidate: string): string | undefined {
   return undefined;
 }
 
-function providerFromLeftover(leftover: string | undefined): string | undefined {
+function providerFromLeftover(
+  leftover: string | undefined,
+): string | undefined {
   if (leftover === undefined || leftover === "") return undefined;
   const interchange = leftover.includes("/") || leftover.startsWith("@");
   if (interchange) {
@@ -295,9 +291,7 @@ export function resolveToolIdentity(
   };
 }
 
-export function toolActivityGlyph(
-  words: readonly string[],
-): ToolActivityGlyph {
+export function toolActivityGlyph(words: readonly string[]): ToolActivityGlyph {
   const has = (candidates: readonly string[]) =>
     words.some((word) => candidates.includes(word));
   if (has(["search", "find", "query", "grep", "glob"])) return "search";
@@ -541,7 +535,10 @@ export function plainTextOfOutput(output: unknown): string | undefined {
   );
 }
 
-function shortField(record: Record<string, unknown>, key: string): string | undefined {
+function shortField(
+  record: Record<string, unknown>,
+  key: string,
+): string | undefined {
   const value = readString(record, key);
   if (value === undefined) return undefined;
   if (value.length > MAX_SHORT_FIELD) return truncate(value, MAX_SHORT_FIELD);

From 2ff73119e1dc70f52f3d4c9accff3a26bb7fe392 Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Thu, 27 Aug 2026 16:18:05 -0700
Subject: [PATCH 5/6] Tense mid-name tool verbs and ellipsize long chips

pickVerb only looked at the first and last leftover words, so a name
like linear_list_recent_issues never conjugated and repeated Linear.
A verb-less fallback also dropped its query clause. Long chips could
not ellipsize because max-width:100% cycled against a shrink-wrapped
max-content row.
---
 packages/chat-ui/src/styles.css               | 15 ++++-
 packages/chat-ui/src/tool-activity.test.ts    | 47 ++++++++++++++++
 packages/chat-ui/src/tool-activity.ts         | 29 ++++++----
 .../chat-ui/test/tool-activity-view.test.tsx  | 55 +++++++++++++++++++
 4 files changed, 134 insertions(+), 12 deletions(-)

diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index 6e3d7dff5..3f15a2cbb 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -2155,6 +2155,10 @@
   align-items: flex-start;
   gap: 0.5rem;
   padding: 0.15rem 0;
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  max-width: 100%;
   font-size: 0.8125rem;
   color: var(--muted-foreground);
 }
@@ -2166,12 +2170,17 @@
 }
 
 /* The row is the outer wrapper — chip on top, its optional detail
-   underneath. `.chat-tool-activity-chip` is what's `width:max-content`. */
+   underneath. It takes the message column so a long chip can ellipsize
+   against a real width instead of a shrink-wrapped max-content cycle. */
 .chat-tool-activity-row {
   display: flex;
   flex-direction: column;
   align-items: flex-start;
   gap: 0.3rem;
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  max-width: 100%;
 }
 
 .chat-tool-activity-row[data-indented="true"] {
@@ -2183,7 +2192,9 @@
   flex-direction: row;
   align-items: center;
   gap: 0.5rem;
-  width: max-content;
+  box-sizing: border-box;
+  width: fit-content;
+  min-width: 0;
   max-width: 100%;
   flex-wrap: nowrap;
   border: 1px solid color-mix(in srgb, var(--foreground) 12%, transparent);
diff --git a/packages/chat-ui/src/tool-activity.test.ts b/packages/chat-ui/src/tool-activity.test.ts
index 5defb56c4..f499177d2 100644
--- a/packages/chat-ui/src/tool-activity.test.ts
+++ b/packages/chat-ui/src/tool-activity.test.ts
@@ -194,6 +194,36 @@ describe("describeToolCall", () => {
       ),
     ).toBe("Asked a question");
   });
+
+  test("a verb in the middle of the leftover name still tenses, without repeating Linear", () => {
+    const phrase = describeToolCall(
+      "@corbits/linear-tools/li:linear_list_recent_issues",
+      {},
+      "past",
+    );
+    expect(phrase).toBe("Listed recent issues in Linear");
+    expect(phrase).not.toBe("Linear list recent issues in Linear");
+    expect(
+      describeToolCall(
+        "@corbits/linear-tools/li:linear_list_recent_issues",
+        {},
+        "present",
+      ),
+    ).toBe("Listing recent issues in Linear");
+  });
+
+  test("a nameless-verb tool still tenses its query clause", () => {
+    expect(
+      describeToolCall("github_activity", { query: "bench pricing" }, "past"),
+    ).toBe('Ran github activity for "bench pricing"');
+    expect(
+      describeToolCall(
+        "github_activity",
+        { query: "bench pricing" },
+        "present",
+      ),
+    ).toBe('Running github activity for "bench pricing"');
+  });
 });
 
 describe("plainTextOfOutput", () => {
@@ -347,6 +377,23 @@ describe("toToolActivityRow", () => {
     expect(row.provider).toBeUndefined();
     expect(row.phrase).toBe("Frobnicate widget");
   });
+
+  test("an Interchange Linear list carries a Linear tile and a tensed sentence", () => {
+    const row = toToolActivityRow(
+      trace({
+        name: "@corbits/linear-tools/li:linear_list_recent_issues",
+        status: "success",
+      }),
+      "k",
+    );
+    expect(row.phrase).toBe("Listed recent issues in Linear");
+    expect(row.provider).toBe("linear");
+    expect(row.toolName).toBe("linear_list_recent_issues");
+    expect(providerTile(row.provider ?? "")).toEqual({
+      initials: "Li",
+      color: "#5e6ad2",
+    });
+  });
 });
 
 describe("providerTile", () => {
diff --git a/packages/chat-ui/src/tool-activity.ts b/packages/chat-ui/src/tool-activity.ts
index 87de58d8c..037d66300 100644
--- a/packages/chat-ui/src/tool-activity.ts
+++ b/packages/chat-ui/src/tool-activity.ts
@@ -58,7 +58,7 @@ type Tense = "past" | "present";
 
 type Conjugation = { readonly past: string; readonly present: string };
 
-/** The verbs tool names actually start (or end) with, in the two forms a
+/** The verbs tool names actually contain, in the two forms a
  * transcript needs. Irregulars are why this is a table and not a suffix rule. */
 const VERBS: Record<string, Conjugation> = {
   add: { past: "Added", present: "Adding" },
@@ -374,15 +374,14 @@ function pickVerb(words: readonly string[]): {
   verb: string | undefined;
   objectWords: readonly string[];
 } {
-  const first = words[0];
-  const last = words.length > 1 ? words[words.length - 1] : undefined;
-  if (first !== undefined && VERBS[first] !== undefined) {
-    return { verb: first, objectWords: words.slice(1) };
+  const index = words.findIndex((word) => VERBS[word] !== undefined);
+  if (index === -1) {
+    return { verb: undefined, objectWords: words };
   }
-  if (last !== undefined && VERBS[last] !== undefined) {
-    return { verb: last, objectWords: words.slice(0, -1) };
-  }
-  return { verb: undefined, objectWords: words };
+  return {
+    verb: words[index],
+    objectWords: [...words.slice(0, index), ...words.slice(index + 1)],
+  };
 }
 
 function isPluralWord(word: string): boolean {
@@ -465,6 +464,10 @@ export function describeToolCall(
   const identity = resolveToolIdentity(name, input);
   const clause = argumentClause(input);
   const picked = pickVerb(identity.words);
+  const objectWords =
+    identity.provider === undefined
+      ? picked.objectWords
+      : picked.objectWords.filter((word) => word !== identity.provider);
   const providerSuffix =
     identity.provider === undefined
       ? ""
@@ -477,7 +480,7 @@ export function describeToolCall(
     }
     const conjugation = VERBS[picked.verb];
     if (conjugation !== undefined) {
-      const object = objectPhrase(picked.objectWords, picked.verb);
+      const object = objectPhrase(objectWords, picked.verb);
       const head =
         object === undefined
           ? conjugation[tense]
@@ -488,6 +491,12 @@ export function describeToolCall(
   }
 
   const fallback = identity.words.join(" ");
+  const clauseSuffix = buildClauseSuffix(clause, providerSuffix !== "");
+  if (clause !== undefined) {
+    const head = tense === "past" ? "Ran" : "Running";
+    const body = fallback === "" ? "a step" : fallback;
+    return `${head} ${body}${providerSuffix}${clauseSuffix}`;
+  }
   const sentence = fallback === "" ? "Ran a step" : titleCase(fallback);
   return `${sentence}${providerSuffix}`;
 }
diff --git a/packages/chat-ui/test/tool-activity-view.test.tsx b/packages/chat-ui/test/tool-activity-view.test.tsx
index 318a8e591..feee09afd 100644
--- a/packages/chat-ui/test/tool-activity-view.test.tsx
+++ b/packages/chat-ui/test/tool-activity-view.test.tsx
@@ -2,6 +2,9 @@
 // on the text a reader sees. The standing rule under test is that no
 // argument bag or tool result ever reaches the DOM as JSON, in any state.
 import { beforeEach, describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 
@@ -178,4 +181,56 @@ describe("ToolActivityGroup", () => {
     expect(el.innerHTML).not.toContain("—");
     expect(el.querySelector(".chat-tool-activity-tile svg")).not.toBeNull();
   });
+
+  test("a Linear list chip uses the Linear tile and a tensed sentence, never the tautology", () => {
+    const el = mount([
+      trace({
+        name: "@corbits/linear-tools/li:linear_list_recent_issues",
+      }),
+    ]);
+    expect(el.textContent).toContain("Listed recent issues in Linear");
+    expect(el.textContent).not.toContain("Linear list recent issues");
+    expect(el.querySelector(".chat-tool-activity-tile")?.textContent).toBe(
+      "Li",
+    );
+  });
+});
+
+const css = readFileSync(
+  join(dirname(fileURLToPath(import.meta.url)), "../src/styles.css"),
+  "utf8",
+);
+
+function ruleBody(selector: string): string {
+  const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`(?:^|\\n)\\s*${escaped}\\s*\\{([^}]+)\\}`).exec(
+    css,
+  );
+  return match?.[1] ?? "";
+}
+
+describe("tool-activity chip layout", () => {
+  test("a long chip ellipsizes against the message column, not a shrink-wrapped cycle", () => {
+    const stack = ruleBody(".chat-tool-activity");
+    expect(stack).toMatch(/width:\s*100%/);
+    expect(stack).toMatch(/min-width:\s*0/);
+    expect(stack).toMatch(/max-width:\s*100%/);
+
+    const row = ruleBody(".chat-tool-activity-row");
+    expect(row).toMatch(/width:\s*100%/);
+    expect(row).toMatch(/min-width:\s*0/);
+    expect(row).toMatch(/max-width:\s*100%/);
+
+    const chip = ruleBody(".chat-tool-activity-chip");
+    expect(chip).toMatch(/width:\s*fit-content/);
+    expect(chip).toMatch(/min-width:\s*0/);
+    expect(chip).toMatch(/max-width:\s*100%/);
+    expect(chip).not.toMatch(/width:\s*max-content/);
+
+    const phrase = ruleBody(".chat-tool-activity-phrase");
+    expect(phrase).toMatch(/overflow:\s*hidden/);
+    expect(phrase).toMatch(/text-overflow:\s*ellipsis/);
+    expect(phrase).toMatch(/white-space:\s*nowrap/);
+    expect(phrase).toMatch(/min-width:\s*0/);
+  });
 });

From 1e0183f55b247753955cdaddbd3f7ac1d3d09258 Mon Sep 17 00:00:00 2001
From: Sawyer Cutler <sawyer@dirtroad.dev>
Date: Thu, 27 Aug 2026 16:23:46 -0700
Subject: [PATCH 6/6] Name failed tool chips and drop the live strip status
 role

The warning icon is aria-hidden, so a failed GitHub chip still read as a success. A visually-hidden Failed word puts failure in the accessible name. The 1Hz elapsed timer sat inside role=status, which is atomic, so the whole strip re-announced every second.
---
 packages/chat-ui/src/strings.ts               |   1 +
 packages/chat-ui/src/styles.css               |  12 +++
 packages/chat-ui/src/tool-activity-view.tsx   |  17 ++-
 .../chat-ui/test/tool-activity-view.test.tsx  | 102 +++++++++++++++++-
 4 files changed, 128 insertions(+), 4 deletions(-)

diff --git a/packages/chat-ui/src/strings.ts b/packages/chat-ui/src/strings.ts
index f6e6760ce..8e33b24b8 100644
--- a/packages/chat-ui/src/strings.ts
+++ b/packages/chat-ui/src/strings.ts
@@ -307,6 +307,7 @@ export const CHAT_STRINGS = {
   },
   turnActivityThinking: "Thinking…",
   turnActivityRetry: (attempt: number) => `Retrying (attempt ${attempt})…`,
+  toolActivityFailed: "Failed",
   replyTimedOutNotice: "No reply arrived — the agent may be unavailable.",
   resumeFailedNotice: (refId: string) =>
     `Couldn't resume the running reply — try again. (ref ${refId})`,
diff --git a/packages/chat-ui/src/styles.css b/packages/chat-ui/src/styles.css
index 3f15a2cbb..83a84e24b 100644
--- a/packages/chat-ui/src/styles.css
+++ b/packages/chat-ui/src/styles.css
@@ -2342,6 +2342,18 @@
   opacity: 0.82;
 }
 
+.chat-tool-activity-status-word {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
 .chat-tool-activity-meta {
   flex: none;
   font-variant-numeric: tabular-nums;
diff --git a/packages/chat-ui/src/tool-activity-view.tsx b/packages/chat-ui/src/tool-activity-view.tsx
index 3e55af253..e368aedee 100644
--- a/packages/chat-ui/src/tool-activity-view.tsx
+++ b/packages/chat-ui/src/tool-activity-view.tsx
@@ -52,6 +52,12 @@ function StatusMarker({ status }: { readonly status: ToolActivityStatus }) {
   );
 }
 
+function chipAccessibleName(row: ToolActivityRow): string {
+  return row.status === "failed"
+    ? `${CHAT_STRINGS.toolActivityFailed}. ${row.phrase}`
+    : row.phrase;
+}
+
 function ActionGlyph({ glyph }: { readonly glyph: ToolActivityGlyph }) {
   let icon: ReactNode;
   switch (glyph) {
@@ -114,9 +120,16 @@ function ChipBody({
   return (
     <>
       <LeadingMark row={row} />
+      {row.status === "failed" ? (
+        <span className="chat-tool-activity-status-word">
+          {CHAT_STRINGS.toolActivityFailed}.{" "}
+        </span>
+      ) : null}
       <span className="chat-tool-activity-phrase">{row.phrase}</span>
       {row.meta === undefined ? null : (
-        <span className="chat-tool-activity-meta">{row.meta}</span>
+        <span className="chat-tool-activity-meta" aria-hidden="true">
+          {row.meta}
+        </span>
       )}
       <StatusMarker status={row.status} />
       {row.detail === undefined ? null : (
@@ -164,6 +177,7 @@ function ToolActivityLine({
         type="button"
         className="chat-tool-activity-chip chat-tool-activity-trigger"
         aria-expanded={open}
+        aria-label={chipAccessibleName(row)}
         title={row.toolName}
         onClick={() => setOpen((value) => !value)}
       >
@@ -213,7 +227,6 @@ export function LiveToolActivity({
     <div
       className="chat-tool-activity chat-tool-activity-live"
       data-slot="tool-activity"
-      role="status"
     >
       {rows.map((row) => (
         <ToolActivityLine key={row.key} row={row} indented={false} />
diff --git a/packages/chat-ui/test/tool-activity-view.test.tsx b/packages/chat-ui/test/tool-activity-view.test.tsx
index feee09afd..2466082e1 100644
--- a/packages/chat-ui/test/tool-activity-view.test.tsx
+++ b/packages/chat-ui/test/tool-activity-view.test.tsx
@@ -9,8 +9,8 @@ import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 
 import type { ToolTracePart } from "@corbits/chat/parts";
-import { toToolActivityRow } from "../src/tool-activity";
-import { ToolActivityGroup } from "../src/tool-activity-view";
+import { toToolActivityRow, type ToolActivityRow } from "../src/tool-activity";
+import { LiveToolActivity, ToolActivityGroup } from "../src/tool-activity-view";
 
 function trace(part: Partial<ToolTracePart>): ToolTracePart {
   return {
@@ -39,6 +39,39 @@ function click(element: Element | null) {
   });
 }
 
+/** Name a screen reader would get: aria-label, else text excluding aria-hidden. */
+function accessibleName(element: Element | null): string {
+  if (element === null) return "";
+  const labelled = element.getAttribute("aria-label");
+  if (labelled !== null && labelled.trim() !== "") return labelled.trim();
+  const walk = (node: Node): string => {
+    if (node.nodeType === Node.TEXT_NODE) return node.textContent ?? "";
+    if (!(node instanceof Element)) return "";
+    if (node.getAttribute("aria-hidden") === "true") return "";
+    return Array.from(node.childNodes).map(walk).join("");
+  };
+  return walk(element).replace(/\s+/g, " ").trim();
+}
+
+function mountLive(
+  rows: readonly ToolActivityRow[],
+  extra?: { readonly thinking?: boolean; readonly retryCount?: number },
+): HTMLDivElement {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const root: Root = createRoot(container);
+  act(() => {
+    root.render(
+      <LiveToolActivity
+        rows={rows}
+        thinking={extra?.thinking ?? false}
+        retryCount={extra?.retryCount ?? 0}
+      />,
+    );
+  });
+  return container;
+}
+
 beforeEach(() => {
   document.body.innerHTML = "";
 });
@@ -145,6 +178,40 @@ describe("ToolActivityGroup", () => {
     expect(el.textContent).toContain("Repository not found");
   });
 
+  test("a failed chip's accessible name includes failure", () => {
+    const el = mount([
+      trace({
+        name: "github__get_issue",
+        input: { repo: "corbitsdev/workbench" },
+        status: "error",
+        output: [{ type: "text", text: "Repository not found" }],
+      }),
+    ]);
+    const chip = el.querySelector(".chat-tool-activity-chip");
+    const name = accessibleName(chip);
+    expect(name).toMatch(/fail|couldn't/i);
+    expect(name).toContain("Retrieved an issue in GitHub");
+    expect(el.querySelector('[data-status="failed"]')).not.toBeNull();
+    expect(
+      el
+        .querySelector(".chat-tool-activity-marker")
+        ?.getAttribute("aria-hidden"),
+    ).toBe("true");
+  });
+
+  test("a disclosure chip has an accessible name", () => {
+    const el = mount([
+      trace({
+        name: "web_search",
+        input: { query: "bench pricing" },
+        output: [{ type: "text", text: "Eight matching pages." }],
+      }),
+    ]);
+    const trigger = el.querySelector(".chat-tool-activity-trigger");
+    expect(trigger).not.toBeNull();
+    expect(accessibleName(trigger).length).toBeGreaterThan(0);
+  });
+
   test("a known-provider chip uses brand initials, not a dash", () => {
     const el = mount([
       trace({ name: "slack__post_message", input: { channel: "general" } }),
@@ -196,6 +263,37 @@ describe("ToolActivityGroup", () => {
   });
 });
 
+describe("LiveToolActivity", () => {
+  test("elapsed ticks are not inside an atomic live region", () => {
+    const el = mountLive([
+      {
+        key: "k0",
+        toolName: "web_search",
+        glyph: "search",
+        provider: undefined,
+        phrase: 'Searching the web for "x"',
+        detail: undefined,
+        status: "running",
+        meta: "3s",
+      },
+    ]);
+    const live = el.querySelector(".chat-tool-activity-live");
+    const meta = el.querySelector(".chat-tool-activity-meta");
+    expect(live).not.toBeNull();
+    expect(meta?.textContent).toBe("3s");
+    expect(meta?.closest('[role="status"]')).toBeNull();
+    expect(live?.getAttribute("role")).not.toBe("status");
+  });
+
+  test("the transcript group stays non-live", () => {
+    const el = mount([trace({ name: "web_search", input: { query: "x" } })]);
+    const group = el.querySelector(".chat-tool-activity");
+    expect(group?.classList.contains("chat-tool-activity-live")).toBe(false);
+    expect(group?.getAttribute("role")).toBeNull();
+    expect(group?.getAttribute("aria-live")).toBeNull();
+  });
+});
+
 const css = readFileSync(
   join(dirname(fileURLToPath(import.meta.url)), "../src/styles.css"),
   "utf8",