compress: add message mode

Author: Tarquinen

lib/commands/manual.ts

@@ -21,14 +21,19 @@ const MANUAL_MODE_OFF = "Manual mode is now OFF."
 const COMPRESS_TRIGGER_PROMPT = [
     "<compress triggered manually>",
     "Manual mode trigger received. You must now use the compress tool.",
-    "Find the most significant completed section of the conversation that can be compressed into a high-fidelity technical summary.",
-    "Choose safe boundaries and preserve all critical implementation details.",
-    "Return after compress with a brief explanation of what range was compressed.",
+    "Find the most significant completed conversation content that can be compressed into a high-fidelity technical summary.",
+    "Follow the active compress mode, preserve all critical implementation details, and choose safe targets.",
+    "Return after compress with a brief explanation of what content was compressed.",
 ].join("\n\n")
 
-function getTriggerPrompt(tool: "compress", state: SessionState, userFocus?: string): string {
+function getTriggerPrompt(
+    tool: "compress",
+    state: SessionState,
+    config: PluginConfig,
+    userFocus?: string,
+): string {
     const base = COMPRESS_TRIGGER_PROMPT
-    const compressedBlockGuidance = buildCompressedBlockGuidance(state)
+    const compressedBlockGuidance = buildCompressedBlockGuidance(state, config)
 
     const sections = [base, compressedBlockGuidance]
     if (userFocus && userFocus.trim().length > 0) {
@@ -78,5 +83,5 @@ export async function handleManualTriggerCommand(
     tool: "compress",
     userFocus?: string,
 ): Promise<string | null> {
-    return getTriggerPrompt(tool, ctx.state, userFocus)
+    return getTriggerPrompt(tool, ctx.state, ctx.config, userFocus)
 }

lib/config.ts

@@ -5,13 +5,15 @@ import { parse } from "jsonc-parser"
 import type { PluginInput } from "@opencode-ai/plugin"
 
 type Permission = "ask" | "allow" | "deny"
+type CompressMode = "range" | "message"
 
 export interface Deduplication {
     enabled: boolean
     protectedTools: string[]
 }
 
-export interface CompressTool {
+export interface CompressConfig {
+    mode: CompressMode
     permission: Permission
     showCompression: boolean
     maxContextLimit: number | `${number}%`
@@ -66,15 +68,15 @@ export interface PluginConfig {
     turnProtection: TurnProtection
     experimental: ExperimentalConfig
     protectedFilePatterns: string[]
-    compress: CompressTool
+    compress: CompressConfig
     strategies: {
         deduplication: Deduplication
         supersedeWrites: SupersedeWrites
         purgeErrors: PurgeErrors
     }
 }
 
-type CompressOverride = Partial<CompressTool>
+type CompressOverride = Partial<CompressConfig>
 
 const DEFAULT_PROTECTED_TOOLS = [
     "task",
@@ -112,6 +114,7 @@ export const VALID_CONFIG_KEYS = new Set([
     "manualMode.enabled",
     "manualMode.automaticStrategies",
     "compress",
+    "compress.mode",
     "compress.permission",
     "compress.showCompression",
     "compress.maxContextLimit",
@@ -347,6 +350,18 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                 actual: typeof compress,
             })
         } else {
+            if (
+                compress.mode !== undefined &&
+                compress.mode !== "range" &&
+                compress.mode !== "message"
+            ) {
+                errors.push({
+                    key: "compress.mode",
+                    expected: '"range" | "message"',
+                    actual: JSON.stringify(compress.mode),
+                })
+            }
+
             if (
                 compress.nudgeFrequency !== undefined &&
                 typeof compress.nudgeFrequency !== "number"
@@ -662,6 +677,7 @@ const defaultConfig: PluginConfig = {
     },
     protectedFilePatterns: [],
     compress: {
+        mode: "range",
         permission: "allow",
         showCompression: false,
         maxContextLimit: 150000,
@@ -830,6 +846,7 @@ function mergeCompress(
     }
 
     return {
+        mode: override.mode ?? base.mode,
         permission: override.permission ?? base.permission,
         showCompression: override.showCompression ?? base.showCompression,
         maxContextLimit: override.maxContextLimit ?? base.maxContextLimit,

lib/messages/inject/utils.ts

@@ -169,7 +169,15 @@ export function addAnchor(
     return anchorMessageIds.size !== previousSize
 }
 
-export function buildCompressedBlockGuidance(state: SessionState): string {
+export function buildCompressedBlockGuidance(state: SessionState, config: PluginConfig): string {
+    if (config.compress.mode === "message") {
+        return [
+            "Compressed message context:",
+            "- Message mode is active. Compress individual raw messages using `mNNNN` IDs only.",
+            "- Do not use block placeholders or `bN` references in message mode.",
+        ].join("\n")
+    }
+
     const refs = Array.from(state.prune.messages.activeBlockIds)
         .filter((id) => Number.isInteger(id) && id > 0)
         .sort((a, b) => a - b)
@@ -238,7 +246,7 @@ export function applyAnchoredNudges(
     messages: WithParts[],
     prompts: RuntimePrompts,
 ): void {
-    const compressedBlockGuidance = buildCompressedBlockGuidance(state)
+    const compressedBlockGuidance = buildCompressedBlockGuidance(state, config)
 
     const contextLimitNudge = appendGuidanceToDcpTag(
         prompts.contextLimitNudge,

lib/prompts/compress-message.ts

@@ -0,0 +1,72 @@
+export const COMPRESS_MESSAGE = `Collapse selected individual messages in the conversation into detailed summaries.
+
+THE PHILOSOPHY OF MESSAGE COMPRESS
+\`compress\` in message mode transforms specific stale messages into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what each selected message contributed.
+
+Think of compression as phase transitions: raw exploration becomes refined understanding. The original message served its purpose; your summary now carries that understanding forward.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
+
+USER INTENT FIDELITY
+When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote short user instructions when that best preserves exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool output, and repetition. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+MESSAGE IDS
+You specify individual raw messages by ID using the injected IDs visible in the conversation:
+
+- \`mNNNN\` IDs identify raw messages
+
+Each message has an ID inside XML metadata tags like \`<dcp-message-id>...</dcp-message-id>\`.
+Treat these tags as message metadata only, not as content to summarize.
+
+Rules:
+
+- Pick each \`messageId\` directly from injected IDs visible in context.
+- Only use raw message IDs of the form \`mNNNN\`.
+- Do NOT use compressed block IDs like \`bN\`.
+- Do not invent IDs. Use only IDs that are present in context.
+- Do not target prior compressed blocks or block summaries.
+
+THE WAYS OF MESSAGE COMPRESS
+Compress when an individual message is genuinely closed and unlikely to be needed verbatim again:
+
+Research findings have already been absorbed into later work
+Tool-heavy assistant updates are no longer needed in raw form
+Earlier planning or analysis messages are now stale but still important to retain as summary
+
+Do NOT compress when:
+You may need the exact raw message text, code, or error output in the immediate next steps
+The message is still actively being referenced or edited against
+The target is a prior compressed block or block summary rather than a raw message
+
+Before compressing, ask: _"Is this message closed enough to become summary-only right now?"_
+
+BATCHING
+Do not call the tool once per message. Select MANY messages in a single tool call when they are independently safe to compress.
+Each entry should summarize exactly one message, and the tool can receive as many entries as needed in one batch.
+
+THE FORMAT OF MESSAGE COMPRESS
+
+~~~json
+{
+  "topic": "overall batch label",
+  "content": [
+    {
+      "messageId": "m0001",
+      "topic": "short message label",
+      "summary": "Complete technical summary replacing that one message"
+    }
+  ]
+}
+~~~
+
+Because each message is compressed independently:
+
+- Do not describe ranges
+- Do not use start/end boundaries
+- Do not use compressed block placeholders
+- Do not reference prior compressed blocks with \`(bN)\`
+`

lib/prompts/compress.ts lib/prompts/compress-range.tslib/prompts/compress.ts renamed to lib/prompts/compress-range.ts

@@ -1,4 +1,4 @@
-export const COMPRESS = `Collapse a range in the conversation into a detailed summary.
+export const COMPRESS_RANGE = `Collapse a range in the conversation into a detailed summary.
 
 THE PHILOSOPHY OF COMPRESS
 \`compress\` transforms verbose conversation sequences into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.

lib/prompts/store.ts

@@ -3,22 +3,25 @@ import { join, dirname } from "path"
 import { homedir } from "os"
 import type { Logger } from "../logger"
 import { SYSTEM as SYSTEM_PROMPT } from "./system"
-import { COMPRESS as COMPRESS_PROMPT } from "./compress"
+import { COMPRESS_RANGE as COMPRESS_RANGE_PROMPT } from "./compress-range"
+import { COMPRESS_MESSAGE as COMPRESS_MESSAGE_PROMPT } from "./compress-message"
 import { CONTEXT_LIMIT_NUDGE } from "./context-limit-nudge"
 import { TURN_NUDGE } from "./turn-nudge"
 import { ITERATION_NUDGE } from "./iteration-nudge"
 import { MANUAL_MODE_SYSTEM_OVERLAY, SUBAGENT_SYSTEM_OVERLAY } from "./internal-overlays"
 
 export type PromptKey =
     | "system"
-    | "compress"
+    | "compress-range"
+    | "compress-message"
     | "context-limit-nudge"
     | "turn-nudge"
     | "iteration-nudge"
 
 type EditablePromptField =
     | "system"
-    | "compress"
+    | "compressRange"
+    | "compressMessage"
     | "contextLimitNudge"
     | "turnNudge"
     | "iterationNudge"
@@ -45,7 +48,8 @@ interface PromptPaths {
 
 export interface RuntimePrompts {
     system: string
-    compress: string
+    compressRange: string
+    compressMessage: string
     contextLimitNudge: string
     turnNudge: string
     iterationNudge: string
@@ -63,12 +67,20 @@ const PROMPT_DEFINITIONS: PromptDefinition[] = [
         runtimeField: "system",
     },
     {
-        key: "compress",
-        fileName: "compress.md",
-        label: "Compress",
-        description: "compress tool instructions and summary constraints",
-        usage: "Registered as the compress tool description",
-        runtimeField: "compress",
+        key: "compress-range",
+        fileName: "compress-range.md",
+        label: "Compress Range",
+        description: "range-mode compress tool instructions and summary constraints",
+        usage: "Registered as the range-mode compress tool description",
+        runtimeField: "compressRange",
+    },
+    {
+        key: "compress-message",
+        fileName: "compress-message.md",
+        label: "Compress Message",
+        description: "message-mode compress tool instructions and summary constraints",
+        usage: "Registered as the message-mode compress tool description",
+        runtimeField: "compressMessage",
     },
     {
         key: "context-limit-nudge",
@@ -98,7 +110,8 @@ const PROMPT_DEFINITIONS: PromptDefinition[] = [
 
 export const PROMPT_KEYS: PromptKey[] = [
     "system",
-    "compress",
+    "compress-range",
+    "compress-message",
     "context-limit-nudge",
     "turn-nudge",
     "iteration-nudge",
@@ -112,7 +125,8 @@ const DEFAULTS_README_FILE = "README.md"
 
 const BUNDLED_EDITABLE_PROMPTS: Record<EditablePromptField, string> = {
     system: SYSTEM_PROMPT,
-    compress: COMPRESS_PROMPT,
+    compressRange: COMPRESS_RANGE_PROMPT,
+    compressMessage: COMPRESS_MESSAGE_PROMPT,
     contextLimitNudge: CONTEXT_LIMIT_NUDGE,
     turnNudge: TURN_NUDGE,
     iterationNudge: ITERATION_NUDGE,
@@ -126,7 +140,8 @@ const INTERNAL_PROMPT_OVERLAYS = {
 function createBundledRuntimePrompts(): RuntimePrompts {
     return {
         system: BUNDLED_EDITABLE_PROMPTS.system,
-        compress: BUNDLED_EDITABLE_PROMPTS.compress,
+        compressRange: BUNDLED_EDITABLE_PROMPTS.compressRange,
+        compressMessage: BUNDLED_EDITABLE_PROMPTS.compressMessage,
         contextLimitNudge: BUNDLED_EDITABLE_PROMPTS.contextLimitNudge,
         turnNudge: BUNDLED_EDITABLE_PROMPTS.turnNudge,
         iterationNudge: BUNDLED_EDITABLE_PROMPTS.iterationNudge,
@@ -232,7 +247,7 @@ function toEditablePromptText(definition: PromptDefinition, rawContent: string):
         normalized = stripConditionalTag(normalized, "subagent")
     }
 
-    if (definition.key !== "compress") {
+    if (definition.key !== "compress-range" && definition.key !== "compress-message") {
         normalized = normalizeReminderPromptContent(normalized)
     }
 
@@ -245,7 +260,7 @@ function wrapRuntimePromptContent(definition: PromptDefinition, editableText: st
         return ""
     }
 
-    if (definition.key === "compress") {
+    if (definition.key === "compress-range" || definition.key === "compress-message") {
         return trimmed
     }
 

lib/prompts/system.ts

@@ -1,29 +1,29 @@
 export const SYSTEM = `
 You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance.
 
-The ONLY tool you have for context management is \`compress\`. It replaces a contiguous portion of the conversation (inclusive) with a technical summary you produce.
+The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with technical summaries you produce. Depending on the configured mode, it may compress closed ranges or selected individual messages.
 
 \`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
 
 OPERATING STANCE
-Prefer short, closed, summary-safe ranges.
-When multiple independent stale ranges exist, prefer several short compressions (in parallel when possible) over one large-range compression.
+Prefer short, closed, summary-safe compressions.
+When multiple independent stale sections exist, prefer several focused compressions (in parallel when possible) over one broad compression.
 
 Use \`compress\` as steady housekeeping while you work.
 
 CADENCE, SIGNALS, AND LATENCY
 
 - No fixed threshold mandates compression
-- Prioritize closedness and independence over raw range size
+- Prioritize closedness and independence over raw size
 - Prefer smaller, regular compressions over infrequent massive compressions for better latency and summary quality
-- When multiple independent stale ranges are ready, batch compressions in parallel
+- When multiple independent stale sections are ready, batch compressions in parallel
 
 DO NOT COMPRESS IF
 
 - raw context is still relevant and needed for edits or precise references
-- the task in the target range is still actively in progress
+- the target content is still actively in progress
 
-Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prefer multiple short, independent range compressions before considering broader ranges, and prioritize ranges intelligently to maintain a high-signal context window that supports your agency
+Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prefer multiple short, independent compressions before considering broader ones, and prioritize stale content intelligently to maintain a high-signal context window that supports your agency
 
 It is of your responsibility to keep a sharp, high-quality context window for optimal performance
 `