[BUG] Opus 4.7 thinking summaries not rendered in VS Code extension

Found 2 possible duplicate issues:

1. https://github.com/anthropics/claude-code/issues/49268
2. https://github.com/anthropics/claude-code/issues/48065

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

Please let us turn off the redact-thinking-2026-02-12 flag, there are so many unaddressed issues about this (I counted 5-6).

The comment from bcherny on hackernews said something like "users don't read reasoning summaries anyway".

It's already summaries and not the true reasoning, why just take it away? I need it.

EDIT: Should I feel so disappointed on new model day? :(

I agree with @Madd0g
Thinking summaries should come back.

Please let us turn off the redact-thinking-2026-02-12 flag, there are so many unaddressed issues about this (I counted 5-6). The comment from bcherny on hackernews said something like "users don't read reasoning summaries anyway". It's already summaries and not the true reasoning, why just take it away? I need it. EDIT: Should I feel so disappointed on new model day? :(

I use and read summaries to track the approaches Claude is considering, it helps me gauge if it's understanding the issue it's working on.

I really hope they revert/fix this, for now I'll stick with Opus 4.6 and hope I don't have to wave thinking summaries goodbye as we move forward

I use and read summaries to track the approaches Claude is considering

Exactly, helps me think of angles I haven't considered myself. And it's literally the only place I could see if it's considering my request silly or wrong in any way (according to my own rules from Claude.md for example)

This is an absurd regression. Taking thinking visibility away is like taking logging away, it's absolutely critical for identifying what needs more prompt clarification. What's next, redacting all tool calls? Redacting any and every response to "Done."? All in the name of reducing time to first response token? The thinking tokens are literally the first tokens I read, every single time. If the thinking is off, I cancel the request, because the response is going to be garbage.

oh.. actually for my case adding this parameter to the command line args works --thinking-display summarized, I don't know if this is the same reasoning from before, but it's something.

Found on hackernews

oh.. actually for my case adding this parameter to the command line args works --thinking-display summarized, I don't know if this is the same reasoning from before, but it's something. Found on hackernews

Hmm, well this issue is about the VS Code extension specifically, which doesn't have ability to use direct CLI flags. Nice to know there's a workaround in the CLI though.

It's weird because the thinking summaries do show sometimes. But randomly and rarely. In the CLI for me. Most of the time I'm left in the dark. Anthropic, please bring them back.

And I DO have showThinkingSummaries:true

> oh.. actually for my case adding this parameter to the command line args works --thinking-display summarized, I don't know if this is the same reasoning from before, but it's something. > Found on hackernews Hmm, well this issue is about the VS Code extension specifically, which doesn't have ability to use direct CLI flags. Nice to know there's a workaround in the CLI though.

Can be done (thank Claude for this).
wrapper script:

#!/bin/bash
# Workaround for VSCode Claude Code extension 2.1.111+ not passing
# --thinking-display to the binary on Opus 4.7 (API default changed
# to "omitted", so thinking blocks arrive empty). See:
#   https://github.com/anthropics/claude-code/issues/49322
#   https://github.com/anthropics/claude-code/issues/49268
# Configure via VSCode settings.json:
#   "claudeCode.claudeProcessWrapper": "/Users/YOUR_USERNAME/.local/bin/claude-wrapper"

exec "$@" --thinking-display summarized

Make it executable:
chmod +x /Users/YOUR_USERNAME/.local/bin/claude-wrapper

Afterward, add this to VSCode's user settings.json (Cmd+Shift+P → "Preferences: Open User Settings (JSON)"):
"claudeCode.claudeProcessWrapper": "/Users/YOUR_USERNAME/.local/bin/claude-wrapper"

Then reload the VSCode window (Cmd+Shift+P → "Developer: Reload Window") to kick the extension and make it pick up the new setting.

...Can be done (thank Claude for this)...

Hey, that worked for me. Thank you Claude but I appreciate you too.

The thinking summaries are critical for complex tasks, You can catch claude going in circles, making wrong decisions or other issues to redirect it.

This is a significant regression and needs to be brought back, it makes claude code highly risky in complex tasks.

Got the same issue on Windows. Workaround didn't work. I created a Windhawk mod to solve this:

<details><summary>Windhawk mod</summary>
<p>

// ==WindhawkMod==
// @id              claude-custom-command-line
// @name            Claude custom command line arguments
// @description     Append extra command line arguments to claude.exe, e.g. to restore Opus 4.7 thinking summaries in the Claude Code VS Code extension
// @version         1.0
// @author          justanotheranonymoususer
// @github          https://github.com/justanotheranonymoususer
// @include         claude.exe
// @license         MIT
// ==/WindhawkMod==

// ==WindhawkModReadme==
/*
# Claude custom command line arguments

Appends extra command line arguments to claude.exe by hooking
`GetCommandLineW`/`GetCommandLineA`.

The default appended arguments are `--thinking-display summarized`, a
workaround for Opus 4.7 thinking summaries not being shown in the Claude Code
VS Code extension. See:
[https://github.com/anthropics/claude-code/issues/49322](https://github.com/anthropics/claude-code/issues/49322)

The appended arguments can be changed in the mod settings.

claude.exe has to be restarted for setting changes to take effect.
*/
// ==/WindhawkModReadme==

// ==WindhawkModSettings==
/*
- extraArgs: "--thinking-display summarized"
  $name: Extra command line arguments
  $description: Extra arguments appended to the Claude command line.
*/
// ==/WindhawkModSettings==

#include <string>
#include <string_view>

std::wstring g_originalCommandLineW;
PCWSTR g_newCommandLineW;
PCSTR g_newCommandLineA;

using GetCommandLineW_t = decltype(&GetCommandLineW);
GetCommandLineW_t GetCommandLineW_Original;
LPWSTR WINAPI GetCommandLineW_Hook() {
    return const_cast<LPWSTR>(g_newCommandLineW);
}

using GetCommandLineA_t = decltype(&GetCommandLineA);
GetCommandLineA_t GetCommandLineA_Original;
LPSTR WINAPI GetCommandLineA_Hook() {
    return const_cast<LPSTR>(g_newCommandLineA);
}

std::string WideToAnsi(std::wstring_view wide) {
    if (wide.empty()) {
        return std::string();
    }

    int size = WideCharToMultiByte(CP_ACP, 0, wide.data(),
                                   static_cast<int>(wide.size()), nullptr, 0,
                                   nullptr, nullptr);
    if (size <= 0) {
        return std::string();
    }

    std::string result(size, '\0');
    WideCharToMultiByte(CP_ACP, 0, wide.data(), static_cast<int>(wide.size()),
                        result.data(), size, nullptr, nullptr);
    return result;
}

void BuildNewCommandLines() {
    std::wstring result = g_originalCommandLineW;

    PCWSTR extraArgs = Wh_GetStringSetting(L"extraArgs");

    if (*extraArgs) {
        if (!result.empty() && result.back() != L' ') {
            result += L' ';
        }
        result += extraArgs;
    }

    Wh_FreeStringSetting(extraArgs);

    // Intentionally leaked: callers may cache the returned pointer, so
    // previously-returned buffers must remain valid for the process lifetime.
    g_newCommandLineW = (new std::wstring(std::move(result)))->c_str();
    g_newCommandLineA = (new std::string(WideToAnsi(g_newCommandLineW)))->c_str();
}

BOOL Wh_ModInit() {
    Wh_Log(L">");

    g_originalCommandLineW = GetCommandLineW();

    BuildNewCommandLines();

    Wh_Log(L"New command line: %s", g_newCommandLineW);

    Wh_SetFunctionHook((void*)GetCommandLineW, (void*)GetCommandLineW_Hook,
                       (void**)&GetCommandLineW_Original);
    Wh_SetFunctionHook((void*)GetCommandLineA, (void*)GetCommandLineA_Hook,
                       (void**)&GetCommandLineA_Original);

    return TRUE;
}

void Wh_ModSettingsChanged() {
    Wh_Log(L">");

    BuildNewCommandLines();
}

</p>
</details>

Steps:

• Download Windhawk
• Click on "Create a new mod" in the corner
• Paste the code
• Press "Compile mod"
• Press "Exit" red button
• ...
• Profit!

Windows works without Windhawk — the documented claudeCode.claudeProcessWrapper extension point accepts any executable, so a tiny Python shim + .cmd forwarder is enough. No GetCommandLineW hook, no binary instrumentation.

claude-thinking-wrapper.cmd (what the extension spawns):

@echo off
python "%~dp0claude-thinking-wrapper.py" %*

claude-thinking-wrapper.py (sits next to the .cmd):

#!/usr/bin/env python3
"""Wrap claude.exe to force --thinking-display summarized.

Extension contract: when claudeProcessWrapper is set, the extension spawns the
wrapper with the real claude executable path as argv[1], followed by the normal
claude args. We inject --thinking-display summarized after the executable path
and forward.
"""
from __future__ import annotations
import os, subprocess, sys

def main() -> int:
    argv = list(sys.argv[1:])
    if not argv:
        sys.stderr.write("[thinking-wrapper] no executable path passed\n")
        return 2
    executable, rest = argv[0], argv[1:]
    if "--thinking-display" not in rest:
        rest = ["--thinking-display", "summarized", *rest]
    if not os.path.exists(executable):
        sys.stderr.write(f"[thinking-wrapper] executable not found: {executable}\n")
        return 127
    return subprocess.call([executable, *rest])

if __name__ == "__main__":
    sys.exit(main())

VSCode/VSCodium settings.json:

"claudeCode.claudeProcessWrapper": "C:\Users\YOU\.claude\scripts\claude-thinking-wrapper.cmd"

Reload the window and Opus 4.7 thinking summaries come back.

Why the .cmd matters on Windows: the extension spawns the wrapper directly, so a shebang-only Python or bash file isn't executable by the spawn. The .cmd is a 2-line forwarder that delegates to Python.

Confirmed working on VSCodium 1.107.x + claude-code 2.1.114 + Opus 4.7 [1m]. Still a workaround for the underlying regression — this just keeps the summaries visible until the extension sets display: "summarized" itself (#49268).

from claude with love :)))

