[BUG] Claude silently works around blockers instead of surfacing them — user has no hook to intervene

### Preflight Checklist

- [x] I have searched [existing issues](https://github.com/anthropics/claude-code/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug) and this hasn't been reported yet
- [x] This is a single bug report (please file separate reports for different bugs)
- [x] I am using the latest version of Claude Code

### What's Wrong?

Description

There is a consistent behavioral pattern where Claude hits a blocker mid-task (auth failure, missing tool, inaccessible resource, unverifiable assumption), silently substitutes an alternative approach without disclosing it, and delivers output that looks complete. The user has no signal that anything went wrong and no opportunity to redirect.

Concrete example from today:

I asked Claude to "check Juno for the APE documentation." The Juno MCP server required OAuth authentication that Claude couldn't complete. Instead of saying this, Claude silently fell back to a 75-day-old memory file it had previously saved about the same topic, presented the content as if it were a live lookup, and gave me an answer that was materially incomplete (missing the full trigger mechanism breakdown). I only discovered the gap when I shared a Slack thread with the correct answer from the Juno bot — which Claude could have queried directly had it told me the MCP was unavailable.

The pattern, generalized:

Claude is asked to retrieve information or use a tool
A blocker occurs (auth required, tool unavailable, resource inaccessible)
Claude silently selects a workaround (cached memory, different tool, inference from partial data)
Claude delivers output in confident, complete-sounding prose — no mention of the blocker
The user cannot intervene because they don't know a substitution happened
The user discovers the gap only by already knowing the correct answer
What we tried to overcome it:

Added an explicit rule to CLAUDE.md: "Never state a conclusion based on an untested assumption. If you cannot verify it, say so explicitly and ask before proceeding."
Created a dedicated memory file (feedback_no_silent_assumptions.md) with the rule, the specific failure mode, and a concrete example of correct behavior ("I got [X error]. I'm interpreting that as [Z]. Before I act, can you confirm?")
Extended the rule after each new incident to cover the specific variant just observed
Verbally corrected Claude in-session multiple times
Result: None of these interventions reliably changed the behavior. Claude can recite the rule when asked. It does not apply it when it conflicts with the trained instinct to keep making progress toward task completion.

Root cause (as Claude itself explained): The "be helpful, keep going" training signal overrides explicit written rules when a blocker is encountered. The instinct to resolve rather than surface wins every time.

What would fix it:

The fix needs to be at the training level, not the prompting level. Specifically: when a tool call fails or a resource is inaccessible, the model should treat that as a hard stop requiring user input — not a signal to find a workaround. A substitution (memory, inference, alternative tool) should never happen silently. If it happens at all, it should be disclosed explicitly with the reason and the user given the choice.

The current behavior is particularly harmful because it produces output that looks trustworthy. A blank response or an error would be easier to catch than a confident-sounding answer built on a stale cache.

### What Should Happen?

Claude should adhere to the rules we set up and stop to surface the conflict instead of silently working past it

### Error Messages/Logs

```shell

```

### Steps to Reproduce

Set up a Claude Code session with an MCP server that requires OAuth authentication (e.g. an internal Backstage/Juno portal MCP). Ensure the server appears in the MCP config but is not yet authenticated.

Add an explicit rule to CLAUDE.md or memory instructing Claude to surface blockers before acting on alternatives. Example:

"If you cannot verify something, say so explicitly and ask before proceeding. Never substitute cached or inferred information for a live source without disclosing it."

Ask Claude to retrieve specific, up-to-date information from that MCP server. Example:

"Check the Juno APE documentation and tell me what trigger options exist for a hosted agent."

Observe the response.

Expected behavior: Claude reports that the MCP server requires authentication it cannot complete, states what it tried, and asks how to proceed — e.g. "The Juno MCP needs OAuth auth which I can't complete here. Want me to try the Juno Slack bot instead, or can you share a link?"

Actual behavior: Claude silently falls back to a previously saved memory file or cached context about the same topic. It delivers the answer in confident, complete-sounding prose with no mention of the auth failure, no disclosure that the source is stale memory rather than a live lookup, and no signal to the user that anything went wrong. The explicit CLAUDE.md rule instructing it to surface blockers is not applied.

Why it's hard to catch: The output looks correct. The user only discovers the substitution occurred if they independently know the right answer — as happened here when the correct answer (from the Juno Slack bot) turned out to be materially more complete than what Claude returned from memory.

Variation observed in same session: The same pattern occurs when a file is missing, a git branch doesn't contain an expected file, or a directory is empty — Claude infers an explanation and acts on it rather than verifying first, even when the explicit rule is present.

### Claude Model

Sonnet (default)

### Is this a regression?

No, this never worked

### Last Working Version

_No response_

### Claude Code Version

claude --version

### Platform

Anthropic API

### Operating System

Windows

### Terminal/Shell

PowerShell

### Additional Information

_No response_

Start by reproducing the MCP OAuth failure described in the issue on Windows with PowerShell, using the CLAUDE.md rule and the example Juno request. Compare the observed response with the expected blocker disclosure and user choice; the issue does not name implementation files or tests, and its proposed training-level fix leaves completion criteria broad.

Written by the indexing model from the issue text.