@tarquinen/opencode-dcp 3.2.5-beta0 → 3.2.6-beta0

package/lib/prompts/compress-range.ts

@@ -0,0 +1,60 @@
+export const COMPRESS_RANGE = `Collapse a range in the conversation into a detailed summary.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
+
+USER INTENT FIDELITY
+When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+COMPRESSED BLOCK PLACEHOLDERS
+When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
+
+- \`(bN)\`
+
+Compressed block sections in context are clearly marked with a header:
+
+- \`[Compressed conversation section]\`
+
+Compressed block IDs always use the \`bN\` form (never \`mNNNN\`) and are represented in the same XML metadata tag format.
+
+Rules:
+
+- Include every required block placeholder exactly once.
+- Do not invent placeholders for blocks outside the selected range.
+- Treat \`(bN)\` placeholders as RESERVED TOKENS. Do not emit \`(bN)\` text anywhere except intentional placeholders.
+- If you need to mention a block in prose, use plain text like \`compressed bN\` (not as a placeholder).
+- Preflight check before finalizing: the set of \`(bN)\` placeholders in your summary must exactly match the required set, with no duplicates.
+
+These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
+
+FLOW PRESERVATION WITH PLACEHOLDERS
+When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
+
+- Treat each placeholder as a stand-in for a full conversation segment, not as a short label.
+- Ensure transitions before and after each placeholder preserve chronology and causality.
+- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`(b2)\`").
+- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
+
+BOUNDARY IDS
+You specify boundaries by ID using the injected IDs visible in the conversation:
+
+- \`mNNNN\` IDs identify raw messages
+- \`bN\` IDs identify previously compressed blocks
+
+Each message has an ID inside XML metadata tags like \`<dcp-message-id>...</dcp-message-id>\`.
+The same ID tag appears in every tool output of the message it belongs to — each unique ID identifies one complete message.
+Treat these tags as boundary metadata only, not as tool result content.
+
+Rules:
+
+- Pick \`startId\` and \`endId\` directly from injected IDs in context.
+- IDs must exist in the current visible context.
+- \`startId\` must appear before \`endId\`.
+- Do not invent IDs. Use only IDs that are present in context.
+
+BATCHING
+When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
+`

package/lib/prompts/context-limit-nudge.ts

@@ -0,0 +1,18 @@
+export const CONTEXT_LIMIT_NUDGE = `<dcp-system-reminder>
+CRITICAL WARNING: MAX CONTEXT LIMIT REACHED
+
+You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
+
+You MUST use the \`compress\` tool now. Do not continue normal exploration until compression is handled.
+
+If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
+
+SELECTION PROCESS
+Start from older, resolved history and capture as much stale context as safely possible in one pass.
+Avoid the newest active working messages unless it is clearly closed.
+
+SUMMARY REQUIREMENTS
+Your summary MUST cover all essential details from the selected messages so work can continue.
+If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+</dcp-system-reminder>
+`

package/lib/prompts/extensions/nudge.ts

@@ -0,0 +1,43 @@
+import type { SessionState } from "../../state"
+
+export function buildCompressedBlockGuidance(state: SessionState): string {
+    const refs = Array.from(state.prune.messages.activeBlockIds)
+        .filter((id) => Number.isInteger(id) && id > 0)
+        .sort((a, b) => a - b)
+        .map((id) => `b${id}`)
+    const blockCount = refs.length
+    const blockList = blockCount > 0 ? refs.join(", ") : "none"
+
+    return [
+        "Compressed block context:",
+        `- Active compressed blocks in this session: ${blockCount} (${blockList})`,
+        "- If your selected compression range includes any listed block, include each required placeholder exactly once in the summary using `(bN)`.",
+    ].join("\n")
+}
+
+export function renderMessagePriorityGuidance(priorityLabel: string, refs: string[]): string {
+    const refList = refs.length > 0 ? refs.join(", ") : "none"
+
+    return [
+        "Message priority context:",
+        "- Higher-priority older messages consume more context and should be compressed right away if it is safe to do so.",
+        `- ${priorityLabel}-priority message IDs before this point: ${refList}`,
+    ].join("\n")
+}
+
+export function appendGuidanceToDcpTag(nudgeText: string, guidance: string): string {
+    if (!guidance.trim()) {
+        return nudgeText
+    }
+
+    const closeTag = "</dcp-system-reminder>"
+    const closeTagIndex = nudgeText.lastIndexOf(closeTag)
+
+    if (closeTagIndex === -1) {
+        return nudgeText
+    }
+
+    const beforeClose = nudgeText.slice(0, closeTagIndex).trimEnd()
+    const afterClose = nudgeText.slice(closeTagIndex)
+    return `${beforeClose}\n\n${guidance}\n${afterClose}`
+}

