mark blocked refs in message mode

Author: Tarquinen

lib/compress/message-utils.ts

@@ -1,6 +1,7 @@
+import type { PluginConfig } from "../config"
 import type { SessionState } from "../state"
 import { parseBoundaryId } from "../message-ids"
-import { isIgnoredUserMessage } from "../messages/utils"
+import { isIgnoredUserMessage, isProtectedUserMessage } from "../messages/utils"
 import { resolveAnchorMessageId, resolveBoundaryIds, resolveSelection } from "./search"
 import { COMPRESSED_BLOCK_HEADER } from "./state"
 import type {
@@ -66,6 +67,7 @@ export function resolveMessages(
     args: CompressMessageToolArgs,
     searchContext: SearchContext,
     state: SessionState,
+    config: PluginConfig,
 ): ResolvedMessageCompressionsResult {
     const issues: string[] = []
     const plans: ResolvedMessageCompression[] = []
@@ -88,6 +90,7 @@ export function resolveMessages(
                 },
                 searchContext,
                 state,
+                config,
             )
             seenMessageIds.add(plan.entry.messageId)
             plans.push(plan)
@@ -111,7 +114,14 @@ function resolveMessage(
     entry: CompressMessageEntry,
     searchContext: SearchContext,
     state: SessionState,
+    config: PluginConfig,
 ): ResolvedMessageCompression {
+    if (entry.messageId.toUpperCase() === "BLOCKED") {
+        throw new SoftIssue(
+            "messageId BLOCKED refers to a protected message and cannot be compressed.",
+        )
+    }
+
     const parsed = parseBoundaryId(entry.messageId)
 
     if (!parsed) {
@@ -122,7 +132,7 @@ function resolveMessage(
 
     if (parsed.kind === "compressed-block") {
         throw new SoftIssue(
-            `messageId ${entry.messageId} is invalid in message mode. Block IDs like bN are not allowed; use an mNNNN message ID instead.`,
+            `messageId ${entry.messageId} is invalid here. Block IDs like bN are not allowed; use an mNNNN message ID instead.`,
         )
     }
 
@@ -157,6 +167,12 @@ function resolveMessage(
         throw new Error(`messageId ${parsed.ref} is not available in the current conversation.`)
     }
 
+    if (isProtectedUserMessage(config, message)) {
+        throw new SoftIssue(
+            `messageId ${parsed.ref} refers to a protected message and cannot be compressed.`,
+        )
+    }
+
     const pruneEntry = state.prune.messages.byMessageId.get(rawMessageId)
     if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
         throw new Error(`messageId ${parsed.ref} is already part of an active compression.`)

lib/compress/message.ts

@@ -54,7 +54,12 @@ export function createCompressMessageTool(ctx: ToolContext): ReturnType<typeof t
                 toolCtx,
                 `Compress Message: ${input.topic}`,
             )
-            const { plans, skippedIssues } = resolveMessages(input, searchContext, ctx.state)
+            const { plans, skippedIssues } = resolveMessages(
+                input,
+                searchContext,
+                ctx.state,
+                ctx.config,
+            )
 
             if (plans.length === 0 && skippedIssues.length > 0) {
                 throw new Error(formatIssues(skippedIssues))

lib/messages/inject/inject.ts

@@ -12,6 +12,7 @@ import {
     createSyntheticTextPart,
     findLastToolPart,
     isIgnoredUserMessage,
+    isProtectedUserMessage,
 } from "../utils"
 import {
     addAnchor,
@@ -157,11 +158,15 @@ export const injectMessageIds = (
             continue
         }
 
+        const isBlockedMessage = isProtectedUserMessage(config, message)
         const priority =
-            config.compress.mode === "message"
+            config.compress.mode === "message" && !isBlockedMessage
                 ? compressionPriorities?.get(message.info.id)?.priority
                 : undefined
-        const tag = formatMessageIdTag(messageRef, priority ? { priority } : undefined)
+        const tag = formatMessageIdTag(
+            isBlockedMessage ? "BLOCKED" : messageRef,
+            priority ? { priority } : undefined,
+        )
 
         if (appendToTextPart(message, tag)) {
             continue

lib/messages/priority.ts

@@ -2,7 +2,7 @@ import type { PluginConfig } from "../config"
 import { countAllMessageTokens } from "../strategies/utils"
 import { isMessageCompacted } from "../shared-utils"
 import type { SessionState, WithParts } from "../state"
-import { isIgnoredUserMessage } from "./utils"
+import { isIgnoredUserMessage, isProtectedUserMessage } from "./utils"
 
 const MEDIUM_PRIORITY_MIN_TOKENS = 500
 const HIGH_PRIORITY_MIN_TOKENS = 5000
@@ -32,6 +32,10 @@ export function buildPriorityMap(
             continue
         }
 
+        if (isProtectedUserMessage(config, message)) {
+            continue
+        }
+
         if (isMessageCompacted(state, message)) {
             continue
         }

lib/messages/prune.ts

@@ -2,7 +2,7 @@ import type { SessionState, WithParts } from "../state"
 import type { Logger } from "../logger"
 import type { PluginConfig } from "../config"
 import { isMessageCompacted, getLastUserMessage } from "../shared-utils"
-import { createSyntheticUserMessage } from "./utils"
+import { createSyntheticUserMessage, replaceBlockIdsWithBlocked } from "./utils"
 import type { UserMessage } from "@opencode-ai/sdk/v2"
 
 const PRUNED_TOOL_OUTPUT_REPLACEMENT =
@@ -16,7 +16,7 @@ export const prune = (
     config: PluginConfig,
     messages: WithParts[],
 ): void => {
-    filterCompressedRanges(state, logger, messages)
+    filterCompressedRanges(state, logger, config, messages)
     // pruneFullTool(state, logger, messages)
     pruneToolOutputs(state, logger, messages)
     pruneToolInputs(state, logger, messages)
@@ -158,6 +158,7 @@ const pruneToolErrors = (state: SessionState, logger: Logger, messages: WithPart
 const filterCompressedRanges = (
     state: SessionState,
     logger: Logger,
+    config: PluginConfig,
     messages: WithParts[],
 ): void => {
     if (
@@ -194,7 +195,10 @@ const filterCompressedRanges = (
 
                 if (userMessage) {
                     const userInfo = userMessage.info as UserMessage
-                    const summaryContent = rawSummaryContent
+                    const summaryContent =
+                        config.compress.mode === "message"
+                            ? replaceBlockIdsWithBlocked(rawSummaryContent)
+                            : rawSummaryContent
                     const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`
                     result.push(
                         createSyntheticUserMessage(

lib/messages/utils.ts

@@ -1,10 +1,13 @@
 import { createHash } from "node:crypto"
+import type { PluginConfig } from "../config"
 import { isMessageCompacted } from "../shared-utils"
 import type { SessionState, WithParts } from "../state"
 import type { UserMessage } from "@opencode-ai/sdk/v2"
 
 const SUMMARY_ID_HASH_LENGTH = 16
-const DCP_MESSAGE_ID_TAG_REGEX = /<dcp-message-id(?=[\s>])[^>]*>(?:m\d+|b\d+)<\/dcp-message-id>/g
+const DCP_MESSAGE_ID_TAG_REGEX =
+    /<dcp-message-id(?=[\s>])[^>]*>(?:m\d+|b\d+|BLOCKED)<\/dcp-message-id>/g
+const DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/dcp-message-id>)/g
 const DCP_SYSTEM_REMINDER_REGEX =
     /<dcp-system-reminder(?=[\s>])[^>]*>[\s\S]*?<\/dcp-system-reminder>/g
 
@@ -157,6 +160,19 @@ export const isIgnoredUserMessage = (message: WithParts): boolean => {
     return true
 }
 
+export function isProtectedUserMessage(config: PluginConfig, message: WithParts): boolean {
+    return (
+        config.compress.mode === "message" &&
+        config.compress.protectUserMessages &&
+        message.info.role === "user" &&
+        !isIgnoredUserMessage(message)
+    )
+}
+
+export const replaceBlockIdsWithBlocked = (text: string): string => {
+    return text.replace(DCP_BLOCK_ID_TAG_REGEX, "$1BLOCKED$2")
+}
+
 export const stripHallucinationsFromString = (text: string): string => {
     return text.replace(DCP_SYSTEM_REMINDER_REGEX, "").replace(DCP_MESSAGE_ID_TAG_REGEX, "")
 }

lib/prompts/compress-message.ts

@@ -18,6 +18,7 @@ Each message has an ID inside XML metadata tags like \`<dcp-message-id priority=
 The ID tag appears at the end of the message it belongs to — it identifies the message above it, not the one below it.
 Treat these tags as message metadata only, not as content to summarize. Use only the inner \`mNNNN\` value as the \`messageId\`.
 The \`priority\` attribute indicates relative context cost. Prefer higher-priority closed messages before lower-priority ones.
+Messages marked as \`<dcp-message-id>BLOCKED</dcp-message-id>\` cannot be compressed.
 
 Rules:
 

tests/compress-message.test.ts

@@ -332,6 +332,68 @@ test("compress message mode rejects compressed block ids", async () => {
     )
 })
 
+test("compress message mode skips protected user message references", async () => {
+    const sessionID = `ses_message_compress_protected_user_${Date.now()}`
+    const rawMessages = buildMessages(sessionID)
+    const state = createSessionState()
+    const logger = new Logger(false)
+    const config = buildConfig()
+    config.compress.protectUserMessages = true
+
+    const tool = createCompressMessageTool({
+        client: {
+            session: {
+                messages: async () => ({ data: rawMessages }),
+                get: async () => ({ data: { parentID: null } }),
+            },
+        },
+        state,
+        logger,
+        config,
+        prompts: {
+            reload() {},
+            getRuntimePrompts() {
+                return { compressMessage: "", compressRange: "" }
+            },
+        },
+    } as any)
+
+    const result = await tool.execute(
+        {
+            topic: "Protected user entries",
+            content: [
+                {
+                    messageId: "BLOCKED",
+                    topic: "Protected marker",
+                    summary: "Should be skipped.",
+                },
+                {
+                    messageId: "m0001",
+                    topic: "Hidden protected ref",
+                    summary: "Should also be skipped.",
+                },
+                {
+                    messageId: "m0002",
+                    topic: "Valid note",
+                    summary: "Captured the assistant's code-path findings.",
+                },
+            ],
+        },
+        {
+            ask: async () => {},
+            metadata: () => {},
+            sessionID,
+            messageID: "msg-compress-message-protected-user",
+        },
+    )
+
+    assert.equal(state.prune.messages.blocksById.size, 1)
+    assert.match(result, /^Compressed 1 message into \[Compressed conversation section\]\./)
+    assert.match(result, /Skipped 2 issues:/)
+    assert.match(result, /messageId BLOCKED refers to a protected message/)
+    assert.match(result, /messageId m0001 refers to a protected message/)
+})
+
 test("compress message mode allows messages containing compress tool parts", async () => {
     const sessionID = `ses_message_compress_tool_${Date.now()}`
     const rawMessages = buildMessages(sessionID)