mason: harden marker reconciliation gates

Author: ualtinok

packages/plugin/src/hooks/magic-context/compaction-marker-manager.test.ts

@@ -136,11 +136,11 @@ function markerServeWire(
 ): string {
     const messages = [
         {
-            info: { role: "user", sessionID: sessionId },
+            info: { role: "user", sessionID: sessionId, syntheticHead: true },
             parts: [{ type: "text", text: "m0", synthetic: true }],
         },
         {
-            info: { role: "user", sessionID: sessionId },
+            info: { role: "user", sessionID: sessionId, syntheticHead: true },
             parts: [{ type: "text", text: "m1", synthetic: true }],
         },
         {
@@ -159,7 +159,7 @@ function markerServeWire(
         db,
         sessionId,
         tagger: createTagger(),
-        ctxReduceCallable: true,
+        ctxReduceAvailability: { callable: true, frozen: true },
     });
     return serializeAnthropicWireWithAdjacentAssistantMerge(messages);
 }

packages/plugin/src/hooks/magic-context/ctx-reduce-availability.test.ts

@@ -16,43 +16,43 @@ describe("ctx_reduce availability (spawn tools map)", () => {
         const verdict = resolveCtxReduceAvailabilityFromMessages("ses-allow", [
             userMsg({ "*": false, read: true, grep: true }),
         ]);
-        expect(verdict).toBe(false);
+        expect(verdict).toEqual({ callable: false, frozen: true });
     });
 
     it("resolves true when ctx_reduce is explicitly allowed", () => {
         clearCtxReduceAvailability("ses-explicit");
         const verdict = resolveCtxReduceAvailabilityFromMessages("ses-explicit", [
             userMsg({ "*": false, read: true, ctx_reduce: true }),
         ]);
-        expect(verdict).toBe(true);
+        expect(verdict).toEqual({ callable: true, frozen: true });
     });
 
     it("fails open for sessions without a tools map (normal sessions)", () => {
         clearCtxReduceAvailability("ses-plain");
         const verdict = resolveCtxReduceAvailabilityFromMessages("ses-plain", [userMsg()]);
-        expect(verdict).toBe(true);
+        expect(verdict).toEqual({ callable: true, frozen: true });
     });
 
     it("resolves false when ctx_reduce is explicitly denied", () => {
         clearCtxReduceAvailability("ses-deny");
         const verdict = resolveCtxReduceAvailabilityFromMessages("ses-deny", [
             userMsg({ ctx_reduce: false }),
         ]);
-        expect(verdict).toBe(false);
+        expect(verdict).toEqual({ callable: false, frozen: true });
     });
 
     it("freezes the verdict per session — later, different tool maps cannot flap it", () => {
         clearCtxReduceAvailability("ses-frozen");
         const first = resolveCtxReduceAvailabilityFromMessages("ses-frozen", [
             userMsg({ "*": false, read: true }),
         ]);
-        expect(first).toBe(false);
+        expect(first).toEqual({ callable: false, frozen: true });
         // Same session, contradictory map on a later pass: cached verdict wins
         // (per-turn maps can differ; a flapping verdict would bust the cache).
         const second = resolveCtxReduceAvailabilityFromMessages("ses-frozen", [
             userMsg({ "*": false, ctx_reduce: true }),
         ]);
-        expect(second).toBe(false);
+        expect(second).toEqual({ callable: false, frozen: true });
     });
 
     it("ignores non-user messages and falls open when the first user message carries no signal", () => {
@@ -61,7 +61,7 @@ describe("ctx_reduce availability (spawn tools map)", () => {
             { info: { role: "assistant" } },
             userMsg({}),
         ]);
-        expect(verdict).toBe(true);
+        expect(verdict).toEqual({ callable: true, frozen: true });
     });
 
     it("does not freeze a fail-open verdict from an array with no user message", () => {
@@ -70,13 +70,13 @@ describe("ctx_reduce availability (spawn tools map)", () => {
         const provisional = resolveCtxReduceAvailabilityFromMessages("ses-no-user-yet", [
             { info: { role: "assistant" } },
         ]);
-        expect(provisional).toBe(true);
+        expect(provisional).toEqual({ callable: true, frozen: false });
         // ...but must NOT lock the session: the real first user message (a
         // deny-list spawn) still decides the frozen verdict.
         const final = resolveCtxReduceAvailabilityFromMessages("ses-no-user-yet", [
             { info: { role: "assistant" } },
             userMsg({ "*": false, read: true }),
         ]);
-        expect(final).toBe(false);
+        expect(final).toEqual({ callable: false, frozen: true });
     });
 });

packages/plugin/src/hooks/magic-context/ctx-reduce-availability.ts

@@ -41,23 +41,23 @@ function verdictFromToolsMap(tools: unknown): boolean | null {
 export function resolveCtxReduceAvailabilityFromMessages(
     sessionId: string,
     messages: ReadonlyArray<{ info?: { role?: string; tools?: unknown } }>,
-): boolean {
+): CtxReduceAvailabilityVerdict {
     const cached = availabilityBySession.get(sessionId);
-    if (cached !== undefined) return cached;
+    if (cached !== undefined) return { callable: cached, frozen: true };
 
     for (const message of messages) {
         if (message.info?.role !== "user") continue;
         // First user message decides: explicit signal, or no-signal → available.
         // Either way the verdict is final — freeze it.
         const verdict = verdictFromToolsMap(message.info.tools) ?? true;
         availabilityBySession.set(sessionId, verdict);
-        return verdict;
+        return { callable: verdict, frozen: true };
     }
     // No user message in the array at all (not a real prompt — e.g. a stray
     // pass on an empty session). Fail open but do NOT freeze: caching true here
     // would lock a deny-list session into the reduce surface before its first
     // user message ever arrives to say otherwise.
-    return true;
+    return { callable: true, frozen: false };
 }
 
 /** Availability verdict plus whether it is final for the session's lifetime. */

packages/plugin/src/hooks/magic-context/inject-compartments.ts

@@ -2258,18 +2258,21 @@ function prependM0M1Messages(
     m0Text: string,
     m1Text: string,
 ): void {
-    // `synthetic: true` marks these as injected context, not real user turns.
+    // `syntheticHead` identifies the injected m0 and m1 message positions for
+    // marker placement; `synthetic: true` marks their parts as injected context,
+    // not real user turns.
     // OpenCode's `toModelMessagesEffect` filters on `ignored` (NOT `synthetic`),
     // so the blocks STILL reach the model — but its title-generation gate
     // (`ensureTitle`) counts a message as a real user turn only when not every
     // part is synthetic, and skips titling unless exactly one real user message
-    // exists. Without this flag, m[0]+m[1] add two phantom user turns on the
-    // first message and permanently suppress the session's auto-title (issue
-    // #129). Must NOT use `ignored` here — that would strip the history
+    // exists. Without the part-level `synthetic` flag, m[0]+m[1] add two
+    // phantom user turns on the first message and permanently suppress the
+    // session's auto-title (issue #129). Must NOT use `ignored` here — that
+    // would strip the history
     // injection from the real model call.
     messages.unshift(
         {
-            info: { role: "user", sessionID: sessionId },
+            info: { role: "user", sessionID: sessionId, syntheticHead: true },
             parts: [
                 {
                     type: "text",
@@ -2279,7 +2282,7 @@ function prependM0M1Messages(
             ],
         },
         {
-            info: { role: "user", sessionID: sessionId },
+            info: { role: "user", sessionID: sessionId, syntheticHead: true },
             parts: [{ type: "text", text: m1Text, synthetic: true }],
         },
     );

packages/plugin/src/hooks/magic-context/tag-messages.ts

@@ -195,6 +195,8 @@ export type MessageInfo = {
     role?: string;
     sessionID?: string;
     summary?: boolean;
+    /** Marks one of the two m[0]/m[1] messages prepended by compartment injection. */
+    syntheticHead?: boolean;
     finish?: string;
     error?: unknown;
 };

packages/plugin/src/hooks/magic-context/transform-message-helpers.ts

@@ -142,6 +142,9 @@ function hasToolPartWithCallId(message: MessageLike, callId: string): boolean {
 }
 
 function isReplayableAssistantAnchor(message: MessageLike): boolean {
+    // A compaction summary is rebuilt by marker reconciliation, so anchoring a
+    // synthetic todo part there would lose it when the summary is replaced.
+    if (message.info.summary === true) return false;
     return message.info.error === undefined || message.info.error === null;
 }