diff --git a/docs/docs/protocol/streaming.md b/docs/docs/protocol/streaming.md
index 67ed392..7638c1b 100644
--- a/docs/docs/protocol/streaming.md
+++ b/docs/docs/protocol/streaming.md
@@ -119,3 +119,50 @@ Treat all three (`stream`, `stream_end`, `message`) as the same kind of update 
 ```
 
 This means the same client code that handles `parts[]` for non-streaming messages works for streams too — no special-casing.
+
+## Thinking events
+
+While the agent works with tools between text outputs, the chat would otherwise sit silent. Two mechanisms cover that window:
+
+1. **Early `typing`.** The runtime emits `typing` at turn start and again before each tool batch — every client (including older SDKs) shows its thinking indicator through the whole generation, not just the final response.
+2. **`thinking` events** — a live, Rovo-style timeline of what the agent is doing, rendered by capable clients as named, expandable steps above the incoming answer.
+
+```
+thinking  { clientId, turnId, step: { id, label, detail?, state }, ts }   // step update
+thinking  { clientId, turnId, done: true, ts }                            // turn complete
+```
+
+- `turnId` groups every event of one agent turn (minted per run).
+- `step.state` is `'active'` before the work starts and `'done'` (same `step.id`, updated in place) when it finishes.
+- `step.label` is a humanized, visitor-safe name (e.g. `"Search knowledge base"`); `step.detail` is optional reasoning prose (markdown). **Never put raw tool params or prompts here** — unlike `debug`, this event is relayed to regular visitors, not admin-gated.
+- The terminal `done: true` event closes the timeline; the widget collapses the block into a re-expandable summary row.
+
+### Capability gating
+
+The SDK (≥ v0.15.0) advertises `'thinking'` in its handshake `capabilities`. The hub forwards the list on every message, and the runtime emits `thinking` events **only** when the triggering message carried the capability. Telegram clients and older SDKs receive nothing new.
+
+### Compatibility matrix
+
+| SDK | Hub | Runtime | Behavior |
+|-----|-----|---------|----------|
+| old | any | new | indicator appears at turn start (early `typing`) — strict improvement |
+| new | old | new | shimmer status only; the old hub's whitelist silently drops `thinking` |
+| new | new | old | behavior unchanged from before |
+| new | new | new | full thinking timeline |
+
+Every partial deployment state is safe — the event is strictly additive. Recommended rollout order: hub → runtime → SDK.
+
+### Emitting from an agent
+
+```ts
+const turnId = crypto.randomUUID()
+const step = { id: crypto.randomUUID(), label: 'Search knowledge base' }
+
+bridle.sendThinking(msg.from, turnId, { ...step, state: 'active' })
+// ... do the work ...
+bridle.sendThinking(msg.from, turnId, { ...step, state: 'done' })
+// ... when the whole turn is finished:
+bridle.sendThinking(msg.from, turnId)          // no step ⇒ done: true
+```
+
+Gate on `msg.capabilities?.includes('thinking')` before emitting.
diff --git a/nestjs/domain/bridle.types.ts b/nestjs/domain/bridle.types.ts
index 4a58818..13d0af3 100644
--- a/nestjs/domain/bridle.types.ts
+++ b/nestjs/domain/bridle.types.ts
@@ -135,6 +135,7 @@ export interface IBridleOutgoingEvent {
     | 'stream'
     | 'stream_end'
     | 'typing'
+    | 'thinking'
     | 'ping'
     | 'agent_status'
   clientId?: string
@@ -148,6 +149,42 @@ export interface IBridleOutgoingEvent {
   connected?: boolean
 }
 
+// ── Thinking (live reasoning steps) ──────────────────────────
+
+/** One published unit of agent work inside a thinking timeline. */
+export interface IBridleThinkingStep {
+  /** Stable per-step id — the `done` update reuses the `active` event's id. */
+  id: string
+  /** Human-readable, visitor-safe step name (e.g. "Search knowledge base"). */
+  label: string
+  /**
+   * Optional visitor-safe reasoning prose (markdown). Never raw tool
+   * params or prompts — this event is NOT admin-gated (unlike `debug`).
+   */
+  detail?: string
+  state: 'active' | 'done'
+}
+
+/**
+ * Agent → Hub → Browser: live "what the agent is doing" feed, rendered by
+ * thinking-capable clients as a collapsible timeline while the answer is
+ * being prepared. Two shapes share the event: a step update (`step` set)
+ * and turn completion (`done: true`, no step) which closes the open block.
+ * The hub relays it to the addressed client like `stream`. Agents emit it
+ * only toward clients whose handshake `capabilities` include `'thinking'`.
+ */
+export interface IBridleThinkingEvent {
+  type: 'thinking'
+  clientId: string
+  /** Groups every step of one agent turn (minted per loop run). */
+  turnId: string
+  /** Present on step updates; absent on the terminal `done` event. */
+  step?: IBridleThinkingStep
+  /** True on the terminal event of a turn. */
+  done?: boolean
+  ts: number
+}
+
 // ── Admin: debug snapshots ───────────────────────────────────
 
 /**
diff --git a/nestjs/handlers/bridleAgentWs.handler.ts b/nestjs/handlers/bridleAgentWs.handler.ts
index b64aeae..6218523 100644
--- a/nestjs/handlers/bridleAgentWs.handler.ts
+++ b/nestjs/handlers/bridleAgentWs.handler.ts
@@ -15,6 +15,7 @@ import {
   type IBridleOutgoingEvent,
   type IBridleDebugEvent,
   type IBridleSyncResponse,
+  type IBridleThinkingEvent,
 } from '../domain'
 
 /**
@@ -136,6 +137,17 @@ export class BridleAgentWsHandler implements OnGatewayConnection, OnGatewayDisco
     }
   }
 
+  @SubscribeMessage('thinking')
+  handleThinking(
+    @ConnectedSocket() client: Socket,
+    @MessageBody() data: IBridleThinkingEvent,
+  ) {
+    const agentId = client.data?.agentId as string
+    if (data?.clientId && data?.turnId && agentId) {
+      this.hub.handleAgentEvent(agentId, { ...data, type: 'thinking' })
+    }
+  }
+
   @SubscribeMessage('debug')
   handleDebug(
     @ConnectedSocket() client: Socket,
diff --git a/runtime/bridle.repository.ts b/runtime/bridle.repository.ts
index 5a5f52b..a576b10 100644
--- a/runtime/bridle.repository.ts
+++ b/runtime/bridle.repository.ts
@@ -159,6 +159,20 @@ export interface IBridleMessageData {
   capabilities?: string[]
 }
 
+// ── Thinking (live reasoning steps) ──────────────────────────
+
+/**
+ * One published unit of agent work inside a thinking timeline. Pass to
+ * `sendThinking()` — `active` before the work starts, `done` (same `id`)
+ * when it finishes. Labels/detail must be visitor-safe.
+ */
+export interface IBridleThinkingStep {
+  id: string
+  label: string
+  detail?: string
+  state: 'active' | 'done'
+}
+
 // ── Admin protocol — debug + sync ─────────────────────────────
 
 /**
@@ -269,6 +283,35 @@ export class BridleRepository implements IChannelGateway {
     this.syncHandler = handler
   }
 
+  /**
+   * Bare typing signal so the browser lights its thinking indicator before
+   * the first LLM byte (streamSend fires its own once streaming starts).
+   * No-op if the socket is offline.
+   */
+  sendTyping(to: string): void {
+    if (!this.socket?.connected) return
+    this.socket.emit('typing', { clientId: to, ts: Date.now() })
+  }
+
+  /**
+   * Publish one thinking-timeline update: a step (`state: 'active' | 'done'`)
+   * or, with `step` omitted, the terminal turn-completion event. Emit only
+   * toward clients whose message `capabilities` include `'thinking'` —
+   * others can't render it. Payload must stay visitor-safe: humanized step
+   * labels and reasoning prose only, never raw tool params or prompts.
+   * No-op if the socket is offline.
+   */
+  sendThinking(to: string, turnId: string, step?: IBridleThinkingStep): void {
+    if (!this.socket?.connected) return
+    this.socket.emit('thinking', {
+      type: 'thinking',
+      clientId: to,
+      turnId,
+      ...(step ? { step } : { done: true }),
+      ts: Date.now(),
+    })
+  }
+
   /**
    * Push an LLM round-trip snapshot to the hub. Hub fans it out to admin
    * clients only. No-op if the socket is offline.
diff --git a/sdk/package.json b/sdk/package.json
index f4d7458..b601f5f 100644
--- a/sdk/package.json
+++ b/sdk/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@cleanslice/bridle",
-  "version": "0.14.0",
-  "description": "Embeddable web chat for Bridle — drop-in <script> or programmatic init.",
+  "version": "0.15.0",
+  "description": "Embeddable web chat for Bridle \u2014 drop-in <script> or programmatic init.",
   "type": "module",
   "main": "./dist/bridle.mjs",
   "module": "./dist/bridle.mjs",
diff --git a/sdk/src/BridleChat.ce.vue b/sdk/src/BridleChat.ce.vue
index 8f36014..9462840 100644
--- a/sdk/src/BridleChat.ce.vue
+++ b/sdk/src/BridleChat.ce.vue
@@ -7,8 +7,11 @@ import type {
   BridlePart,
   BridleUiValue,
   IBridleMessage,
+  IBridleThinkingEvent,
+  IBridleThinkingStep,
   IBridleUiPart,
   IBridleUiSubmitPart,
+  IThinkingBlock,
 } from './types'
 
 interface IBridleAttachment {
@@ -169,6 +172,168 @@ const emit = defineEmits<{
 const messages = ref<IBridleMessage[]>([])
 const isConnected = ref(false)
 const isTyping = ref(false)
+
+// ── Thinking timeline (live reasoning steps) ─────────────────────────
+// One block per agent turn, opened by the first `thinking` event and
+// frozen by the terminal `done` event (or the stale watchdog below).
+// Session-only view state — nothing here is persisted or replayed.
+const thinkingBlocks = ref<IThinkingBlock[]>([])
+// Turns terminally closed (done event / watchdog / socket close) —
+// straggler steps for these must not resurrect a segment.
+const closedTurns = new Set<string>()
+// segment key → collapsed override. Unset means the default: open while
+// thinking, collapsed once done (auto-collapse on completion).
+const collapsedBlocks = ref<Record<string, boolean>>({})
+// stepId → detail expanded. Steps arrive collapsed.
+const expandedSteps = ref<Record<string, boolean>>({})
+
+// A turn may span several segments (blocks) — turnId + seg identifies one.
+function blockKey(b: IThinkingBlock): string {
+  return `${b.turnId}#${b.seg}`
+}
+
+const hasOpenThinking = computed(() =>
+  thinkingBlocks.value.some((b) => b.status === 'thinking'),
+)
+
+// Messages and thinking blocks interleaved by timestamp — a frozen block
+// stays anchored above the answer it produced, Rovo-style.
+interface IChatFlowItem {
+  message?: IBridleMessage
+  block?: IThinkingBlock
+  ts: number
+}
+const chatItems = computed<IChatFlowItem[]>(() => {
+  const items: IChatFlowItem[] = messages.value.map((m) => ({ message: m, ts: m.ts }))
+  for (const b of thinkingBlocks.value) items.push({ block: b, ts: b.ts })
+  return items.sort((a, b) => a.ts - b.ts)
+})
+
+// Watchdog for the thinking UI: a cancelled runtime turn breaks its loop
+// without ever emitting stream_end/message or the terminal thinking event,
+// so without a timeout the shimmer would animate forever. Every
+// typing/thinking/stream event re-arms it while anything is still open.
+const THINKING_STALE_MS = 75_000
+let thinkingStaleTimer: ReturnType<typeof setTimeout> | null = null
+
+function setTyping(on: boolean): void {
+  isTyping.value = on
+  if (thinkingStaleTimer) {
+    clearTimeout(thinkingStaleTimer)
+    thinkingStaleTimer = null
+  }
+  if (on || hasOpenThinking.value) {
+    thinkingStaleTimer = setTimeout(() => {
+      thinkingStaleTimer = null
+      isTyping.value = false
+      closeAllTurns()
+    }, THINKING_STALE_MS)
+  }
+}
+
+const thinkingLabel = computed(() => `${props.title} is thinking…`)
+
+function isBlockCollapsed(b: IThinkingBlock): boolean {
+  return collapsedBlocks.value[blockKey(b)] ?? b.status === 'done'
+}
+
+function toggleBlock(b: IThinkingBlock): void {
+  collapsedBlocks.value[blockKey(b)] = !isBlockCollapsed(b)
+}
+
+function toggleStep(s: IBridleThinkingStep): void {
+  expandedSteps.value[s.id] = !expandedSteps.value[s.id]
+}
+
+function freezeThinkingBlock(b: IThinkingBlock): void {
+  b.status = 'done'
+  b.steps = b.steps.map((s) => ({ ...s, state: 'done' as const }))
+}
+
+/**
+ * Seal (collapse) every open segment. The turns stay open — later steps of
+ * the same turn open a fresh segment below the newest message.
+ */
+function freezeOpenThinking(): void {
+  for (const b of thinkingBlocks.value) {
+    if (b.status === 'thinking') freezeThinkingBlock(b)
+  }
+}
+
+/** Terminal paths (watchdog, socket close): seal segments AND close their
+ * turns so straggler steps can't resurrect a zombie segment. */
+function closeAllTurns(): void {
+  for (const b of thinkingBlocks.value) closedTurns.add(b.turnId)
+  freezeOpenThinking()
+}
+
+/**
+ * Assistant content landing below the open segment seals it — the next
+ * step opens a fresh segment under this message (the turn stays open).
+ */
+function sealThinkingBeforeNewBubble(m: IBridleMessage): void {
+  if (m.role !== 'assistant') return
+  if (!m.text || !m.text.trim()) return
+  if (messages.value.some((x) => x.id === m.id)) return // update, not new
+  freezeOpenThinking()
+}
+
+function clearThinking(): void {
+  thinkingBlocks.value = []
+  closedTurns.clear()
+  collapsedBlocks.value = {}
+  expandedSteps.value = {}
+}
+
+function onThinkingEvent(e: IBridleThinkingEvent): void {
+  if (!e?.turnId) return
+  const turnBlocks = thinkingBlocks.value.filter((x) => x.turnId === e.turnId)
+  if (e.done || !e.step) {
+    // Terminal event — freeze every segment and refuse stragglers.
+    for (const b of turnBlocks) freezeThinkingBlock(b)
+    closedTurns.add(e.turnId)
+    return
+  }
+  if (closedTurns.has(e.turnId)) return // straggler after terminal
+  // `done` updates land in whichever segment holds the step id — the
+  // segment may have sealed while the tool was still running.
+  const owner = turnBlocks.find((b) => b.steps.some((s) => s.id === e.step!.id))
+  if (owner) {
+    owner.steps = owner.steps.map((s) => (s.id === e.step!.id ? e.step! : s))
+    setTyping(true)
+    return
+  }
+  // New step: continue the trailing open segment, or open a fresh one
+  // below the newest message (segments seal when content lands).
+  let block = turnBlocks[turnBlocks.length - 1]
+  if (!block || block.status === 'done') {
+    // Linear conversation: a new turn's first step closes other turns.
+    for (const b of thinkingBlocks.value) {
+      if (b.turnId !== e.turnId && b.status === 'thinking') {
+        freezeThinkingBlock(b)
+        closedTurns.add(b.turnId)
+      }
+    }
+    // Anchor after every message already on screen — wire timestamps come
+    // from the agent's clock and could otherwise sort above the user's
+    // message on skewed clocks.
+    const lastTs = messages.value.length
+      ? messages.value[messages.value.length - 1].ts
+      : 0
+    block = {
+      turnId: e.turnId,
+      seg: turnBlocks.length,
+      steps: [],
+      status: 'thinking',
+      ts: Math.max(e.ts ?? Date.now(), lastTs + 1),
+    }
+    thinkingBlocks.value.push(block)
+  }
+  block.steps.push(e.step)
+  // Steps mean the agent is actively working — keep the status shimmer on
+  // through tool execution and re-arm the stale watchdog.
+  setTyping(true)
+}
 const connectionError = ref<BridleAuthError | Error | null>(null)
 const isOpen = ref(props.mode === 'inline' || coerceBool(props.defaultOpen))
 const draft = ref('')