package/lib/prompts/extensions/system.ts

@@ -0,0 +1,32 @@
+export const MANUAL_MODE_SYSTEM_EXTENSION = `<dcp-system-reminder>
+Manual mode is enabled. Do NOT use compress unless the user has explicitly triggered it through a manual marker.
+
+Only use the compress tool after seeing \`<compress triggered manually>\` in the current user instruction context.
+
+Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
+
+After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
+</dcp-system-reminder>
+`
+
+export const SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
+You are operating in a subagent environment.
+
+The initial subagent instruction is imperative and must be followed exactly.
+It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
+All subsequent messages in the session will have IDs.
+</dcp-system-reminder>
+`
+
+export function buildProtectedToolsExtension(protectedTools: string[]): string {
+    if (protectedTools.length === 0) {
+        return ""
+    }
+
+    const toolList = protectedTools.map((t) => `\`${t}\``).join(", ")
+    return `<dcp-system-reminder>
+The following tools are environment-managed: ${toolList}.
+Their outputs are automatically preserved during compression.
+Do not include their content in compress tool summaries — the environment retains it independently.
+</dcp-system-reminder>`
+}

package/lib/prompts/extensions/tool.ts

@@ -0,0 +1,35 @@
+// These format schemas are kept separate from the editable compress prompts
+// so they cannot be modified via custom prompt overrides. The schemas must
+// match the tool's input validation and are not safe to change independently.
+
+export const RANGE_FORMAT_EXTENSION = `
+THE FORMAT OF COMPRESS
+
+\`\`\`
+{
+  topic: string,           // Short label (3-5 words) - e.g., "Auth System Exploration"
+  content: [               // One or more ranges to compress
+    {
+      startId: string,     // Boundary ID at range start: mNNNN or bN
+      endId: string,       // Boundary ID at range end: mNNNN or bN
+      summary: string      // Complete technical summary replacing all content in range
+    }
+  ]
+}
+\`\`\``
+
+export const MESSAGE_FORMAT_EXTENSION = `
+THE FORMAT OF COMPRESS
+
+\`\`\`
+{
+  topic: string,           // Short label (3-5 words) for the overall batch
+  content: [               // One or more messages to compress independently
+    {
+      messageId: string,   // Raw message ID only: mNNNN (ignore metadata attributes like priority)
+      topic: string,       // Short label (3-5 words) for this one message summary
+      summary: string      // Complete technical summary replacing that one message
+    }
+  ]
+}
+\`\`\``

package/lib/prompts/index.ts

@@ -0,0 +1,29 @@
+import type { RuntimePrompts } from "./store"
+export type { PromptStore, RuntimePrompts } from "./store"
+
+export function renderSystemPrompt(
+    prompts: RuntimePrompts,
+    protectedToolsExtension?: string,
+    manual?: boolean,
+    subagent?: boolean,
+): string {
+    const extensions: string[] = []
+
+    if (protectedToolsExtension) {
+        extensions.push(protectedToolsExtension.trim())
+    }
+
+    if (manual) {
+        extensions.push(prompts.manualExtension.trim())
+    }
+
+    if (subagent) {
+        extensions.push(prompts.subagentExtension.trim())
+    }
+
+    return [prompts.system.trim(), ...extensions]
+        .filter(Boolean)
+        .join("\n\n")
+        .replace(/\n([ \t]*\n)+/g, "\n\n")
+        .trim()
+}

package/lib/prompts/iteration-nudge.ts

@@ -0,0 +1,6 @@
+export const ITERATION_NUDGE = `<dcp-system-reminder>
+You've been iterating for a while after the last user message.
+
+If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+</dcp-system-reminder>
+`