Merge pull request #438 from Opencode-DCP/dev

v3.0.3 - Version bump

Author: Tarquinen

lib/prompts/system.ts

@@ -3,6 +3,8 @@ You operate in a context-constrained environment. Manage context continuously to
 
 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.
 
+\`<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.

lib/tools/compress.ts

@@ -22,6 +22,7 @@ import {
     type CompressToolArgs,
 } from "./utils"
 import { isIgnoredUserMessage } from "../messages/utils"
+import { assignMessageRefs } from "../message-ids"
 import { getCurrentParams, getCurrentTokenUsage, countTokens } from "../strategies/utils"
 import { deduplicate, supersedeWrites, purgeErrors } from "../strategies"
 import { saveSessionState } from "../state/persistence"
@@ -112,6 +113,8 @@ export function createCompressTool(ctx: ToolContext): ReturnType<typeof tool> {
                 ctx.config.manualMode.enabled,
             )
 
+            assignMessageRefs(ctx.state, rawMessages)
+
             deduplicate(ctx.state, ctx.logger, ctx.config, rawMessages)
             // supersedeWrites(ctx.state, ctx.logger, ctx.config, rawMessages)
             purgeErrors(ctx.state, ctx.logger, ctx.config, rawMessages)

package-lock.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package.json",
     "name": "@tarquinen/opencode-dcp",
-    "version": "3.0.2",
+    "version": "3.0.3",
     "type": "module",
     "description": "OpenCode plugin that optimizes token usage by pruning obsolete tool outputs from conversation context",
     "main": "./dist/index.js",

package.json

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { mkdirSync } from "node:fs"
+import { createCompressTool } from "../lib/tools/compress"
+import { createSessionState, type WithParts } from "../lib/state"
+import type { PluginConfig } from "../lib/config"
+import { Logger } from "../lib/logger"
+
+const testDataHome = join(tmpdir(), `opencode-dcp-tests-${process.pid}`)
+const testConfigHome = join(tmpdir(), `opencode-dcp-config-tests-${process.pid}`)
+
+process.env.XDG_DATA_HOME = testDataHome
+process.env.XDG_CONFIG_HOME = testConfigHome
+
+mkdirSync(testDataHome, { recursive: true })
+mkdirSync(testConfigHome, { recursive: true })
+
+function buildConfig(): PluginConfig {
+    return {
+        enabled: true,
+        debug: false,
+        pruneNotification: "off",
+        pruneNotificationType: "chat",
+        commands: {
+            enabled: true,
+            protectedTools: [],
+        },
+        manualMode: {
+            enabled: false,
+            automaticStrategies: true,
+        },
+        turnProtection: {
+            enabled: false,
+            turns: 4,
+        },
+        experimental: {
+            allowSubAgents: true,
+            customPrompts: false,
+        },
+        protectedFilePatterns: [],
+        compress: {
+            permission: "allow",
+            showCompression: false,
+            maxContextLimit: 100000,
+            minContextLimit: 30000,
+            nudgeFrequency: 5,
+            iterationNudgeThreshold: 15,
+            nudgeForce: "soft",
+            flatSchema: false,
+            protectedTools: [],
+            protectUserMessages: false,
+        },
+        strategies: {
+            deduplication: {
+                enabled: true,
+                protectedTools: [],
+            },
+            supersedeWrites: {
+                enabled: true,
+            },
+            purgeErrors: {
+                enabled: true,
+                turns: 4,
+                protectedTools: [],
+            },
+        },
+    }
+}
+
+function textPart(messageID: string, sessionID: string, id: string, text: string) {
+    return {
+        id,
+        messageID,
+        sessionID,
+        type: "text" as const,
+        text,
+    }
+}
+
+function buildMessages(sessionID: string): WithParts[] {
+    return [
+        {
+            info: {
+                id: "msg-subagent-prompt",
+                role: "user",
+                sessionID,
+                agent: "codebase-analyzer",
+                model: {
+                    providerID: "anthropic",
+                    modelID: "claude-test",
+                },
+                time: { created: 1 },
+            } as WithParts["info"],
+            parts: [textPart("msg-subagent-prompt", sessionID, "part-1", "Investigate the issue")],
+        },
+        {
+            info: {
+                id: "msg-assistant-1",
+                role: "assistant",
+                sessionID,
+                agent: "codebase-analyzer",
+                time: { created: 2 },
+            } as WithParts["info"],
+            parts: [
+                textPart("msg-assistant-1", sessionID, "part-2", "I found the relevant code path"),
+            ],
+        },
+        {
+            info: {
+                id: "msg-user-2",
+                role: "user",
+                sessionID,
+                agent: "codebase-analyzer",
+                model: {
+                    providerID: "anthropic",
+                    modelID: "claude-test",
+                },
+                time: { created: 3 },
+            } as WithParts["info"],
+            parts: [
+                textPart("msg-user-2", sessionID, "part-3", "Please compress the initial findings"),
+            ],
+        },
+    ]
+}
+
+test("compress rebuilds subagent message refs after session state was reset", async () => {
+    const sessionID = `ses_subagent_compress_${Date.now()}`
+    const rawMessages = buildMessages(sessionID)
+    const state = createSessionState()
+    state.sessionId = "ses_other"
+    state.messageIds.byRawId.set("other-message", "m0001")
+    state.messageIds.byRef.set("m0001", "other-message")
+    state.messageIds.nextRef = 2
+
+    const logger = new Logger(false)
+    const tool = createCompressTool({
+        client: {
+            session: {
+                messages: async () => ({ data: rawMessages }),
+                get: async () => ({ data: { parentID: "ses_parent" } }),
+            },
+        },
+        state,
+        logger,
+        config: buildConfig(),
+        prompts: {
+            reload() {},
+            getRuntimePrompts() {
+                return { compress: "" }
+            },
+        },
+    } as any)
+
+    const result = await tool.execute(
+        {
+            topic: "Subagent race fix",
+            content: {
+                startId: "m0001",
+                endId: "m0002",
+                summary: "Captured the initial investigation and follow-up request.",
+            },
+        },
+        {
+            ask: async () => {},
+            metadata: () => {},
+            sessionID,
+            messageID: "msg-compress",
+        },
+    )
+
+    assert.equal(result, "Compressed 2 messages into [Compressed conversation section].")
+    assert.equal(state.sessionId, sessionID)
+    assert.equal(state.isSubAgent, true)
+    assert.equal(state.messageIds.byRef.get("m0001"), "msg-assistant-1")
+    assert.equal(state.messageIds.byRef.get("m0002"), "msg-user-2")
+    assert.equal(state.prune.messages.blocksById.size, 1)
+})