Windows workaround

Adding a Windows variant for others who hit this — the bash wrapper above (thanks @thatChadM) doesn't work on Windows because the VSCode extension spawns the wrapper with child_process.spawn without shell: true. Windows can only execute native .exe files that way — .cmd / .bat files produce a red "failed to start" error.

Fix: ship the wrapper as a tiny native .exe. Here's a Go version (~20 lines, Go 1.18+):

claude-wrapper.go

package main

import (
	"os"
	"os/exec"
)

func main() {
	args := os.Args[1:]
	if len(args) == 0 {
		os.Exit(1)
	}
	cmd := exec.Command(args[0], append(args[1:], "--thinking-display", "summarized")...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		if exitErr, ok := err.(*exec.ExitError); ok {
			os.Exit(exitErr.ExitCode())
		}
		os.Exit(1)
	}
}

Build (produces a ~2.5 MB standalone exe, no runtime deps):

go build -o "%USERPROFILE%\.claude\claude-wrapper.exe" claude-wrapper.go

VSCode user settings (Ctrl+Shift+P → "Preferences: Open User Settings (JSON)"):

"claudeCode.claudeProcessWrapper": "C:\\Users\\YOUR_USERNAME\\.claude\\claude-wrapper.exe"

(Note the doubled backslashes — JSON escaping.)

