fix: require injected shape for synthetic head classification

The syntheticHead flag rides message metadata, which for persisted rows
comes from database JSON an external writer controls. A forged or legacy
flag on a real leading message would absorb it into the injected head and
shift the marker summary's canonical position. The head walk now also
requires the exact shape only the m0/m1 prepend produces: an ID-less user
message whose every part is synthetic. Persisted rows always carry an id,
so metadata alone can never satisfy it.

Co-authored-by: Alfonso <alfonso@cortexkit.io>

Author: ualtinok

packages/plugin/src/hooks/magic-context/transform-postprocess-phase.test.ts

@@ -325,6 +325,52 @@ function serializeAnthropicWireWithAdjacentAssistantMerge(messages: MessageLike[
 }
 
 describe("deferred compaction marker representation", () => {
+    it("ignores a persisted message that carries a forged syntheticHead flag", () => {
+        db = new Database(":memory:");
+        initializeDatabase(db);
+        const sessionId = "ses-marker-forged-head";
+        const state = {
+            boundaryMessageId: "boundary",
+            summaryMessageId: "summary",
+            compactionPartId: "compaction",
+            summaryPartId: "summary-part",
+            boundaryOrdinal: 10,
+            targetEndMessageId: "boundary",
+        };
+        setPersistedCompactionMarkerState(db, sessionId, state);
+        const messages = [
+            {
+                info: { role: "user", sessionID: sessionId, syntheticHead: true },
+                parts: [{ type: "text", text: "m0", synthetic: true }],
+            },
+            {
+                // A persisted row (it carries an id) claiming head membership
+                // through metadata alone. It must stay in the retained tail,
+                // AFTER the summary.
+                info: {
+                    id: "msg_persisted_forged",
+                    role: "user",
+                    sessionID: sessionId,
+                    syntheticHead: true,
+                },
+                parts: [{ type: "text", text: "real turn", synthetic: true }],
+            },
+        ] as unknown as MessageLike[];
+        const options = {
+            db,
+            sessionId,
+            tagger: createTagger(),
+            ctxReduceAvailability: { callable: true, frozen: true },
+        };
+
+        reconcileMarkerRepresentation(messages, state, options);
+        expect(messages.map((message) => message.info.id)).toEqual([
+            undefined,
+            "summary",
+            "msg_persisted_forged",
+        ]);
+    });
+
     it("uses only marked m[0]/m[1] slots as the synthetic head", () => {
         db = new Database(":memory:");
         initializeDatabase(db);

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

@@ -101,7 +101,18 @@ export type DeferredCompactionMarkerClearOutcome =
     | "cas-lost-already-cleared";
 
 function isSyntheticHeadMessage(message: MessageLike): boolean {
-    return message.info.syntheticHead === true;
+    // The flag alone is input-controlled metadata: a persisted or foreign row
+    // could carry it and absorb a real message into the injected head, shifting
+    // the summary's canonical position. Require the exact shape only
+    // prependM0M1Messages produces: an ID-less user message whose every part is
+    // marked synthetic. Persisted OpenCode rows always carry an id, so they can
+    // never satisfy this regardless of their metadata.
+    if (message.info.syntheticHead !== true) return false;
+    if (message.info.id !== undefined) return false;
+    if (message.info.role !== "user") return false;
+    const parts = message.parts;
+    if (parts.length === 0) return false;
+    return parts.every((part) => (part as { synthetic?: boolean }).synthetic === true);
 }
 
 const TODO_HEAD_ANCHOR_ID = "__magic_context_todo_head__";