[BUG] Desktop (Cowork/Code): showThinkingSummaries is ignored — thinking arrives empty (display: omitted) on Fable 5 / Opus 4.7+, "Thought process" panel permanently empty

[r99-creator]

Preflight Checklist

• I have searched existing issues and this hasn't been reported yet
• This is a single bug report (please file separate reports for different bugs)
• I am using the latest version of Claude Code

What's Wrong?

On Claude Desktop (macOS) — both Cowork and Code surfaces — the "Thought process" panel renders for every turn but is permanently empty: expanding it shows no text at any point, then just "Completed". claude.ai web on the same account shows thinking summaries normally. Persisting since ~May 2026.

Transcript forensics (~/.claude/projects/<project>/<session>.jsonl) show this is data-level, not rendering: thinking blocks ARE present, with thinking: "" and only a large signature — the documented shape of thinking.display: "omitted".

Controlled A/B evidence (2026-07-14, Desktop 1.20186.7, runtime 2.1.205) — same session, same account, same settings:

Actor	Model	thinking blocks	text
Main loop	claude-fable-5	23	all empty (0 chars), signatures up to ~15,400 chars
claude-code-guide subagent	claude-haiku-4-5-20251001	17	all populated with plaintext

Cumulative on this machine since 2026-07-11: 331 Fable 5 thinking blocks, 0 with text · 17 Haiku 4.5 blocks, 17 with text. This matches the per-model API defaults (Fable 5 / Sonnet 5 / Opus 4.7+ → display: "omitted"; Haiku 4.5 / ≤4.6 models → "summarized"): the desktop runtime never requests summarized for omitted-default models.

The documented opt-out is a no-op on the desktop surface. The model config docs say interactive sessions on the Anthropic API receive redacted thinking blocks by default and that setting showThinkingSummaries: true restores the full summaries. That key has been set in ~/.claude/settings.json since 2026-07-12 — before all sessions above. Inspection of the live desktop-spawned runtime process confirms user settings are loaded and not overridden (--setting-sources=user,project,local, --settings {} — full argv in logs below). Thinking still arrives empty on Fable 5 / Opus 4.7.

Regression window: 2026-04-11 (claude-opus-4-6 — thinking populated, 611 chars across 3 blocks) → 2026-05-12 onward (claude-opus-4-7, later claude-fable-5 — every sampled block empty: 05-12/13/14/15/17/21, 06-12, 07-11→14). Correlates with the model-default switch to omitted plus CHANGELOG v2.1.89 ("thinking summaries no longer generated by default … set showThinkingSummaries: true … to restore") — a restore path desktop sessions ignore. Evidence sessions (transcripts retained, available on request): 1a1e5f08-cd60-4de6-aa88-9678fbcaf232 (04-11), dd823e3c-4b2f-4097-a768-963a1742f45a (05-12→21), 34f2f61a-9df9-4961-8ea8-4a5f40477251 (06-12), 86bc3562-207d-4b03-be87-f9d4ece9105f (07-14 A/B).

Reproduction:

1. ~/.claude/settings.json → {"showThinkingSummaries": true}
2. Start a new Cowork or Code session on Fable 5 / Opus 4.7+ and let it think
3. Inspect the session .jsonl: every thinking block has "thinking": ""
4. Spawn any Haiku-powered subagent in the same session → its agent-*.jsonl thinking blocks contain plaintext

Additional context: Related — #31326 (terminal analog: empty since v2.1.69, closed as not planned), #67729 (Bedrock ignores summarized display — same "client never applies display" family), #58689 and #52046 (VS Code extension analogs: thinking not viewable on Opus 4.7 despite showThinkingSummaries: true; closed), #24285 (different mechanism: blocks absent vs. present-but-empty). Reported to Anthropic support ~2026-06-12 with a full technical report; no response in 30+ days (Installation ID a118e8fe-e424-4fae-8e01-7f00bd8004cf).

Environment: Claude Desktop 1.20186.7 (macOS, auto-updated) · Claude Code runtime 2.1.205 · CLAUDE_CODE_ENTRYPOINT=claude-desktop · first-party API (api.anthropic.com), consumer OAuth · Affected: claude-opus-4-7, claude-fable-5 (any omitted-default model) · Not affected: claude-haiku-4-5 subagents, claude.ai web

