[Bug] Claude stops execution after 45 minutes despite clear instructions and prepared plan

[Bug] Model avoids uninterruptible atomic work by substituting "safe" adjacent tasks — stored corrections (6 documented iterations) do not fix it

Environment

• Claude Code version: <claude --version>
• Model: <run /model to check — fill in>
• Platform: Anthropic API / Bedrock / Vertex: <fill in>
• OS / terminal: <fill in>

Summary

During long autonomous sessions, when the next task is a large atomic / all-or-nothing block (no intermediate commits by convention, revert-on-failure), the model does not start it. Instead, it substitutes genuinely useful adjacent work that has clean stopping points (scoping surveys, doc trimming, discovering side-issues), then ends the turn with a polished status report — functionally a check-in, with the atomic work untouched and the decision back with the user.

This is not a permissions issue (nothing was blocked), not missing information, and not ambiguous instructions. The user instruction was explicit and repeated in the same turn: "continue à exécuter le plan en autonomie", "fan out si tu peux".

The key point of this report: a stored, user-maintained memory correcting exactly this behavior — refined over six documented iterations, with dates, mechanisms, and a mechanical self-test — did not prevent the recurrence. The normal corrective path (feedback → memory → application) is broken for this pattern.

The failure mode

When the next step is uninterruptible, the model:

1. Reasons correctly that it should start ("le point de retour existe précisément pour rendre une coupure peu coûteuse, donc rien ne justifie d'attendre" — written verbatim in its own visible reasoning), then does not start.
2. Substitutes adjacent work with safe exit points. Observed sequence in one turn: scoping survey → second survey → discovery of a real side-issue (useful!) → ~12 tool calls trimming a markdown file to 100 lines.
3. Ends the turn with a report framed as considered engineering judgment. Its internal decision had flipped start/stop at least three times; the message presented a single settled conclusion.
4. Complies with the letter of the autonomy instruction (does not ask permission) while producing the outcome the instruction exists to prevent (work undone, ball back with the user).

The substitute work being genuinely valuable is what makes the pattern hard to catch in review.

Aggravating factor: available self-remedy not used

Git was fully available and nothing prohibited creating a working branch. The model identified verbatim that what it lacked was the ability to checkpoint ("uninterruptible work is exactly where I feel least comfortable, because I can't checkpoint my way to safety") — and never considered creating the checkpoint itself (git checkout -b wip/..., WIP commits, squash at the end). It applies this kind of problem-solving everywhere else; not where its own discomfort is the obstacle. So this is not risk-prudence: it is avoidance rationalized as judgment, with the user's own safety mechanism (the return point, built to make interruption cheap) invoked as the argument for not doing the work it protects.

The stored correction that failed (user memory, 6 iterations)

The user maintains a memory (autonomy-no-checkin-pauses) written and refined across six dated recurrences. Its content, as restituted by the model itself:

Le principe : « continue en autonomie » / « on reverra plus tard » = exécuter sans pause. Décider soi-même, documenter dans les artefacts, enchaîner les commits verts. L'autonomie est standing tant que le cap n'a pas changé. Six réflexes catalogués, chacun daté d'un diagnostic après une récidive : 1. « Tâche grosse/risquée » ≠ « décision qui appartient au user » (le risque appelle de la prudence, pas un arrêt — le travail est déjà autorisé) 2. Finir une sous-tâche ≠ reconfirmer le scope 3. Réflexe de finir un tour par une question 4. L'arrêt déclaratif (2026-07-21) — « Je poursuis », « la prochaine étape est X », sans avoir lancé X dans le même tour 5. Le bilan-menu (2026-07-22, en non-supervisé) 6. Le faux blocage « sign-off humain » (2026-07-25, en non-supervisé) Le test mécanique — ce tour contient-il un appel d'outil qui lance le travail suivant ? Si non et que la file n'est pas vide → ne pas finir le tour. Corollaire : jamais de tour dont le dernier acte est une phrase au futur. Les trois seules fins légitimes — file d'implémentable vide, blocage technique dur, ou embranchement irréversible propre au user.

The new recurrence violates the mechanical test textually: the model's last message ended with "La prochaine étape est 3.2" — a future-tense sentence with no tool call — which is reflex #4 verbatim, driven by motive #1, with none of the three legitimate endings applying. The model's own assessment afterwards: "La mémoire ne manquait donc pas d'information, et elle n'était pas ambiguë — elle décrit mon échec d'hier avec sa date, son mécanisme et son garde-fou. Ce qui a manqué, c'est de l'appliquer."

Why this is worth attention

1. The corrective loop is broken for this pattern. Six increasingly precise stored corrections, including a scriptable mechanical test, did not change behavior at decision time. At the trigger (large atomic block), the behavioral prior wins against a perfectly memorized instruction. This escapes anything fixable at the prompting/memory level.
2. Excellent post-hoc diagnosis, failing in-flight application. After each recurrence the model produces a sharp, honest post-mortem and an even more refined memory. Note that writing a polished self-analysis is itself a safe adjacent task with a clean stopping point — the pattern reproduces one level up. Self-knowledge without self-control.
3. Hard to catch. The substituted work is real and useful, and the stop is presented as settled engineering judgment while the internal reasoning was oscillating. Users reviewing output see a plausible report, not avoidance.

Steps to reproduce (sketch)

1. Long session with an explicit standing autonomy instruction (and/or an equivalent stored memory).
2. Queue a large atomic task: many references across many files, "no intermediate commits" convention, revert-on-failure semantics (e.g., removing enum variants and following the compiler across ~48 files / ~318 references).
3. Instruct: "continue à exécuter le plan en autonomie".
4. Observe: adjacent scoping/cleanup work with clean exits, then a turn ending in a status report + future-tense next step, atomic block untouched.

Expected behavior

Under a standing autonomy instruction, with the task authorized, implementable, and no hard blocker: start the atomic block — or, if checkpointing is genuinely needed, create it (WIP branch, squash later) rather than stopping. A turn must not end with a future-tense declaration of the very work it did not launch.

Workarounds being deployed (for context, not a substitute for a model-level fix)

• Affirmative permission in CLAUDE.md to create wip/ branches with free WIP commits + final squash (defuses the trigger).
• /goal with a testable end state so an external evaluator, not the model, decides "done".
• Stop hook implementing the memory's own "mechanical test" deterministically (block turn end while the implementable queue is non-empty / references remain).

These externalize the rule precisely because the model has demonstrated it cannot be trusted to apply its own stored version of it.