fix: prevent cache busts from note nudge injection and sticky reminder clearing

- Note nudges now append to latest user message instead of depending on
  assistant nudge placements (which don't exist at low context usage)
- Sticky reminder clearing gated behind isCacheBustingPass so defer
  passes don't remove anchored reminder text from cached user messages
- Removed dead appendNudgeToLastAssistant (assistant-target footgun)
- Split sticky reminder test into defer (keeps) and execute (clears)

Author: ualtinok

src/hooks/magic-context/transform-nudge-cache.test.ts

@@ -491,14 +491,68 @@ describe("createTransform nudge cache handling", () => {
         });
     });
 
-    it("clears sticky turn reminder when messages contain a recent ctx_reduce call", async () => {
-        //#given
-        useTempDataHome("context-transform-sticky-suppress-by-message-");
-        const scheduler: Scheduler = { shouldExecute: mock(() => "defer" as const) };
+    it("keeps sticky turn reminder on cache-safe defer pass even when ctx_reduce is in recent messages", async () => {
+        //#given — scheduler defers, so this is a cache-safe pass
+        useTempDataHome("context-transform-sticky-keep-on-defer-");
         const db = openDatabase();
         const transform = createTransform({
             tagger: createTagger(),
-            scheduler,
+            scheduler: { shouldExecute: mock(() => "defer" as const) },
+            contextUsageMap: new Map<string, { usage: ContextUsage; updatedAt: number }>([
+                [
+                    "ses-1",
+                    { usage: { percentage: 41, inputTokens: 80_000 }, updatedAt: Date.now() },
+                ],
+            ]),
+            nudger: () => null,
+            db,
+            nudgePlacements: createNudgePlacementStore(db),
+            flushedSessions: new Set<string>(),
+            lastHeuristicsTurnId: new Map<string, string>(),
+            clearReasoningAge: 50,
+            protectedTags: 0,
+            autoDropToolAge: 1000,
+        });
+
+        setPersistedStickyTurnReminder(
+            db,
+            "ses-1",
+            '\n\n<instruction name="ctx_reduce_turn_cleanup">sticky reminder</instruction>',
+        );
+
+        const messages: TestMessage[] = [
+            {
+                info: { id: "m-user", role: "user", sessionID: "ses-1" },
+                parts: [{ type: "text", text: "user prompt" }],
+            },
+            {
+                info: { id: "m-assistant", role: "assistant" },
+                parts: [
+                    { type: "text", text: "assistant response" },
+                    {
+                        type: "tool-invocation" as "text",
+                        callID: "reduce-call" as unknown as undefined,
+                        toolName: "ctx_reduce",
+                    } as unknown as TestMessage["parts"][0],
+                ],
+            },
+        ];
+
+        //#when
+        await transform({}, { messages });
+
+        //#then — reminder stays in DB and keeps being reinjected (cache-safe: no removal)
+        expect(firstText(messages[0]!)).toContain("sticky reminder");
+        expect(getPersistedStickyTurnReminder(db, "ses-1")).not.toBeNull();
+    });
+
+    it("clears sticky turn reminder on cache-busting execute pass when ctx_reduce is in recent messages", async () => {
+        //#given — scheduler executes, so this pass already busts cache
+        useTempDataHome("context-transform-sticky-clear-on-execute-");
+        const db = openDatabase();
+        const transform = createTransform({
+            tagger: createTagger(),
+            scheduler: { shouldExecute: mock(() => "execute" as const) },
             contextUsageMap: new Map<string, { usage: ContextUsage; updatedAt: number }>([
                 [
                     "ses-1",
@@ -521,7 +575,6 @@ describe("createTransform nudge cache handling", () => {
             '\n\n<instruction name="ctx_reduce_turn_cleanup">sticky reminder</instruction>',
         );
 
-        // Messages include a ctx_reduce tool call — agent already reduced
         const messages: TestMessage[] = [
             {
                 info: { id: "m-user", role: "user", sessionID: "ses-1" },
@@ -543,7 +596,7 @@ describe("createTransform nudge cache handling", () => {
         //#when
         await transform({}, { messages });
 
-        //#then — reminder should be cleared from DB and NOT injected
+        //#then — reminder cleared from DB and NOT injected (cache already busting)
         expect(firstText(messages[0]!)).not.toContain("sticky reminder");
         expect(getPersistedStickyTurnReminder(db, "ses-1")).toBeNull();
     });

src/hooks/magic-context/transform-postprocess-phase.ts

@@ -19,10 +19,6 @@ import {
     renderCompartmentInjection,
 } from "./inject-compartments";
 import { getNoteNudgeText } from "./note-nudger";
-import {
-    appendSupplementalNudgeToAssistant,
-    canAppendSupplementalNudgeToAssistant,
-} from "./nudge-injection";
 import type { NudgePlacementStore } from "./nudge-placement-store";
 import type { ContextNudge } from "./nudger";
 import {
@@ -293,11 +289,15 @@ export function runPostTransformPhase(args: RunPostTransformPhaseArgs): void {
 
     const pendingUserTurnReminder = getPersistedStickyTurnReminder(args.db, args.sessionId);
     if (pendingUserTurnReminder) {
-        if (args.hasRecentReduceCall) {
+        // Only clear the reminder when the pass is already cache-busting (execute/flush).
+        // Clearing on a cache-safe pass would remove text from an anchored user message,
+        // changing cached content and busting the Anthropic prompt-cache prefix.
+        const isCacheBustingPass = isExplicitFlush || shouldApplyPendingOps || shouldRunHeuristics;
+        if (args.hasRecentReduceCall && isCacheBustingPass) {
             clearPersistedStickyTurnReminder(args.db, args.sessionId);
             sessionLog(
                 args.sessionId,
-                "sticky turn reminder cleared — ctx_reduce found in recent messages",
+                "sticky turn reminder cleared — ctx_reduce found in recent messages (cache-busting pass)",
             );
         } else {
             if (pendingUserTurnReminder.messageId) {
@@ -355,19 +355,10 @@ export function runPostTransformPhase(args: RunPostTransformPhaseArgs): void {
             args.nudgePlacements.clear(args.sessionId);
         }
 
-        const canInjectDeferredNoteNudge = canAppendSupplementalNudgeToAssistant(
-            args.messages,
-            args.nudgePlacements,
-            args.sessionId,
-        );
         const deferredNoteText = getNoteNudgeText(args.db, args.sessionId);
-        if (deferredNoteText && canInjectDeferredNoteNudge) {
-            appendSupplementalNudgeToAssistant(
-                args.messages,
-                `\n\n<instruction name="deferred_notes">${deferredNoteText}</instruction>`,
-                args.nudgePlacements,
-                args.sessionId,
-            );
+        if (deferredNoteText) {
+            const noteInstruction = `\n\n<instruction name="deferred_notes">${deferredNoteText}</instruction>`;
+            appendReminderToLatestUserMessage(args.messages, noteInstruction);
         }
     } else {
         args.nudgePlacements.clear(args.sessionId);