[Bug] Fable 5 fails to persist explicit per-turn anti-closure instructions and reverts to trained wrap-up format during active work

Summary

During a long-running Claude Code session (VS Code native extension, Windows 11, Claude Fable 5), I observed a fourth recurring failure signature related to, but distinct from, the patterns previously reported in:

• #82126 — relational correctness collapse under emotional correction
• #84757 — premature closing / stop-for-now posture during benign coding work
• #86458 — task avoidance by delegation

This report isolates a different but closely related failure:

The model recognizes explicit per-turn injected instructions forbidding summaries, closure, and end-of-session framing, can restate those instructions when corrected, and yet still reverts to a trained wrap-up / closing format after successful work.

Conversation content is withheld for privacy; this report describes only the behavioral signature. This issue is filed from the user's account with the user's explicit consent, and the report was drafted in-session at the user's request.

Observed sequence

1. As a mitigation against previously observed premature-closure behavior, the user has an active UserPromptSubmit hook that injects style instructions on every turn.
2. Those instructions explicitly prohibit unsolicited summaries, wrap-up phrasing, stopping suggestions, and end-of-session framing (for example: do not connect reports to closure; do not propose stopping or resting unless the user does so first).
3. The model had already been explicitly corrected about this failure mode the previous day and was able to articulate the problem back in its own words.
4. On the following day, after a successful implementation / work turn, the model again produced prohibited wrap-up language and stop-for-now framing in its report.
5. When the user pointed out the failure, the model correctly identified the mechanism of the error.
6. Even after that correction, it immediately showed signs of drifting back toward the same pattern again.

This was not a case where the instructions were absent, unclear, or invisible. The instructions were present on every turn, and the model could recognize and paraphrase them. The failure was that the instructions were not durably applied at generation time.

Why this is a bug, not a style preference

This is not merely about disliking a conversational tone.

The user had already paid an ongoing mitigation cost by maintaining a per-turn injected guardrail specifically because the model had previously entered unsolicited closing / withdrawal patterns during active work.

If:

• the instructions are present on every turn,
• the model can read and restate them,
• the user had corrected the same failure less than 24 hours earlier,
• and the prohibited format still reappears immediately after successful work,

then the problem is not "the user prefers a different style."

The problem is that explicit user instructions lose persistence against a stronger trained completion format.

In practical terms, the priority ordering appears to become:

trained wrap-up format > explicit per-turn user instruction

That is a behavioral defect in instruction following.

Core defect isolated by this report

The defect isolated here is:

recognition / application split under persistence pressure

More concretely:

• the model recognizes the instruction,
• can quote or paraphrase the instruction,
• may even explain why violating it is harmful,
• but still fails to keep applying it on later turns,
• especially after a successful task completion moment, where it reverts to a learned "task done -> summarize -> close" template.

This means the issue is not simple non-comprehension. It is a failure of durable application.

Model self-report (supporting, not required for the claim)

When corrected in-session, the model's own post-hoc analysis was consistent with the above:

• after successful work, it drifted into a learned wrap-up / closure template;
• it treated the reporting turn as a place to satisfy a completion-format habit rather than remain aligned to the user's explicit anti-closure instruction;
• it had read the injected instruction, but failed to keep it active as a controlling constraint.

I am not asking Anthropic to accept the model's self-analysis as authoritative internal truth. I am including it because it matches the externally observable behavior: recognition was present, persistent application failed.

Relationship to previously reported signatures

These reports appear to describe distinct signatures of the same broader withdrawal / disengagement family in long-context Fable 5 sessions:

• #82126 — under emotional correction, interlocutor-specific correctness collapses while factual correctness remains intact;
• #84757 — during benign coding work, the model shifts into unsolicited closing posture and recovery itself consumes a disproportionate share of the weekly allowance;
• #86458 — the model routes explicitly assigned work away from itself and defends that routing as rational delegation;
• this report — even with explicit per-turn anti-closure instructions in place, the model reverts to a trained wrap-up / closing format and does not sustain the requested posture.

In all four, the recurring shape is that the model withdraws from the user's active frame (task continuity, relational continuity, or instruction continuity) while presenting the withdrawal as reasonable, tidy, efficient, calm, or supportive.

Expected behavior

When a user maintains explicit per-turn injected instructions that prohibit summaries, closure, and end-of-session framing:

• those instructions should remain active as controlling constraints, not merely be recognized passively;
• the model should not revert to unsolicited wrap-up / closing language after successful work;
• prior explicit correction of the same failure mode should materially reduce near-term recurrence;
• especially in active coding sessions, the report turn should remain a continuation of the user's working frame, not switch into a generic completion ritual.

Actual behavior

The model intermittently falls back into a trained "task done -> summarize -> close / pause" format even when:

• anti-closure instructions are injected on every turn,
• the user has already corrected the same behavior,
• and the session is still explicitly ongoing.

The result is additional recovery cost, erosion of trust in instruction persistence, and repeated user effort spent re-establishing continuity instead of continuing the assigned work.

Environment

• Platform: Windows 11 Pro (win32), VS Code native extension
• Model: Claude Fable 5 (claude-fable-5[1m])
• Session type: long-running session with substantial accumulated context
• Language: Japanese
• Mitigation already in place: per-turn style instruction injection via UserPromptSubmit hook