@@ -306,6 +471,10 @@ async function connect(): Promise<void> {
   client.on('close', () => {
     if (gen !== connectGen) return
     isConnected.value = false
+    // Connection gone — nothing can finish this turn, stop the shimmer
+    // and settle any open timeline into its frozen state.
+    closeAllTurns()
+    setTyping(false)
   })
   client.on('error', (err) => {
     if (gen !== connectGen) return
@@ -328,17 +497,23 @@ async function connect(): Promise<void> {
   })
   client.on('typing', () => {
     if (gen !== connectGen) return
-    isTyping.value = true
+    setTyping(true)
+  })
+  client.on('thinking', (e) => {
+    if (gen !== connectGen) return
+    onThinkingEvent(e)
   })
   client.on('message', (m) => {
     if (gen !== connectGen) return
-    isTyping.value = false
+    setTyping(false)
+    sealThinkingBeforeNewBubble(m)
     upsert(m)
     emit('message', m)
   })
   client.on('stream', (m) => {
     if (gen !== connectGen) return
-    isTyping.value = false
+    setTyping(false)
+    sealThinkingBeforeNewBubble(m)
     upsert(m)
   })
   client.on('stream_end', (m) => {
@@ -418,7 +593,7 @@ function send(): void {
     parts,
     ts: Date.now(),
   })
-  isTyping.value = true
+  setTyping(true)
   client.send(text, parts)
   draft.value = ''
   attachments.value = []
@@ -829,7 +1004,7 @@ function maybeShowGreeting(): void {
   }
 
   greetingShown.value = true
-  isTyping.value = true
+  setTyping(true)
 
   const raw =
     typeof props.greetingDelay === 'string'
@@ -839,7 +1014,7 @@ function maybeShowGreeting(): void {
 
   greetingTimer = setTimeout(() => {
     greetingTimer = null
-    isTyping.value = false
+    setTyping(false)
     // User snuck a message in during the delay — drop the greeting so we
     // don't shove it above their first turn.
     if (messages.value.length > 0) return
@@ -904,8 +1079,9 @@ async function startNewChat(): Promise<void> {
   }
   cancelGreetingTimer()
   messages.value = []
+  clearThinking()
   greetingShown.value = false
-  isTyping.value = false
+  setTyping(false)
   connectionError.value = null
   // Suppress the next transcript replay too — belt-and-braces in case the
   // archive endpoint was a no-op (older hub without the override) and the
@@ -950,10 +1126,15 @@ function onKeydown(e: KeyboardEvent): void {
 }
 
 watch(
-  [messages, isTyping],
+  [messages, isTyping, thinkingBlocks],
   async () => {
+    // Capture BEFORE the DOM grows: follow only a reader who was already at
+    // the bottom — never yank back someone who scrolled up to re-read.
+    const el = scrollEl.value
+    const nearBottom =
+      !el || el.scrollHeight - el.scrollTop - el.clientHeight < 80
     await nextTick()
-    if (scrollEl.value) {
+    if (nearBottom && scrollEl.value) {
       scrollEl.value.scrollTop = scrollEl.value.scrollHeight
     }
   },
@@ -967,6 +1148,7 @@ watch(
   () => {
     if (!props.apiUrl || !props.agentId) return
     messages.value = []
+    clearThinking()
     cancelGreetingTimer()
     greetingShown.value = false
     void connect()
@@ -1023,6 +1205,7 @@ onBeforeUnmount(() => {
   unbindAutoColorMode()
   cancelGreetingTimer()
   cancelPopupTimer()
+  setTyping(false)
   if (typeof document !== 'undefined') {
     document.removeEventListener('click', onDocClick)
     document.removeEventListener('keydown', onDocKeydown)
@@ -1228,9 +1411,12 @@ defineExpose({
           </template>
           <template v-else>Start a conversation</template>
         </div>
+        <template
+          v-for="{ message: m, block: b } in chatItems"
+          :key="m ? m.id : (b ? blockKey(b) : '')"
+        >
         <div
-          v-for="m in messages"
-          :key="m.id"
+          v-if="m"
           :class="['bridle__msg', `bridle__msg--${m.role}`]"
         >
           <div
@@ -1411,8 +1597,77 @@ defineExpose({
             <span v-if="m.text && uiSubmitParts(m).length === 0" class="bridle__msg-text">{{ m.text }}</span>
           </div>
         </div>
-        <div v-if="isTyping" class="bridle__typing" aria-label="Agent is typing">
-          <span /><span /><span />
+        <div
+          v-else-if="b"
+          class="bridle__thinking"
+          :role="b.status === 'thinking' ? 'status' : undefined"
+          :aria-label="b.status === 'thinking' ? thinkingLabel : undefined"
+        >
+          <div class="bridle__thinking-header">
+            <span
+              class="bridle__thinking-status"
+              :class="{ 'bridle__thinking-status--done': b.status === 'done' }"
+            >{{ b.status === 'thinking' ? thinkingLabel : 'Thought for a moment' }}</span>
+            <button
+              v-if="b.steps.length"
+              type="button"
+              class="bridle__thinking-toggle"
+              :aria-expanded="!isBlockCollapsed(b)"
+              aria-label="Toggle thinking details"
+              @click="toggleBlock(b)"
+            >
+              <svg viewBox="0 0 24 24" width="14" height="14" aria-hidden="true"><path d="M6 9l6 6 6-6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" /></svg>
+            </button>
+          </div>
+          <div
+            v-if="b.steps.length && !isBlockCollapsed(b)"
+            class="bridle__thinking-steps"
+          >
+            <div
+              v-for="s in b.steps"
+              :key="s.id"
+              class="bridle__thinking-step"
+              :class="{ 'bridle__thinking-step--active': s.state === 'active' }"
+            >
+              <button
+                v-if="s.detail"
+                type="button"
+                class="bridle__thinking-step-head bridle__thinking-step-head--expandable"
+                :aria-expanded="!!expandedSteps[s.id]"
+                :aria-controls="`bridle-step-${s.id}`"
+                @click="toggleStep(s)"
+              >
+                <span
+                  class="bridle__thinking-step-label"
+                  :class="{ 'bridle__thinking-step-label--active': s.state === 'active' }"
+                >{{ s.label }}</span>
+                <svg class="bridle__thinking-step-chevron" viewBox="0 0 24 24" width="12" height="12" aria-hidden="true"><path d="M6 9l6 6 6-6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" /></svg>
+              </button>
+              <div v-else class="bridle__thinking-step-head">
+                <span
+                  class="bridle__thinking-step-label"
+                  :class="{ 'bridle__thinking-step-label--active': s.state === 'active' }"
+                >{{ s.label }}</span>
+              </div>
+              <div
+                v-if="s.detail && expandedSteps[s.id]"
+                :id="`bridle-step-${s.id}`"
+                class="bridle__thinking-step-detail"
+                v-html="renderMarkdown(s.detail)"
+              />
+            </div>
+          </div>
+        </div>
+        </template>
+        <div
+          v-if="isTyping && !hasOpenThinking"
+          class="bridle__thinking"
+          role="status"
+          :aria-label="thinkingLabel"
+        >
+          <div class="bridle__thinking-header">
+            <span class="bridle__thinking-status">{{ thinkingLabel }}</span>
+          </div>
         </div>
       </div>
 
@@ -2052,28 +2307,157 @@ defineExpose({
   background: rgba(255, 255, 255, 0.08);
 }
 
-.bridle__typing {
+/* ── Thinking status (Rovo-style shimmer) ─────────────────────────────
+   The status text carries a traveling light sweep: a gradient clipped to
+   the glyphs, animated across. Solid `background` first so browsers that
+   reject the gradient/color-mix still render readable muted text. */
+.bridle__thinking {
   align-self: flex-start;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 6px 2px;
+  max-width: 100%;
+}
+.bridle__thinking-header {
   display: inline-flex;
-  gap: 4px;
-  padding: 10px 14px;
-  background: var(--bridle-bubble-bg);
-  border-radius: 14px;
-  border-bottom-left-radius: 4px;
+  align-items: center;
+  gap: 6px;
 }
-.bridle__typing span {
-  width: 6px;
-  height: 6px;
-  border-radius: 50%;
+.bridle__thinking-status {
+  font-size: 14px;
+  font-weight: 500;
+  color: var(--bridle-muted);
   background: var(--bridle-muted);
-  animation: bridle-bounce 1.4s infinite ease-in-out;
+  background: linear-gradient(
+    90deg,
+    var(--bridle-muted) 0%,
+    var(--bridle-muted) 35%,
+    color-mix(in srgb, var(--bridle-muted) 30%, var(--bridle-bg)) 50%,
+    var(--bridle-muted) 65%,
+    var(--bridle-muted) 100%
+  );
+  background-size: 200% 100%;
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: bridle-shimmer 1.6s linear infinite;
+}
+
+@keyframes bridle-shimmer {
+  0% { background-position: 100% 0; }
+  100% { background-position: -100% 0; }
+}
+
+/* Frozen block header: summary row, sweep off. */
+.bridle__thinking-status--done {
+  animation: none;
+  background: none;
+  -webkit-text-fill-color: currentColor;
+  color: var(--bridle-muted);
 }
-.bridle__typing span:nth-child(2) { animation-delay: 0.15s; }
-.bridle__typing span:nth-child(3) { animation-delay: 0.3s; }
 
-@keyframes bridle-bounce {
-  0%, 60%, 100% { opacity: 0.3; transform: translateY(0); }
-  30% { opacity: 1; transform: translateY(-3px); }
+.bridle__thinking-toggle {
+  display: inline-flex;
+  align-items: center;
+  background: none;
+  border: 0;
+  padding: 2px;
+  cursor: pointer;
+  color: var(--bridle-muted);
+}
+.bridle__thinking-toggle svg {
+  transition: transform 0.15s ease;
+}
+.bridle__thinking-toggle[aria-expanded="false"] svg {
+  transform: rotate(-90deg);
+}
+
+/* Vertical timeline of steps, thin left rule à la the Rovo reference. */
+.bridle__thinking-steps {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  margin-left: 5px;
+  padding-left: 12px;
+  border-left: 1px solid var(--bridle-border);
+}
+.bridle__thinking-step {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+}
+.bridle__thinking-step-head {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  background: none;
+  border: 0;
+  padding: 2px 0;
+  font: inherit;
+  font-size: 13px;
+  text-align: left;
+  color: var(--bridle-muted);
+}
+.bridle__thinking-step-head--expandable {
+  cursor: pointer;
+}
+.bridle__thinking-step-chevron {
+  flex-shrink: 0;
+  transition: transform 0.15s ease;
+}
+.bridle__thinking-step-head[aria-expanded="false"] .bridle__thinking-step-chevron {
+  transform: rotate(-90deg);
+}
+.bridle__thinking-step-label {
+  color: var(--bridle-muted);
+}
+/* The in-progress step carries the same light sweep as the status line. */
+.bridle__thinking-step-label--active {
+  color: var(--bridle-fg);
+  background: var(--bridle-fg);
+  background: linear-gradient(
+    90deg,
+    var(--bridle-fg) 0%,
+    var(--bridle-fg) 35%,
+    color-mix(in srgb, var(--bridle-fg) 30%, var(--bridle-bg)) 50%,
+    var(--bridle-fg) 65%,
+    var(--bridle-fg) 100%
+  );
+  background-size: 200% 100%;
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: bridle-shimmer 1.6s linear infinite;
+}
+.bridle__thinking-step-detail {
+  margin: 2px 0 6px;
+  padding-left: 8px;
+  border-left: 2px solid var(--bridle-border);
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--bridle-muted);
+  overflow-wrap: anywhere;
+}
+.bridle__thinking-step-detail :where(p) { margin: 4px 0; }
+
+@media (prefers-reduced-motion: reduce) {
+  .bridle__thinking-status,
+  .bridle__thinking-step-label--active {
+    animation: none;
+    background: none;
+    -webkit-text-fill-color: currentColor;
+  }
+  .bridle__thinking-status {
+    color: var(--bridle-muted);
+  }
+  .bridle__thinking-step-label--active {
+    color: var(--bridle-fg);
+  }
+  .bridle__thinking-toggle svg,
+  .bridle__thinking-step-chevron {
+    transition: none;
+  }
 }
 
 .bridle__input {
diff --git a/sdk/src/client.ts b/sdk/src/client.ts
index 8e327b3..a59513d 100644
--- a/sdk/src/client.ts
+++ b/sdk/src/client.ts
@@ -1,5 +1,5 @@
 import { io, type Socket } from 'socket.io-client'
-import type { BridlePart, IBridleMessage } from './types'
+import type { BridlePart, IBridleMessage, IBridleThinkingEvent } from './types'
 
 export interface IBridleClientOptions {
   apiUrl: string
@@ -20,7 +20,7 @@ export interface IBridleClientOptions {
   prompt?: string
 }
 
-type EventName = 'open' | 'close' | 'error' | 'typing' | 'message' | 'stream' | 'stream_end' | 'welcome'
+type EventName = 'open' | 'close' | 'error' | 'typing' | 'thinking' | 'message' | 'stream' | 'stream_end' | 'welcome'
 type Listener<T = unknown> = (payload: T) => void
 
 /**
@@ -81,7 +81,8 @@ export class BridleClient {
     // What this client can render. The hub forwards the list to the agent
     // on every message — runtimes use it to skip part types this peer
     // can't display (e.g. don't emit `ui` parts to a Telegram client).
-    const capabilities = ['streaming', 'images', 'files', 'ui']
+    // `thinking`: live reasoning-step events (SDK ≥ v0.15.0).
+    const capabilities = ['streaming', 'images', 'files', 'ui', 'thinking']
     const socket = io(`${url}/ws/client`, {
       transports: ['websocket'],
       reconnection: true,
@@ -110,6 +111,9 @@ export class BridleClient {
       this.fire('welcome', data)
     })
     socket.on('typing', () => this.fire('typing', undefined))
+    socket.on('thinking', (data: IBridleThinkingEvent) =>
+      this.fire('thinking', data),
+    )
     socket.on('message', (data: unknown) =>
       this.fire('message', toMessage(data, 'assistant')),
     )
@@ -138,6 +142,7 @@ export class BridleClient {
   on(event: 'open' | 'close' | 'typing', handler: () => void): void
   on(event: 'error', handler: (error: Error) => void): void
   on(event: 'welcome', handler: (data: { clientId: string }) => void): void
+  on(event: 'thinking', handler: (data: IBridleThinkingEvent) => void): void
   on(event: 'message' | 'stream' | 'stream_end', handler: (message: IBridleMessage) => void): void
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   on(event: EventName, handler: (...args: any[]) => void): void {
diff --git a/sdk/src/types.ts b/sdk/src/types.ts
index fcb3b94..cc13d37 100644
--- a/sdk/src/types.ts
+++ b/sdk/src/types.ts
@@ -85,6 +85,52 @@ export interface IBridleUiSubmitPart {
   values: Record<string, BridleUiValue>
 }
 
+// ── Thinking (live reasoning steps) ───────────────────────────
+// Agent → Browser while an answer is being prepared. Rendered as a
+// Rovo-style collapsible timeline above the incoming answer.
+
+/** One published unit of agent work inside a thinking timeline. */
+export interface IBridleThinkingStep {
+  /** Stable per-step id — the `done` update reuses the `active` event's id. */
+  id: string
+  /** Human-readable, visitor-safe step name (e.g. "Search knowledge base"). */
+  label: string
+  /** Optional visitor-safe reasoning prose (markdown). */
+  detail?: string
+  state: 'active' | 'done'
+}
+
+/**
+ * Wire event: a step update (`step` set) or turn completion (`done: true`).
+ * Only delivered to clients that advertised the `thinking` capability.
+ */
+export interface IBridleThinkingEvent {
+  type: 'thinking'
+  clientId: string
+  /** Groups every step of one agent turn. */
+  turnId: string
+  step?: IBridleThinkingStep
+  done?: boolean
+  ts: number
+}
+
+/**
+ * One SEGMENT of a turn's thinking timeline. A turn may produce several
+ * segments: a segment seals (collapses) as soon as assistant content lands
+ * below it, and the next step opens a fresh segment under that message —
+ * so the current activity always renders at the bottom of the flow.
+ * Session-only view state — never persisted or replayed after a reload.
+ */
+export interface IThinkingBlock {
+  turnId: string
+  /** Segment ordinal within the turn — with turnId forms the render key. */
+  seg: number
+  steps: IBridleThinkingStep[]
+  status: 'thinking' | 'done'
+  /** Arrival time of the first event — anchors the segment in the chat flow. */
+  ts: number
+}
+
 export interface IBridleMessage {
   id: string
   role: 'user' | 'assistant'