What Should Happen?

Any of, in order of preference:

1. The desktop runtime honors showThinkingSummaries: true (i.e. requests thinking.display: "summarized") the same way the docs describe for the CLI — or exposes an equivalent desktop setting.
2. If omitted is intentional on desktop: the UI should not render an expandable, permanently-empty "Thought process" panel — show a "reasoning hidden" state or hide it. During 10+ minute agentic turns there is currently no way to tell progress from a hang.
3. At minimum, docs state explicitly that showThinkingSummaries does not apply to Claude Desktop sessions.

Error Messages/Logs

# thinking block as stored in session .jsonl (2026-07-14, claude-fable-5, runtime 2.1.205):
{"type": "thinking", "thinking": "", "signature": "CAISs1oK..."}   # signature: 15,440 chars
# same structure on 2026-04-11 (claude-opus-4-6) had plaintext in "thinking"

# transcript scan across all local sessions (model / runtime / dates / blocks):
claude-fable-5             2.1.205   2026-07-11..07-14   331 empty, 0 with text
claude-haiku-4-5-20251001  2.1.205   2026-07-14            0 empty, 17 with text

# live desktop-spawned runtime argv (settings-precedence-relevant flags):
~/Library/Application Support/Claude/claude-code/2.1.205/claude.app/Contents/MacOS/claude
  --output-format stream-json --input-format stream-json
  --effort max --model claude-fable-5
  --setting-sources=user,project,local
  --settings {}
  --permission-mode auto --include-partial-messages [...]
# env: CLAUDE_CODE_ENTRYPOINT=claude-desktop, ANTHROPIC_BASE_URL=https://api.anthropic.com

# ~/.claude/settings.json (mtime 2026-07-12, before all A/B sessions above):
{"showThinkingSummaries": true, ...}

Steps to Reproduce

1. On Claude Desktop (macOS, latest), ensure ~/.claude/settings.json contains {"showThinkingSummaries": true}
2. Start a new Cowork or Code session on Fable 5 (or Opus 4.7+); give it any task that triggers extended thinking
3. Observe the "Thought process" panel: it renders every turn but never shows any text, then reads "Completed"
4. Inspect the session transcript ~/.claude/projects/<project>/<session-id>.jsonl: every assistant thinking block has "thinking": "" with a populated signature (up to ~15,400 chars)
5. In the same session, spawn any Haiku-powered subagent (e.g. the built-in claude-code-guide agent) and inspect its agent-*.jsonl: its thinking blocks contain plaintext — same runtime, same account, same settings; only the model (and its API-side thinking.display default) differs

Claude Model

Not sure / Multiple models

Is this a regression?

Yes, this worked in a previous version

Last Working Version

