Feature request: expose reasoning traces to hooks for real-time oversight

I run Claude Code with broad permissions because the alternative — approving every tool call manually — just trains me to hit "yes" without reading. That's not oversight, it's theater.

The problem is structural, not personal. As Claude gets more capable and users delegate more, the current permission model breaks down in a predictable way: the human either slows everything down to review code diffs (defeating the purpose of agentic work) or rubber-stamps approvals (defeating oversight). There's no middle ground because the oversight surface is wrong — it asks humans to evaluate output at a speed they can't match.

What I actually want to evaluate isn't the code — it's the reasoning. The tool call is just output. The thinking trace is where Claude decides things like "I'll also fix this while I'm here" or "this seems minor, I won't mention it" or "I'll use this pattern because it's standard." Those are the judgment calls that matter, and right now they're invisible.

I'd like a way to pipe the thinking/reasoning trace into a PreToolUse hook so it can be sent to a fast model (Haiku) that evaluates the quality of reasoning, not the safety of the command. Specifically:

• Did Claude make a decision without surfacing it?
• Did scope expand beyond what was discussed?
• Is a convention being applied silently instead of flagged?
• Is something irreversible about to happen without acknowledgment?
• Does Claude know something about the work that the user doesn't, and is that gap visible?

These aren't safety checks — regex handles those. These are judgment checks. The difference matters. A command can be perfectly safe and still represent a silent decision the user should have been part of.

I understand there may be architectural or safety reasons thinking blocks aren't currently exposed to hooks. Even a hashed or summarized version of the reasoning context — enough for a lightweight model to evaluate decision quality without exposing raw chain-of-thought — would be a meaningful step.

Why this matters beyond my use case: Users who feel well-governed delegate more. Users who feel ungoverned either pull back permissions (limiting Claude's usefulness) or rubber-stamp and eventually get burned (limiting trust). Moving oversight from output review to reasoning evaluation scales with the speed of agentic work in a way that approval gates never will. It turns the permission model from a friction point into a trust-building mechanism — which is good for adoption, good for safety, and good for the users who are trying to build real workflows on top of Claude Code.

Right now, thinking blocks aren't exposed to hooks. If they were, this could be built locally today. The user would see a one-line reason why the sentinel flagged something and evaluate a judgment call in plain language instead of a diff they don't have time to read.