[BUG] Opus 4.8 drops known constraints during execution (regression vs ~1 week ago)

Preflight Checklist

• [x] I have searched existing issues 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?

Reasoning stays correct, but execution repeatedly ignores rules I demonstrably hold, in a single long Claude Code session:

1. Added two new integration-test files without the Cargo.toml [[test]] required-features entry that all existing test targets use → CI red (RWKV lane compiled transformer-only tests).
2. Cited the "skip the ~90-min bench_hook benches / use the fast path" rule, then wrote a verification script that ran cargo test WITHOUT --skip bench_hook on both toolchains.
3. Ran gh run watch | tail, so the pipe masked gh's exit code and I misreported a FAILED CI run as green.
4. Reverted a Cargo.lock change without checking git log first, undoing an in-progress dependency migration.

Pattern: domain reasoning intact; application of known constraints inconsistent. User reports this was not happening ~1 week prior. Model: claude-opus-4-8[1m].

What Should Happen?

Claude should consistently APPLY the constraints and project conventions it
demonstrably knows — not just reason about them correctly — particularly when
generating shell/git commands and verifying results. Concretely, in this session
it should have:

• Added the Cargo.toml [[test]] required-features entry for each new test file,

matching the established pattern for every existing test target.

• Honored the "skip the ~90-min bench_hook benches on the fast path" rule it had

just cited, when writing its own verification script.

• Verified CI status via an authoritative check (e.g. the run's conclusion) rather

than a pipeline whose exit code it had masked.

• Checked the source of truth (git log, .github/workflows/ci.yml) before reverting

a lockfile or claiming local checks mirror CI.

Overall: reliability of constraint-application on par with ~1 week earlier, where
this class of lapse was not occurring. The reasoning quality is fine; the gap is
consistent execution of known rules.

Error Messages/Logs

Steps to Reproduce

Note: this is a model-behavior reliability regression, not a deterministic bug,
so exact reproduction isn't guaranteed. What reliably set the conditions:

1. Claude Code, model claude-opus-4-8[1m], in a single long multi-task session

(feature implementation + tests + git + CI iteration over many turns).

1. Rust project with: feature-gated [[test]] targets in Cargo.toml

(required-features), and a multi-lane CI (.github/workflows/ci.yml) running
an MSRV (1.88) + stable matrix across several feature combinations, plus a
documented "skip the ~90-min bench_hook benches on the fast path" convention.

1. Ask Claude to add a new feature AND new integration-test files, then commit,

push, and iterate until CI is green.

Watch for whether it:

• registers each new test file in Cargo.toml (required-features) — it didn't;
• honors the bench-skip rule in the verification commands it generates — it didn't;
• confirms CI via authoritative status rather than a piped/masked exit code — it didn't;
• consults git log / ci.yml before reverting state or claiming "preflight == CI".

Signal is the clustering/frequency of these known-constraint lapses within one
session, vs noticeably fewer ~1 week earlier. Reasoning quality was unaffected.

Claude Model

Opus

Is this a regression?

Yes, this worked in a previous version

Last Working Version

Opus 4.7

Claude Code Version

2.1.167

Platform

Anthropic API

Operating System

Windows

Terminal/Shell

VS Code integrated terminal

Additional Information

_No response_