Runtime 2.1.68 (terminal analog, per #31326); on this machine, desktop thinking last displayed 2026-04-11 (claude-opus-4-6)

Claude Code Version

2.1.205 (Claude Code) — bundled runtime of Claude Desktop 1.20186.7 (macOS)

Platform

Anthropic API

Operating System

macOS

Terminal/Shell

Other

Additional Information

Surface is the Claude Desktop app itself (Cowork and Code tabs), not a terminal — Terminal/Shell set to "Other" as the closest option. The desktop app embeds the Claude Code runtime (spawned with --input-format/--output-format stream-json). Full transcripts and the desktop diagnostic report are available on request.

[gavinBurtonStoreFeeder]

Also have this problem. It looks something like this screenshot.

We see that the agent is thinking, and the number of tokens ticks up, but it cannot be expanded any more.

It looks like an intentional change though, there are no error messages and everything else is working.

This must be fixed if we are to trust claude.

[gavinBurtonStoreFeeder]

I had claude read through the VS code plugin, and look at log files, introspecting the conversation I'm having with it about this issue. Here are it's findings:

I can't include the actual transcript, but visual inspection does show that no thinking text has been sent. The VS code extension appears to work correctly, the problem is upstream and might be intentional.

Report: Why extended-thinking blocks show "Thought for Ns" but won't expand (Claude Code VS Code extension)

Environment: Claude Code VS Code extension anthropic.claude-code-2.1.210-win32-x64 (Windows).
Symptom: In the VS Code panel, a reasoning block renders as a static line — e.g. Thought for 332s — with no way to expand it and read the reasoning. The reasoning is not visible anywhere else in the UI.

Summary

Two facts combine, and only the second is the real gap:

1. The webview renderer has two pathways, selected by whether the thinking block it is handed contains text. Non-empty text renders an expandable <details> with the reasoning inside; empty/blank text renders a static, non-expandable label showing only the duration.

2. The blocks the client holds always have empty text. Every thinking block in the persisted session transcript is { type:"thinking", thinking:"", signature:"…" } — an opaque signature and a duration, but no words.

So the renderer correctly takes the static pathway: it is doing the right thing for empty input. "Thought for 332s, not expandable" is not a rendering bug — it is the correct output when there is no text. The reasoning plaintext is stripped or never delivered upstream of the client's stored state: it is absent from the transcript the host renders from, therefore also absent from whatever the host could forward to the webview. This is at the API/SDK layer, not the host-to-webview boundary, and it is not model output that this client ever sees in readable form.

Evidence

1. The transcript stores signatures, not reasoning text

Session transcript: ~/.claude/projects/c--projects-agents-meat-agent-workspace/<session-id>.jsonl

JSON-parsing every line and inspecting each type:"thinking" block:

thinking blocks:            138
blocks with empty thinking: 138
blocks with non-empty text:   0
keys on each block:         type, thinking, signature
signature length min/max:   412 / 17580

The shape of every block (signature truncated):

{
  "type": "thinking",
  "thinking": "",
  "signature": "Er0ECokBCA8YAipA5+YE+4A2zhjTl3xe0IPvvCp0C9vHZNq2…"   // 412–17580 chars, opaque
}

The signature is an encrypted token the model uses to verify and continue its own prior reasoning on later turns; it is not human-readable and does not contain the reasoning. Note that a naive grep -c '"type":"thinking"' counts block markers, not whether they carry text, and will mislead — a JSON parse is required, and it shows the text is empty in every case.

Consequence: the reasoning is not recoverable from the transcript. There is no plaintext to read or quote.

2. The extension is closed-source (minified bundle)

The extension ships as compiled, minified JavaScript with mangled identifiers — there is no public source for these internals:

• webview/index.js (~4.8 MB) — the React UI that renders the conversation.
• extension.js (~2.2 MB) — the extension host.

The renderer below was recovered by grepping the minified webview/index.js for the literal string Thought for.

The renderer and its two pathways

Raw (minified) — webview/index.js, the Thought for render site

function Vxe({thinkingBlock:e,context:t,isExpanded:i,onToggle:n,isCurrentlyThinking:o,durationMillis:r,liveThinkingTokenEstimate:s}){
  let[a,l]=ne(!1),c=i!==void 0?i:a,d=n!==void 0?n:l,
    u=o?"Thinking...":r!==null?`Thought for ${Math.round(r/1000)}s`:"Thinking",
    h=o&&s?b(klt,{estimate:s}):null;
  if(!e.thinking||!e.thinking.trim())
    return b("div",{className:`${hp.thinking} ${hp.thinkingV2}`,children:E("div",{className:`${hp.thinkingSummary} ${hp.thinkingStatic}`,children:[b("span",{children:u}),h]})});
  return E("details",{className:`${hp.thinking} ${hp.thinkingV2}`,open:c,onToggle:(p)=>d(p.target.open),children:[
    E("summary",{className:hp.thinkingSummary,children:[b("span",{children:u}),h,b(zxe,{className:`${hp.thinkingToggle} ${c?hp.thinkingToggleOpen:""}`})]}),
    b("div",{className:hp.thinkingContent,children:b(up,{content:e.thinking,context:t})})
  ]})
}

(b/E are the bundle's JSX-createElement helpers; ne is useState; up is the markdown renderer.)

De-minified for clarity

function ThinkingBlock({ thinkingBlock, context, isExpanded, onToggle,
                         isCurrentlyThinking, durationMillis, liveThinkingTokenEstimate }) {

  const [localOpen, setLocalOpen] = useState(false);
  const open   = isExpanded !== undefined ? isExpanded : localOpen;
  const toggle = onToggle   !== undefined ? onToggle   : setLocalOpen;

  const label =
      isCurrentlyThinking      ? "Thinking..." :
      durationMillis !== null  ? `Thought for ${Math.round(durationMillis / 1000)}s` :
                                 "Thinking";

  // ---- PATHWAY A: no reasoning text present ----
  if (!thinkingBlock.thinking || !thinkingBlock.thinking.trim()) {
    return (
      <div className="thinking thinkingV2">
        <div className="thinkingSummary thinkingStatic">   {/* static: no <details>, no toggle, no body */}
          <span>{label}</span>
        </div>
      </div>
    );
  }

  // ---- PATHWAY B: reasoning text present ----
  return (
    <details className="thinking thinkingV2" open={open} onToggle={e => toggle(e.target.open)}>
      <summary className="thinkingSummary">
        <span>{label}</span>
        <Chevron className={open ? "thinkingToggleOpen" : ""} />
      </summary>
      <div className="thinkingContent">
        <Markdown content={thinkingBlock.thinking} context={context} />
      </div>
    </details>
  );
}

Pathway A — static, non-expandable (the observed behaviour)

• Trigger: thinkingBlock.thinking is null, undefined, "", or whitespace-only.
• Renders: a plain <div> with class thinkingStatic containing only the label (Thought for 332s).
• No <details>, no <summary>, no toggle chevron, no content node. The reasoning body is never placed in the DOM, so there is nothing to expand.

Pathway B — expandable (the intended experience, not reached here)

• Trigger: thinkingBlock.thinking contains non-whitespace text.
• Renders: a native <details> element — a clickable <summary> (label + chevron) and a <div class="thinkingContent"> holding the reasoning as markdown.
• Expand/collapse works via the <details open> attribute, driven by controlled props (isExpanded/onToggle) or the local useState fallback.

Because the client's thinking blocks always have empty text (see Evidence 1), Pathway B is never reached for them; the panel always renders Pathway A.

Root cause

The webview renders the duration correctly and takes Pathway A because the block's thinking is empty — the renderer is behaving correctly for its input. The real gap is that the block never has text on the client side: the persisted transcript, which is the store the host renders from, holds only thinking:"" + signature. The plaintext is stripped or never delivered before it reaches anything the client can display.

Confidence:

• Confirmed (read from the shipped bundle): the two-pathway renderer and its exact empty-text condition.
• Confirmed (JSON-parsed on disk): 138 thinking blocks, all with empty thinking and a non-empty signature; none carry reasoning text.
• Confirmed: the reasoning plaintext is not recoverable from the transcript.
• Not determinable from the on-disk artifacts alone: which layer drops the plaintext, and whether it was ever present client-side. Candidates: (a) the API returns signature-only thinking to this SDK/effort configuration; (b) the Agent SDK / harness streams plaintext live but persists only the signature, discarding the text once the turn completes. Distinguishing these needs a network or stream capture.

Implications

• Reasoning that is billed and generated (e.g. 332s of it) is currently unauditable in the VS Code panel — it cannot be watched or reviewed there.
• It is not recoverable after the fact either: the transcript keeps only the signature and duration, not the words.
• This is closer to a content-retention gap than a display bug: the plaintext is not available client-side at all. Whether that is by design (privacy/size) or incidental is unconfirmed.

Workarounds

1. Watch it live in the terminal CLI — the CLI can stream thinking/tool events (verbose) as they happen. Unverified against this environment: if the CLI is subject to the same signature-only delivery it will not show plaintext either, so test it directly (run a task with verbose and see whether reasoning text appears).
2. Have the assistant reason in the open — lower effort and/or narrate a short plan before each step, so the reasoning lands in normal rendered text (which is retained and rendered) rather than a hidden thinking block. This is the only option fully under our control and immune to the retention gap.
3. Do not rely on the session .jsonl for reasoning — it contains signatures only.

Artifacts / references

• Renderer: ~/.vscode/extensions/anthropic.claude-code-2.1.210-win32-x64/webview/index.js (search Thought for).
• Host bundle (candidate strip point, unconfirmed): ~/.vscode/extensions/anthropic.claude-code-2.1.210-win32-x64/extension.js.
• Transcript (signatures only, no reasoning text): ~/.claude/projects/c--projects-agents-meat-agent-workspace/<session-id>.jsonl.
• Related upstream reports (thinking visibility is actively changing): Claude Code GitHub issues Show extended thinking in CLI output (collapsed by default, toggle to expand) #36006 (CLI), VS Code extension: add a verbose toggle equivalent to CLI Ctrl+O #54322 (VS Code verbose toggle).

[r99-creator]

Thanks @gavinBurtonStoreFeeder — the VS Code data point (2.1.210, Windows, 138/138 empty with signature) matches exactly, and the renderer analysis is a useful confirmation that the clients render correctly for empty input.

On your open question about which layer drops the plaintext, the A/B in the original report resolves most of it: in a single desktop session on runtime 2.1.205, a Haiku 4.5 subagent's thinking blocks persist with plaintext through the same SDK/persistence pipeline that stores Fable 5 blocks empty. If the SDK/harness were stripping text at stream- or persist-time, Haiku's blocks would be empty too. So this is your candidate (a): the API returns signature-only thinking for omitted-default models (Fable 5 / Sonnet 5 / Opus 4.7+) unless the client requests thinking.display: "summarized" — which is exactly what showThinkingSummaries: true is documented to do, and what the desktop (and apparently the VS Code extension) never sends.

One caveat on the terminal-CLI workaround: per #31326 the terminal has the same empty-by-default behavior since v2.1.69; the docs say showThinkingSummaries: true restores summaries there. If you can test that on your account, the contrast (works on terminal vs. no-op on desktop/VS Code) would sharpen the fix scope for the maintainers.

[r99-creator]

Update: resolved by the Claude Desktop 1.21459.0 client update — summaries are arriving again.

Data from the same machine/account as the report (all UTC; CC runtime version constant throughout):

Turn time	Desktop build	CC runtime	thinking text
07-14 11:56–12:05	1.20186.9	2.1.209	all empty
07-15 ~01:00	1.21459.0 auto-installed	2.1.209	—
07-15 04:37 onward	1.21459.0 / .1	2.1.209	all populated (≈150–3,600 chars, summarized-sized)

Since the runtime is identical on both sides of the boundary, the change came with the Desktop app build (1.20186.9 → 1.21459.0), not the CC runtime — consistent with the host now enabling/requesting thinking.display: "summarized". The Desktop UI renders the summaries inline, including on Fable 5. showThinkingSummaries: true was set the whole time, so I can't tell whether the new build honors it or enables summaries by default.

@gavinBurtonStoreFeeder — worth checking whether a VS Code extension update past your 2.1.210 does the same there.

From my side the core symptom is resolved as of 1.21459.0. Leaving open in case the maintainers want to confirm intent/scope (and the cosmetic point stands: when text is absent, the panel still renders as expandable-but-empty). Feel free to close otherwise.

[r99-creator]

Follow-up: the fix is partial — Cowork (VM sandbox) sessions on the same Desktop build still receive empty thinking.

Same machine/account, Desktop 1.21459.1. The two desktop surfaces now diverge:

Surface	How the runtime is launched	Runtime	thinking text
Code tab (local agent)	host-spawned claude --output-format stream-json …	2.1.209	summaries since 1.21459.0 ✅
Cowork tab (VM sandbox)	in-VM claude --preload /home/claude/.claude/remote/spare.sock	2.1.211	still all empty ❌

Verified from inside the Cowork environment (2026-07-16, model claude-fable-5, CLI 2.1.211): every thinking block in the in-VM session transcript is thinking: "" + signature — the same shape as the original report.

Likely why it was missed: the Cowork environment has no user ~/.claude/settings.json — only a launcher-injected launcher-settings.json (hooks/permissions/skillOverrides; no thinking keys) — and the session is configured via the preload socket, not CLI flags. So whatever 1.21459.0 changed for local sessions (requesting thinking.display: "summarized") doesn't propagate through the Cowork VM/preload launcher path.

Note this also rules out runtime version as the variable: the in-VM CLI (2.1.211) is newer than my local one (2.1.209), where summaries now work.

Could the same enablement be applied to the Cowork launcher path (via the preload protocol or launcher-settings)?