Then reload the window: Ctrl+Shift+P → "Developer: Reload Window". Thinking summaries render again for Opus 4.7.

Revert

1. Delete %USERPROFILE%\.claude\claude-wrapper.exe
2. Remove the claudeCode.claudeProcessWrapper line from user settings.json
3. Reload the window

Notes

• Tested on Windows 11 with VSCode extension 2.1.114 and Go 1.24.
• The wrapper is model-agnostic. On models where thinking summaries already work, --thinking-display summarized matches the desired behavior, so it's effectively a no-op. Remove the setting once the extension is fixed.
• If you don't have Go installed: any language that produces a native .exe works (C, Rust, Zig, etc.). The logic is trivial — just re-exec argv[1:] with --thinking-display summarized appended.

Hi — this is Claude (Opus 4.7), posting from the account owner's GitHub at his request.

@thatChadM, thanks — your wrapper got us back to visible thinking on Cursor 2.x (macOS). Posting a drop-in prompt so anyone landing here can have their Claude Code session implement it for them, across editor flavors and OSes:

~~~
Please implement the Claude Code "thinking display" workaround from this issue:
https://github.com/anthropics/claude-code/issues/49322

Start with @thatChadM's bash wrapper (works on macOS/Linux). On Windows that
wrapper won't spawn — use @cristian-sima's Go .exe or @Evey-Vendetta's
Python+.cmd variant later in the same thread.

Detect which VSCode-family editor I'm using (VSCode / VSCode Insiders / Cursor)
by checking which settings.json already has claudeCode.* entries. Create the
wrapper at a sensible path for my OS, make it executable, add
claudeCode.claudeProcessWrapper pointing at it in the correct settings.json,
and tell me to reload the window plus a test prompt to verify.
~~~

After reload, send something that warrants reasoning (e.g. "think about the tradeoffs of X vs Y in our codebase") — summarized thinking should render again. Remove the claudeCode.claudeProcessWrapper setting once the extension ships an official fix.

— Claude

Confirming the claudeProcessWrapper workaround works on Linux (VS Code Remote-SSH, extension 2.1.116). 🥳

some learnings.
Gotcha1 values:

--thinking-display summarized -> works, and the summary is substantive enough to catch logic loops / misunderstandings mid-session (my actual use case).
--thinking-display visible -> crashes the extension on session spawn with Error: Claude Code process exited with code 1. (wanted to test something un-summarized lol)

Gotcha2: naive exec "$@" --thinking-display summarized also crashes with exit 1. The extension invokes the bundled claude binary for more than interactive sessions BUT it also spawns it for mcp, --version probes, and other helper calls. Appending the flag unconditionally breaks those.

Guarded wrapper:

#!/bin/bash
# VSCode invokes as: claude-wrapper <binary> <args...>

for arg in "${@:2}"; do
  case "$arg" in
    --thinking-display|--thinking-display=*) exec "$@" ;;
    --version|-v) exec "$@" ;;
  esac
done

for arg in "${@:2}"; do
  case "$arg" in
    -*) continue ;;
    mcp|doctor|install|update|upgrade|auth|plugin|plugins|agents|auto-mode|setup-token)
      exec "$@" ;;
    *) break ;;
  esac
done

exec "$@" --thinking-display summarized

-----

Quick note on testing (vibecode warning): if the wrapper crashes the extension, the Claude panel won't load, duh 😆, so you can't ask Claude to fix it. So edit the wrapper file directly in a regular editor.

If you are like me and SSH into your server remotely:
setting can go in ~/.vscode-server/data/Machine/settings.json on the remote. no local user-settings access needed.

🙏 thx to all my above commenters here, that was easier than expected!

+1. VS Code extension, Opus 4.7, showThinkingSummaries: true - no thinking output at all. Likely the same root cause as #49268 (harness not requesting display: "summarized" on 4.7). The setting silently no-ops, which is worse than documenting the limitation.

Same issue. Strongly need this feature.

Just a note here: I was previously using the claudeProcessWrapper workaround, but I noticed it broke some things in VS Code like for example the /plugins command.

As an alternative, you can also set the undocumented environment variable CLAUDE_CODE_EXTRA_BODY. For example, write the following in your ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_EXTRA_BODY": "{\"thinking\":{\"type\":\"adaptive\",\"display\":\"summarized\"}}"
  }
}

You need to set type: adaptive because it's a mandatory parameter and the CLAUDE_CODE_EXTRA_BODY environment variable clobbers any existing objects specified within it (it only does a shallow merge). EDIT: But be aware, as noted below, that this breaks Haiku usage since that model doesn't support the type parameter.

@shawnz - you're awesome, thank you very much for posting this and the original workaround! I owe my April 16th sanity exclusively to you! (need to paraphrase this lol)

Windows + VSCodium: guarded .exe wrapper (PyInstaller freeze) — confirmed working on 2.1.118

Closing the loop on the Windows workaround after some thrashing:

What didn't work in my multi-model harness (Opus + Sonnet + Haiku subagent dispatches):

1. CLAUDE_CODE_EXTRA_BODY env var with {thinking: {type: adaptive, display: summarized}} — breaks every Haiku dispatch with adaptive thinking is not supported on this model (API 400). Haiku doesn't support adaptive type. Env var applies to ALL API calls from the CC process, not just interactive Opus, so this is fatal for any setup that dispatches Haiku subagents. Fine for single-model interactive use.

1. Val4evr's thinkingDisplay settings key — documented working on 2.1.116 but no-op on 2.1.117 and 2.1.118 in my testing. Key survives CC startup (not stripped) but thinking blocks still don't render. Either the read path was gated, or the key is consumed but overridden elsewhere.

1. .cmd → .py wrapper via claudeProcessWrapper — crashed the VSCodium extension entirely on reload. VSCodium's child_process.spawn on Windows doesn't auto-shell .cmd files the way standard Node does.

What does work: standalone .exe wrapper with subcommand guards

Python wrapper frozen to .exe via PyInstaller (python -m PyInstaller --onefile wrapper.py). Guards subcommands like mcp, doctor, plugin/plugins, agents, auto-mode, setup-token, --version, --help so /plugins, /mcp, /doctor continue to work. Only appends --thinking-display summarized to interactive invocations.

Wrapper logic:

_SKIP_FLAGS = {"--version", "-v", "--help", "-h"}
_SKIP_SUBCOMMANDS = {"mcp", "doctor", "install", "update", "upgrade",
                    "auth", "plugin", "plugins", "agents", "auto-mode",
                    "setup-token", "config", "migrate-installer"}

def _should_skip(rest):
    if "--thinking-display" in rest:
        return True
    for arg in rest:
        if arg in _SKIP_FLAGS:
            return True
    for arg in rest:
        if arg.startswith("-"):
            continue
        if arg in _SKIP_SUBCOMMANDS:
            return True
        break
    return False

def main():
    argv = list(sys.argv[1:])
    executable, rest = argv[0], argv[1:]
    if not _should_skip(rest):
        rest = ["--thinking-display", "summarized", *rest]
    try:
        return subprocess.call([executable, *rest])
    except FileNotFoundError:
        # Windows may pass path without .exe; retry with suffix
        if not executable.lower().endswith(".exe") and os.path.exists(executable + ".exe"):
            return subprocess.call([executable + ".exe", *rest])
        return 127

Build:

python -m PyInstaller --onefile wrapper.py

VSCodium user settings.json:

"claudeCode.claudeProcessWrapper": "C:\Users\YOU\.claude\scripts\claude-thinking-wrapper.exe"

Reload window. Opus 4.7 thinking summaries render, /plugins + /mcp + /doctor all continue to work, Haiku and Sonnet subagent dispatches unaffected.

Still a workaround — the upstream fix (harness setting display: "summarized" natively for Opus 4.7 per #49268) would make this obsolete.

Just a note here: I was previously using the claudeProcessWrapper workaround, but I noticed it broke some things in VS Code like for example the /plugins command. As an alternative, you can also set the undocumented environment variable CLAUDE_CODE_EXTRA_BODY. For example, write the following in your ~/.claude/settings.json: { "env": { "CLAUDE_CODE_EXTRA_BODY": "{\"thinking\":{\"type\":\"adaptive\",\"display\":\"summarized\"}}" } } You need to set type: adaptive because it's a mandatory parameter and the CLAUDE_CODE_EXTRA_BODY environment variable clobbers any existing objects specified within it (it only does a shallow merge). EDIT: But be aware, as noted below, that this breaks Haiku usage since that model doesn't support the type parameter.

Thank you, this works, but for some reason it also disabled Web Fetch and WebSearch? One shows "adaptive thinking is not supported", the other shows "Thinking may not be enabled when tool_choice forces tool use"

<html>
<body>
<!--StartFragment--><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><strong>Workaround observation: invert the "Extended thinking" toggle on Opus 4.7 (Windows, extension 2.1.114)</strong></p><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Stumbled onto a no-cost workaround that may help others on Windows / <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">effort=max</code> setups. Pasting in case it saves people the wrapper round-trip.</p><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><strong>Setup:</strong></p><ul style="padding-inline-start: 2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><li>OS: Windows 11</li><li>VS Code Claude Code extension: 2.1.114</li><li>Model:<span> </span><code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">claude-opus-4-7[1m]</code></li><li><code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">~/.claude/settings.json</code><span> </span>env:<span> </span><code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">CLAUDE_CODE_EFFORT_LEVEL=max</code></li><li>Extension settings include<span> </span><code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">claudeCode.allowDangerouslySkipPermissions: true</code>,<span> </span><code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">claudeCode.initialPermissionMode: bypassPermissions</code><span> </span>(probably not relevant, listing for completeness)</li></ul><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><strong>Observation across 3 trials with substantive reasoning prompts:</strong></p>
Extended thinking toggle (in prompt-box / menu) | Thinking summary in UI
-- | --
OFF | Renders normally (multi-paragraph summarized thinking above the answer, same as 4.6 behavior)
ON | Empty / no thinking block visible

<p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">The toggle's intuitive meaning appears to be inverted on 4.7. Sonnet 4.6 in the same extension shows summaries correctly with the toggle in either state, so this is 4.7-specific.</p><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><strong>Inferred mechanism (best guess without extension source):</strong> the "ON" path likely sends <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">thinking: {type: "adaptive"}</code> without an explicit <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">display</code> field, and on 4.7 that defaults to <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">display: "omitted"</code> per the <a href="https://platform.claude.com/docs/en/about-claude/models/whats-new-claude-4-7" target="_blank" rel="noopener noreferrer" style="color: rgb(72, 160, 199); text-decoration: rgb(72, 160, 199);">4.7 breaking change</a> → empty thinking blocks. The "OFF" path appears to send a different request shape that, combined with <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">effort=max</code> keeping the model thinking server-side, ends up returning summarized thinking. Effectively a happy accident from the inverted defaults.</p><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><strong>For users who want thinking summaries back on 4.7 today:</strong> try toggling Extended thinking <strong>OFF</strong> before reaching for <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">claudeProcessWrapper</code> or <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">CLAUDE_CODE_EXTRA_BODY</code> — both of which have their own breakage modes (wrapper crashes extension on Windows due to <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">spawn EINVAL</code> on <code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">.cmd</code>/<code style="font-family: monospace; color: rgb(140, 140, 140); background-color: rgb(38, 38, 38); padding: 2px 4px; border-radius: 3px; word-break: break-word; font-size: 0.9em;">.bat</code>; env-var clobbers Haiku and breaks Web Fetch / Web Search per @JacktheRanger above).</p><p style="white-space: pre-wrap; margin-top: 0.1em; margin-bottom: 0.2em; color: rgb(191, 191, 191); font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif; font-size: 13px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(18, 19, 20); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">When the underlying bug is fixed, this workaround presumably flips back, so worth re-testing after extension updates.</p><!--EndFragment-->
</body>
</html>Workaround observation: invert the "Extended thinking" toggle on Opus 4.7 (Windows, extension 2.1.114)

Just throwing in another observation. Due to the issues with the CLAUDE_CODE_EXTRA_BODY breaking Haiku, web search, and similar, I went back to the wrapper script. I found that fixing the wrapper script to not crash when using /plugins was as simple as re-arranging the parameter order. e.g.:

#!/bin/bash
exec "$1" --thinking-display summarized "${@:2}"

...instead of my original approach of putting --thinking-display summarized at the end. I got claude to step through the decompiled source code of both the claude code binary and the VS code extension, and it appears that this should work for all code paths. They are using commander.js with the enablePositionalOptions flag set, which parses left-to-right and only hits the error if the --thinking-display occurs AFTER a subcommand. Therefore I don't think there's a need to explicitly detect subcommands. So I will be using this approach for myself. Let me know if anyone tries this and observes any issues.

Strangely enough, @Baharlooie's workaround of just turning thinking off also seems to work for me, but that strikes me as potentially brittle. I think the ideal solution would be if they fix the new upstream behaviour of showThinkingSummaries to work even in non-interactive sessions, like @anthrotype described here: https://github.com/anthropics/claude-code/issues/8477#issuecomment-4305259256. But until that is in place, I will be sticking with the wrapper script

Confirming repro on macOS, extension v2.1.121, model claude-opus-4-7[1m]. Same symptom: "Thought for Xs" line renders in the VS Code panel but is inert — clicking does nothing, no expand chevron.

showThinkingSummaries: true is set in ~/.claude/settings.json and has no effect (silent no-op, as @Shadetail noted).

@shawnz's claudeProcessWrapper workaround (with --thinking-display summarized placed BEFORE the positional args) works as documented and does not break /plugins, /mcp, or /doctor for me. The CLAUDE_CODE_EXTRA_BODY alternative was a non-starter for my setup because I dispatch Haiku subagents (the adaptive type errors them) and use WebFetch/WebSearch heavily (also broken per @JacktheRanger).

Adding to the count of users this is affecting — the wrapper is a tolerable patch but the underlying behavior change (Opus 4.7 defaulting display: "omitted" and the extension not setting it back to summarized) silently degrades a critical visibility feature. +1 to fixing this in the extension itself.

Same bug on Windows / VS Code extension 2.1.x with Opus 4.7. Not macOS-specific.

Root cause is now public (credit to the workaround in #8477 (comment)): Opus 4.7 changed the API default for thinking blocks from display: "summarized" to display: "omitted". The blocks are still in the response stream, but the thinking field is empty unless the caller passes display: "summarized" explicitly. Documented in Anthropic's own migration guide: https://platform.claude.com/docs/en/about-claude/models/migration-guide#migrating-to-claude-opus-4-7

Net effect: showThinkingSummaries, alwaysThinkingEnabled, and viewMode: "verbose" have nothing to render, because Claude Code does not pass display: "summarized" when calling the Opus 4.7 API. showThinkingSummaries is the documented, official way to surface thinking in the VS Code extension, and it is silently broken on Opus 4.7. The settings surface never caught up to the API change.

Two undocumented workarounds (from the same comment):

1. Add to ~/.claude/settings.json:

``json
{
"env": {
"CLAUDE_CODE_EXTRA_BODY": "{\"thinking\":{\"type\":\"adaptive\",\"display\":\"summarized\"}}"
}
}
``

1. Hidden CLI flag: --thinking-display summarized

The env var approach works for the VS Code extension since it delegates to the CLI.

Why this is high-priority, not a cosmetic regression:

Visible real-time thinking was load-bearing for the steering loop. With it visible, you could stop the model going down a wrong branch before it spent N turns of token budget on a wrong premise; you could verify it had internalized constraints from CLAUDE.md / memory rather than hallucinated them; and you could audit assumptions before committing to a plan.

With it hidden behind an unexpandable pill, you cannot tell whether a wrong final answer came from a wrong premise or a wrong execution of a right premise. Silent assumption drift becomes invisible until after the wrong action is taken. "Thought for 376s" is a duration, not a signal. It tells you nothing actionable. This is a regression in the developer's ability to supervise the agent.

On the user side: this is a paid product. Pro at $20/month, Max at $100–$200/month. Paying customers should not have to monkey-patch cli.js, reverse-engineer an undocumented CLAUDE_CODE_EXTRA_BODY env var, or scrape issue threads to recover functionality that worked in the previous release of the same product. The workaround being undocumented is itself a bug. The gap between what the API supports and what Claude Code exposes as a first-class setting keeps widening with every model bump.

Related open issues, same root problem:

• #8477 — original tracking issue where the API-default change was traced and the workaround was published
• #49268 — harness doesn't set display: "summarized" for Opus 4.7 (same root cause, named explicitly)
• #49757 — empty/unexpandable stub in VS Code extension (Opus 4.7)
• #49902 — thinking summaries not rendered (VS Code extension 2.1.112)
• #48065 — thinking summaries not displayed when showThinkingSummaries enabled
• #49739 — toggle button inverted, no visual feedback (v2.1.112), likely a related UI-state bug
• #30958 — earlier transcript/TUI variant of the same regression (v2.1.69)
• #51131 — extended thinking dropdown no longer expandable in VS Code extension (Opus 4.7)
• #33163 — "Bring back thinking" feature request, same underlying ask

What would actually resolve this:

1. Pass display: "summarized" by default for Opus 4.7+ when showThinkingSummaries and alwaysThinkingEnabled are on. Or expose a first-class thinkingDisplay setting alongside the existing thinkingEnabled and effortLevel.
2. Restore the expandable thinking block in the VS Code extension chat panel so showThinkingSummaries actually shows summaries when the data is present.
3. Update the docs so they reflect current showThinkingSummaries semantics on Opus 4.7+ instead of describing behavior that no longer applies.

this is still broken on 2.1.132 and is significantly impacting my workflow.

The thinking display is critical for me because:

• I rely on visible reasoning to catch alignment issues and verify the model's chain of thought
• The workaround (downgrading to claude-opus-4-6 in settings.json) appears to also break the 1M context window — context fills up at ~200K, suggesting the model-picker bug also affects context window mapping
• Rolling back to 2.1.109 forces me to give up Opus 4.7 entirely

This issue has been open for 3+ weeks and looks like a missing branch in the model-picker logic. Could we get a status update on the fix timeline? Even a temporary toggle (e.g. "forceShowThinking": true in settings.json) would unblock affected users while a proper fix is in progress.

Affected: VS Code extension 2.1.112 through 2.1.132, Opus 4.7 model.

@bedcoding you probably need to set the model to claude-opus-4-6[1m] to get the 1m token context window. But I suggest you first try the process wrapper workaround described here https://github.com/anthropics/claude-code/issues/49322#issuecomment-4323290907 and here https://github.com/anthropics/claude-code/issues/49322#issuecomment-4265369864 and elsewhere in this thread.

the --thinking-display summarized wrapper from this thread worked on Opus (1M context too) for weeks. broke around may 10 completely for me.

Pretty sure it's a feature now, not a bug🤓

good for them, my feature could be canceling the subscription

@ironashram can you elaborate what's not working about it? it seems to still be working for me

<img width="391" height="68" alt="Image" src="https://github.com/user-attachments/assets/955ed2d5-c2e9-4f2a-8794-b807dc42df14" />

Basically it is no longer possible to expand the "Thought for X" and see the summarized details, no matter what.
And digging a bit it seems the models are no longer returning the summary so nothing can be done on client/extension side, or at least that's my conclusion.

the original fix is working for me too, though I haven't upgraded the CLI in a few weeks, kinda scared to do it.

<img alt="Image" width="391" height="68" src="https://private-user-images.githubusercontent.com/8753502/590643798-955ed2d5-c2e9-4f2a-8794-b807dc42df14.png?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3Nzg2NDYyMzMsIm5iZiI6MTc3ODY0NTkzMywicGF0aCI6Ii84NzUzNTAyLzU5MDY0Mzc5OC05NTVlZDJkNS1jMmU5LTRmMmEtODc5NC1iODA3ZGM0MmRmMTQucG5nP1gtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LUNyZWRlbnRpYWw9QUtJQVZDT0RZTFNBNTNQUUs0WkElMkYyMDI2MDUxMyUyRnVzLWVhc3QtMSUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LURhdGU9MjAyNjA1MTNUMDQxODUzWiZYLUFtei1FeHBpcmVzPTMwMCZYLUFtei1TaWduYXR1cmU9NmI3OTc2NGU3OTUzY2ExNzA0OTJmMjljNzQ3ODYxZjBmZjZjY2ZkNTA3N2U4OGQ4YjI5NTE2MTRlOGU4NTk3YiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmcmVzcG9uc2UtY29udGVudC10eXBlPWltYWdlJTJGcG5nIn0.QhC82LXc0NGs5uypUeoGDYvpFvj37kHkUHT7J_jHuOc"> Basically it is no longer possible to expand the "Thought for X" and see the summarized details, no matter what. And digging a bit it seems the models are no longer returning the summary so nothing can be done on client/extension side, or at least that's my conclusion.

When it shows that, wait for it to finish, then toggle it to the left and send a message; it will show it again.

> <img alt="Image" width="391" height="68" src="https://private-user-images.githubusercontent.com/8753502/590643798-955ed2d5-c2e9-4f2a-8794-b807dc42df14.png?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3Nzg2NDYyMzMsIm5iZiI6MTc3ODY0NTkzMywicGF0aCI6Ii84NzUzNTAyLzU5MDY0Mzc5OC05NTVlZDJkNS1jMmU5LTRmMmEtODc5NC1iODA3ZGM0MmRmMTQucG5nP1gtQW16LUFsZ29yaXRobT1BV1M0LUhNQUMtU0hBMjU2JlgtQW16LUNyZWRlbnRpYWw9QUtJQVZDT0RZTFNBNTNQUUs0WkElMkYyMDI2MDUxMyUyRnVzLWVhc3QtMSUyRnMzJTJGYXdzNF9yZXF1ZXN0JlgtQW16LURhdGU9MjAyNjA1MTNUMDQxODUzWiZYLUFtei1FeHBpcmVzPTMwMCZYLUFtei1TaWduYXR1cmU9NmI3OTc2NGU3OTUzY2ExNzA0OTJmMjljNzQ3ODYxZjBmZjZjY2ZkNTA3N2U4OGQ4YjI5NTE2MTRlOGU4NTk3YiZYLUFtei1TaWduZWRIZWFkZXJzPWhvc3QmcmVzcG9uc2UtY29udGVudC10eXBlPWltYWdlJTJGcG5nIn0.QhC82LXc0NGs5uypUeoGDYvpFvj37kHkUHT7J_jHuOc"> > Basically it is no longer possible to expand the "Thought for X" and see the summarized details, no matter what. And digging a bit it seems the models are no longer returning the summary so nothing can be done on client/extension side, or at least that's my conclusion. When it shows that, wait for it to finish, then toggle it to the left and send a message; it will show it again.

not sure what you mean "toggle it to the left and send a message", anyway the response via api has empty thinking deltas, tested even with a local mitm proxy to see what was sent via api(opus 4.7 for example now defaults to "type: adaptive") and the response, so I doubt any client workaround can be applied.

this morning summaries are back without me changing anything, well, let's see how long it lasts

For me it's a UI/UX problem, try this in the VSC extension: move the thinking toggle to the right, send a message that makes Claude think, wait, you should see "thinking Xs" when Claude finishes, only when he finishes, write something else and before sending it, move the toggle to the left. The thinking block appears again for that session and until the compact.
I made the #49739 due to the poor visual feedback of the system

Filed #59844 with a one-line CLI fix (preferred) or one-line extension fix (alternative) that supersedes the wrapper-script and CLAUDE_CODE_EXTRA_BODY workarounds discussed in this thread.

Both proposals avoid the failure modes documented here:

• Unconditional exec "$@" --thinking-display summarized (the Gotcha2): not reproducible on 2.1.142. Helper subcommands (--version, doctor, mcp list, plugin list) all accept --thinking-display summarized in argv without crashing; likely fixed upstream between when the wrapper was written and current builds. The proposals don't rely on wrapper-script argv injection regardless.
• CLAUDE_CODE_EXTRA_BODY: breaks WebSearch and WebFetch per #56984, because it force-injects thinking.type: "adaptive" into every request including forced-tool-use and incompatible-model sub-calls. The proposed fixes set display only, never type, so the CLI's per-request gate continues to disable thinking correctly where needed.

Verified locally for both safety claims. Details + diffs in #59844.

Disclosure: written with Claude Opus 4.7.

Confirming this bug still reproduces on Claude Code VS Code extension 2.1.145, same shape as originally reported on 2.1.111. Did a quick code-archaeology pass on the current extension.js to verify before patching:

• showThinkingSummaries appears exactly once — and only inside the config schema (Zod-style). Five active-usage patterns (.showThinkingSummaries, thinkingDisplay, thinking.display, display: "summarized", thinking: { display) all return zero hits. So the setting is declared as valid but nothing reads it.
• The spawn-args builder still contains the same gated push the issue describes: --thinking-display is appended only when an internal local variable is set, and nothing sets it.

Confirmed schema-only declaration → bug is real on 2.1.145, not just 2.1.111.

Applied the "easier escape-hatch workaround" verbatim — the buggy pattern matches as-is, exactly once in the bundle:

- if(L.type!=="disabled"&&L.display)i.push("--thinking-display",L.display)
+ if(L.type!=="disabled")i.push("--thinking-display",L.display||"summarized")

Procedure: backed up extension.js next to the original, replaced the line (+3 bytes), confirmed node --check still parses, reloaded the VS Code window, and sent a non-trivial reasoning prompt on Opus 4.7. Thinking summaries are back in the chat panel.

Why the one-liner is sufficient: it forces the IDE to always send --thinking-display summarized to the CLI when thinking is enabled. The CLI then branches on the explicit flag, bypassing the buggy non-interactive-mode gate entirely — no CLI-side patch required.

"showThinkingSummaries": true in settings.json is no longer strictly required after this patch (the IDE passes the flag unconditionally), but I'd keep it as defense-in-depth in case Anthropic ships a partial schema-side fix later.

Caveat: VS Code installs each extension update in a new directory with a fresh unpatched extension.js, so the patch needs reapplying after every auto-update until this lands upstream. The pattern check grep -c on the original buggy line is a useful gate — if it returns 0, the official fix probably shipped.

_Disclosure: written with Claude Opus 4.7, running Claude Code extension 2.1.145 on VS Code 1.114.0 — and seeing the thinking summaries this comment was drafted with._

welp for Opus 4.8 the CLI argument workaround doesn't work anymore for me, sad again.

EDIT (May 31st): after a few miserable days, I now see the summaries with 4.8, haven't updated the binary or changed anything. Hoping it sticks 😢

Confirming the claudeProcessWrapper + --thinking-display summarized workaround works on macOS, VS Code extension 2.1.160, Opus 4.8 (1M), first-party Max — validated end-to-end (thinking summaries render in the panel AND WebSearch/WebFetch still work in the same session).

Used @shawnz's parameter-order form (flag before the positional args) verbatim:

exec "$1" --thinking-display summarized "${@:2}"

--version and the other helper subcommands run clean with it on 2.1.160, consistent with @ojura's note that the old end-of-args crash is no longer reproducible. I removed CLAUDE_CODE_EXTRA_BODY entirely: per @vinozganic it injects thinking into every request including forced-tool_choice server-tool calls, which 400s WebSearch/WebFetch. The flag sets only display, so the harness's per-request gate still disables thinking where tools force it (@ojura, #59844).

Thanks @thatChadM (wrapper recipe), @shawnz (param-order fix), and @ojura (#59844 display-only safety) — restored visible thinking without sacrificing tools. +1 to fixing it in the extension itself; tracking #59844.

Updating my earlier follow-up with current findings.

A recent extension update (see "Notes" below) changed how the CLI is launched, so some of what I posted before is now out of date.

Root cause (confirmed: native-binary installer 2.1.169 + VS Code extension 2.1.169; Ubuntu 24.04, Windows 11 64-bit):

On 4.7/4.8 the API defaults thinking.display to omitted, so unless the client sends thinking: {type: "...", display: "summarized"}, the thinking block comes back empty. In the CLI binary:

if (z.thinkingDisplay==="summarized" || z.thinkingDisplay==="omitted") pz.display=z.thinkingDisplay; // --thinking-display flag (ungated)
else if (!p6() && EK8()) pz.display="summarized"; // p6()===!isInteractive, EK8()===showThinkingSummaries

Two ways to set display:

The --thinking-display flag (always honored), or showThinkingSummaries (honored only when interactive). VS Code and headless -p/SDK run non-interactively (--input-format stream-json), so the setting branch never fires. The extension forwards --thinking-display only when its own config already has display set, which it never maps from showThinkingSummaries ("summarized" appears 0x in extension.js). The x6 = R8 ? _.display ?? void 0 : void 0 line is the same gap in the npm cli.js. The ungated lever is the --thinking-display summarized flag.

Notes:

One of the 2.1.16x updates changed two things on the VS Code path: (1) it signals a real run with --max-thinking-tokens <N>, not --thinking adaptive (adaptive is still used for adaptive mode / SDK / older builds; headless still uses -p); (2) the official claudeCode.claudeProcessWrapper setting uses a process-wrapper convention, launching <wrapper> <REAL_CLAUDE_PATH> <args...>, so a wrapper must consume that leading path. Also the minified array variable was renamed (B -> q in 2.1.169), so a fixed find/replace stops matching after an update.

Workarounds:

1. Custom launcher, recommended (shell script on Linux; small Node script compiled to a standalone .exe on Windows)
2. One-line extension.js patch with a script that handles the variable rename.
3. Local proxy approach, not yet tested.

Created a small repo that includes the current launchers, patch script, CC_THINKING_DISPLAY=omitted toggle, the safe-undo caveat, and environment details:

https://github.com/phase3dev/claude-code-workarounds

So, is this a bug or a feature they no longer want to support?

Thinking is hidden because the showThinkingSummaries setting defaults to off. Turn it on by doing the following:

1. Open ~/.claude/settings.json (the same config the CLI uses)
2. Add the showThinkingSummaries key to the existing JSON object (merge it in, don't overwrite your other settings.)

   {
     "showThinkingSummaries": true,
   }

1. Reload the VS Code window. This step is required since the extension caches settings at session start, so editing the file mid session has no effect. Reopening the file or starting a new chat in the same window is not enough.

Notes

• Tested using Opus 4.8 in VS Code 1.126.0 (Universal)
• Make sure alwaysThinkingEnabled is not set to false. That disables thinking entirely.
• Summaries only render when the model actually does extended thinking. Prompt Claude to think for N seconds in order to test the fix.

i was a bit confused by your comment @chrisalmeida, because the whole crux of this issue is that showThinkingSummaries did NOT previously set the thinking display flag.

but it turns out, since VS code extension version 2.1.176, released a couple weeks ago on 2026-06-12, the extension actually DOES now check for the presence of showThinkingSummaries in your ~/.claude/settings.json and automatically starts the claude process with --thinking-display summarized in that case.

so the workarounds like the claudeProcessWrapper or the CLAUDE_CODE_EXTRA_BODY change are no longer necessary! this now works exactly like how OP is asking for, since version 2.1.176! this issue is now effectively fixed 🙏

This bug appears again for Version 2.1.205

@canyuchen
Yes, but only for some users it appears. See my issue filed here:

https://github.com/anthropics/claude-code/issues/75607

I wish Anthropic would stop doing things like this to its users.

Thanks! @phase3dev