openrecall 0.2.2 → 0.4.0

package/src/dcp/messages/utils.ts

@@ -0,0 +1,269 @@
+import { ulid } from "ulid"
+import { isMessageCompacted } from "../shared-utils"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import type { UserMessage } from "@opencode-ai/sdk/v2"
+
+export const COMPRESS_SUMMARY_PREFIX = "[Compressed conversation block]\n\n"
+
+const generateUniqueId = (prefix: string): string => `${prefix}_${ulid()}`
+
+const isGeminiModel = (modelID: string): boolean => {
+    const lowerModelID = modelID.toLowerCase()
+    return lowerModelID.includes("gemini")
+}
+
+export const createSyntheticUserMessage = (
+    baseMessage: WithParts,
+    content: string,
+    variant?: string,
+): WithParts => {
+    const userInfo = baseMessage.info as UserMessage
+    const now = Date.now()
+    const messageId = generateUniqueId("msg")
+    const partId = generateUniqueId("prt")
+
+    return {
+        info: {
+            id: messageId,
+            sessionID: userInfo.sessionID,
+            role: "user" as const,
+            agent: userInfo.agent,
+            model: userInfo.model,
+            time: { created: now },
+            ...(variant !== undefined && { variant }),
+        },
+        parts: [
+            {
+                id: partId,
+                sessionID: userInfo.sessionID,
+                messageID: messageId,
+                type: "text" as const,
+                text: content,
+            },
+        ],
+    }
+}
+
+export const createSyntheticTextPart = (baseMessage: WithParts, content: string) => {
+    const userInfo = baseMessage.info as UserMessage
+    const partId = generateUniqueId("prt")
+
+    return {
+        id: partId,
+        sessionID: userInfo.sessionID,
+        messageID: userInfo.id,
+        type: "text" as const,
+        text: content,
+    }
+}
+
+export const createSyntheticToolPart = (
+    baseMessage: WithParts,
+    content: string,
+    modelID: string,
+) => {
+    const userInfo = baseMessage.info as UserMessage
+    const now = Date.now()
+
+    const partId = generateUniqueId("prt")
+    const callId = generateUniqueId("call")
+
+    // Gemini requires thoughtSignature bypass to accept synthetic tool parts
+    const toolPartMetadata = isGeminiModel(modelID)
+        ? { google: { thoughtSignature: "skip_thought_signature_validator" } }
+        : {}
+
+    return {
+        id: partId,
+        sessionID: userInfo.sessionID,
+        messageID: userInfo.id,
+        type: "tool" as const,
+        callID: callId,
+        tool: "context_info",
+        state: {
+            status: "completed" as const,
+            input: {},
+            output: content,
+            title: "Context Info",
+            metadata: toolPartMetadata,
+            time: { start: now, end: now },
+        },
+    }
+}
+
+/**
+ * Extracts a human-readable key from tool metadata for display purposes.
+ */
+export const extractParameterKey = (tool: string, parameters: any): string => {
+    if (!parameters) return ""
+
+    if (tool === "read" && parameters.filePath) {
+        const offset = parameters.offset
+        const limit = parameters.limit
+        if (offset !== undefined && limit !== undefined) {
+            return `${parameters.filePath} (lines ${offset}-${offset + limit})`
+        }
+        if (offset !== undefined) {
+            return `${parameters.filePath} (lines ${offset}+)`
+        }
+        if (limit !== undefined) {
+            return `${parameters.filePath} (lines 0-${limit})`
+        }
+        return parameters.filePath
+    }
+    if ((tool === "write" || tool === "edit" || tool === "multiedit") && parameters.filePath) {
+        return parameters.filePath
+    }
+
+    if (tool === "apply_patch" && typeof parameters.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        const paths: string[] = []
+        let match
+        while ((match = pathRegex.exec(parameters.patchText)) !== null) {
+            paths.push(match[1]!.trim())
+        }
+        if (paths.length > 0) {
+            const uniquePaths = [...new Set(paths)]
+            const count = uniquePaths.length
+            const plural = count > 1 ? "s" : ""
+            if (count === 1) return uniquePaths[0]!
+            if (count === 2) return uniquePaths.join(", ")
+            return `${count} file${plural}: ${uniquePaths[0]}, ${uniquePaths[1]}...`
+        }
+        return "patch"
+    }
+
+    if (tool === "list") {
+        return parameters.path || "(current directory)"
+    }
+    if (tool === "glob") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+    if (tool === "grep") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "bash") {
+        if (parameters.description) return parameters.description
+        if (parameters.command) {
+            return parameters.command.length > 50
+                ? parameters.command.substring(0, 50) + "..."
+                : parameters.command
+        }
+    }
+
+    if (tool === "webfetch" && parameters.url) {
+        return parameters.url
+    }
+    if (tool === "websearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+    if (tool === "codesearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+
+    if (tool === "todowrite") {
+        return `${parameters.todos?.length || 0} todos`
+    }
+    if (tool === "todoread") {
+        return "read todo list"
+    }
+
+    if (tool === "task" && parameters.description) {
+        return parameters.description
+    }
+    if (tool === "skill" && parameters.name) {
+        return parameters.name
+    }
+
+    if (tool === "lsp") {
+        const op = parameters.operation || "lsp"
+        const path = parameters.filePath || ""
+        const line = parameters.line
+        const char = parameters.character
+        if (path && line !== undefined && char !== undefined) {
+            return `${op} ${path}:${line}:${char}`
+        }
+        if (path) {
+            return `${op} ${path}`
+        }
+        return op
+    }
+
+    if (tool === "question") {
+        const questions = parameters.questions
+        if (Array.isArray(questions) && questions.length > 0) {
+            const headers = questions
+                .map((q: any) => q.header || "")
+                .filter(Boolean)
+                .slice(0, 3)
+
+            const count = questions.length
+            const plural = count > 1 ? "s" : ""
+
+            if (headers.length > 0) {
+                const suffix = count > 3 ? ` (+${count - 3} more)` : ""
+                return `${count} question${plural}: ${headers.join(", ")}${suffix}`
+            }
+            return `${count} question${plural}`
+        }
+        return "question"
+    }
+
+    const paramStr = JSON.stringify(parameters)
+    if (paramStr === "{}" || paramStr === "[]" || paramStr === "null") {
+        return ""
+    }
+    return paramStr.substring(0, 50)
+}
+
+export function buildToolIdList(
+    state: SessionState,
+    messages: WithParts[],
+    logger: Logger,
+): string[] {
+    const toolIds: string[] = []
+    for (const msg of messages) {
+        if (isMessageCompacted(state, msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        if (parts.length > 0) {
+            for (const part of parts) {
+                if (part.type === "tool" && part.callID && part.tool) {
+                    toolIds.push(part.callID)
+                }
+            }
+        }
+    }
+    state.toolIdList = toolIds
+    return toolIds
+}
+
+export const isIgnoredUserMessage = (message: WithParts): boolean => {
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    if (parts.length === 0) {
+        return true
+    }
+
+    for (const part of parts) {
+        if (!(part as any).ignored) {
+            return false
+        }
+    }
+
+    return true
+}
+
+export const findMessageIndex = (messages: WithParts[], messageId: string): number => {
+    return messages.findIndex((msg) => msg.info.id === messageId)
+}

package/src/dcp/prompts/_codegen/compress-nudge.generated.ts

@@ -0,0 +1,15 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from compress-nudge.md by scripts/generate-prompts.ts
+// To modify, edit compress-nudge.md and run `npm run generate:prompts`
+
+export const COMPRESS_NUDGE = `<instruction name=context_limit_reached>
+CRITICAL CONTEXT LIMIT
+Your session context has exceeded the configured limit. Strict adherence to context compression is required.
+
+PROTOCOL
+You should prioritize context management, but do not interrupt a critical atomic operation if one is in progress. Once the immediate step is done, you must perform context management.
+
+IMMEDIATE ACTION REQUIRED
+PHASE COMPLETION: If a phase is complete, use the \`compress\` tool to condense the entire sequence into a detailed summary
+</instruction>
+`

package/src/dcp/prompts/_codegen/compress.generated.ts

@@ -0,0 +1,56 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from compress.md by scripts/generate-prompts.ts
+// To modify, edit compress.md and run `npm run generate:prompts`
+
+export const COMPRESS = `Use this tool to collapse a contiguous range of conversation into a preserved 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.
+
+Think of compression as phase transitions: raw exploration becomes refined understanding. The original context 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... 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.
+
+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.
+
+THE WAYS OF COMPRESS
+\`compress\` when a chapter closes - when a phase of work is truly complete and the raw conversation has served its purpose:
+
+Research concluded and findings are clear
+Implementation finished and verified
+Exploration exhausted and patterns understood
+
+Do NOT compress when:
+You may need exact code, error messages, or file contents from the range
+Work in that area is still active or may resume
+You're mid-sprint on related functionality
+
+Before compressing, ask: _"Is this chapter closed?"_ Compression is irreversible. The summary replaces everything in the range.
+
+BOUNDARY MATCHING
+You specify boundaries by matching unique text strings in the conversation. CRITICAL: In code-centric conversations, strings repeat often. Provide sufficiently unique text to match exactly once. If a match fails (not found or found multiple times), the tool will error - extend your boundary string with more surrounding context in order to make SURE the tool does NOT error.
+
+WHERE TO PICK STRINGS FROM (important for reliable matching):
+
+- Your own assistant text responses (MOST RELIABLE - always stored verbatim)
+- The user's own words in their messages
+- Tool result output text (distinctive substrings within the output)
+- Previous compress summaries
+- Tool input string values (individual values, not whole serialized objects)
+
+WHERE TO NEVER PICK STRINGS FROM:
+
+- \`<system-reminder>\` tags or any XML wrapper/meta-commentary around messages
+- Injected system instructions (plan mode text, max-steps warnings, mode-switch text, environment info)
+- File/directory listing framing text (e.g. "Called the Read tool with the following input...")
+- Strings that span across message or part boundaries
+- Entire serialized JSON objects (key ordering may differ - pick a distinctive substring within instead)
+
+THE FORMAT OF COMPRESS
+\`topic\`: Short label (3-5 words) for display - e.g., "Auth System Exploration"
+\`content\`: Object containing:
+\`startString\`: Unique text string marking the beginning of the range
+\`endString\`: Unique text string marking the end of the range
+\`summary\`: Complete technical summary replacing all content in the range
+`

package/src/dcp/prompts/_codegen/distill.generated.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from distill.md by scripts/generate-prompts.ts
+// To modify, edit distill.md and run `npm run generate:prompts`
+
+export const DISTILL = `Use this tool to distill relevant findings from a selection of raw tool outputs into preserved knowledge, in order to denoise key bits and parts of context.
+
+THE PRUNABLE TOOLS LIST
+A <prunable-tools> will show in context when outputs are available for distillation (you don't need to look for it). Each entry follows the format \`ID: tool, parameter (~token usage)\` (e.g., \`20: read, /path/to/file.ts (~1500 tokens)\`). You MUST select outputs by their numeric ID. THESE ARE YOUR ONLY VALID TARGETS.
+
+THE PHILOSOPHY OF DISTILLATION
+\`distill\` is your favored instrument for transforming raw tool outputs into preserved knowledge. This is not mere summarization; it is high-fidelity extraction that makes the original output obsolete.
+
+Your distillation must be COMPLETE. Capture function signatures, type definitions, business logic, constraints, configuration values... EVERYTHING essential. Think of it as creating a high signal technical substitute so faithful that re-fetching the original would yield no additional value. Be thorough; be comprehensive; leave no ambiguity, ensure that your distillation stands alone, and is designed for easy retrieval and comprehension.
+
+AIM FOR IMPACT. Distillation is most powerful when applied to outputs that contain signal buried in noise. A single line requires no distillation; a hundred lines of API documentation do. Make sure the distillation is meaningful.
+
+THE WAYS OF DISTILL
+\`distill\` when you have extracted the essence from tool outputs and the raw form has served its purpose.
+Here are some examples:
+EXPLORATION: You've read extensively and grasp the architecture. The original file contents are no longer needed; your understanding, synthesized, is sufficient.
+PRESERVATION: Valuable technical details (signatures, logic, constraints) coexist with noise. Preserve the former; discard the latter.
+
+Not everything should be distilled. Prefer keeping raw outputs when:
+PRECISION MATTERS: You will edit the file, grep for exact strings, or need line-accurate references. Distillation sacrifices precision for essence.
+UNCERTAINTY REMAINS: If you might need to re-examine the original, defer. Distillation is irreversible; be certain before you commit.
+
+Before distilling, ask yourself: _"Will I need the raw output for upcoming work?"_ If you plan to edit a file you just read, keep it intact. Distillation is for completed exploration, not active work.
+
+THE FORMAT OF DISTILL
+\`targets\`: Array of objects, each containing:
+\`id\`: Numeric ID (as string) from the \`<prunable-tools>\` list
+\`distillation\`: Complete technical substitute for that tool output
+`

package/src/dcp/prompts/_codegen/nudge.generated.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from nudge.md by scripts/generate-prompts.ts
+// To modify, edit nudge.md and run `npm run generate:prompts`
+
+export const NUDGE = `<instruction name=context_management_required>
+CRITICAL CONTEXT WARNING
+Your context window is filling with tool. Strict adherence to context hygiene is required.
+
+PROTOCOL
+You should prioritize context management, but do not interrupt a critical atomic operation if one is in progress. Once the immediate step is done, you must perform context management.
+
+IMMEDIATE ACTION REQUIRED
+<distill>KNOWLEDGE PRESERVATION: If holding valuable raw data you POTENTIALLY will need in your task, use the \`distill\` tool. Produce a high-fidelity distillation to preserve insights - be thorough</distill>
+<compress>PHASE COMPLETION: If a phase is complete, use the \`compress\` tool to condense the entire sequence into a detailed summary</compress>
+<prune>NOISE REMOVAL: If you read files or ran commands that yielded no value, use the \`prune\` tool to remove them. If newer tools supersedes older ones, prune the old</prune>
+</instruction>
+`

package/src/dcp/prompts/_codegen/prune.generated.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from prune.md by scripts/generate-prompts.ts
+// To modify, edit prune.md and run `npm run generate:prompts`
+
+export const PRUNE = `Use this tool to remove tool outputs from context entirely. No preservation - pure deletion.
+
+THE PRUNABLE TOOLS LIST
+A \`<prunable-tools>\` section surfaces in context showing outputs eligible for removal. Each line reads \`ID: tool, parameter (~token usage)\` (e.g., \`20: read, /path/to/file.ts (~1500 tokens)\`). Reference outputs by their numeric ID - these are your ONLY valid targets for pruning.
+
+THE WAYS OF PRUNE
+\`prune\` is surgical deletion - eliminating noise (irrelevant or unhelpful outputs), superseded information (older outputs replaced by newer data), or wrong targets (you accessed something that turned out to be irrelevant). Use it to keep your context lean and focused.
+
+BATCH WISELY! Pruning is most effective when consolidated. Don't prune a single tiny output - accumulate several candidates before acting.
+
+Do NOT prune when:
+NEEDED LATER: You plan to edit the file or reference this context for implementation.
+UNCERTAINTY: If you might need to re-examine the original, keep it.
+
+Before pruning, ask: _"Is this noise, or will it serve me?"_ If the latter, keep it. Pruning that forces re-fetching is a net loss.
+
+THE FORMAT OF PRUNE
+\`ids\`: Array of numeric IDs (as strings) from the \`<prunable-tools>\` list
+`

package/src/dcp/prompts/_codegen/system.generated.ts

@@ -0,0 +1,57 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Generated from system.md by scripts/generate-prompts.ts
+// To modify, edit system.md and run `npm run generate:prompts`
+
+export const SYSTEM = `<system-reminder>
+<instruction name=context_management_protocol policy_level=critical>
+You operate a context-constrained environment and MUST PROACTIVELY MANAGE IT TO AVOID CONTEXT ROT. Efficient context management is CRITICAL to maintaining performance and ensuring successful task completion.
+
+AVAILABLE TOOLS FOR CONTEXT MANAGEMENT
+<distill>\`distill\`: condense key findings from tool calls into high-fidelity distillation to preserve gained insights. Use to extract valuable knowledge to the user's request. BE THOROUGH, your distillation MUST be high-signal, low noise and complete</distill>
+<compress>\`compress\`: squash contiguous portion of the conversation and replace it with a low level technical summary. Use to filter noise from the conversation and retain purified understanding. Compress conversation phases ORGANICALLY as they get completed, think meso, not micro nor macro. Do not be cheap with that low level technical summary and BE MINDFUL of specifics that must be crystallized to retain UNAMBIGUOUS full picture.</compress>
+<prune>\`prune\`: remove individual tool calls that are noise, irrelevant, or superseded. No preservation of content. DO NOT let irrelevant tool calls accumulate. DO NOT PRUNE TOOL OUTPUTS THAT YOU MAY NEED LATER</prune>
+
+<distill>THE DISTILL TOOL
+\`distill\` is the favored way to target specific tools and crystalize their value into high-signal low-noise knowledge nuggets. Your distillation must be comprehensive, capturing technical details (symbols, signatures, logic, constraints) such that the raw output is no longer needed. THINK complete technical substitute. \`distill\` is typically best used when you are certain the raw information is not needed anymore, but the knowledge it contains is valuable to retain so you maintain context authenticity and understanding. Be conservative in your approach to distilling, but do NOT hesitate to distill when appropriate.
+</distill>
+
+<compress>THE COMPRESS TOOL
+\`compress\` is a sledgehammer and should be used accordingly. It's purpose is to reduce whole part of the conversation to its essence and technical details in order to leave room for newer context. Your summary MUST be technical and specific enough to preserve FULL understanding of WHAT TRANSPIRED, such that NO AMBIGUITY remains about what was done, found, or decided. Your compress summary must be thorough and precise. \`compress\` will replace everything in the range you match, user and assistant messages, tool inputs and outputs. It is preferred to not compress preemptively, but rather wait for natural breakpoints in the conversation. Those breakpoints are to be infered from user messages. You WILL NOT compress based on thinking that you are done with the task, wait for conversation queues that the user has moved on from current phase.
+
+This tool will typically be used at the end of a phase of work, when conversation starts to accumulate noise that would better served summarized, or when you've done significant exploration and can FULLY synthesize your findings and understanding into a technical summary.
+
+Make sure to match enough of the context with start and end strings so you're not faced with an error calling the tool. Be VERY CAREFUL AND CONSERVATIVE when using \`compress\`.
+</compress>
+
+<prune>THE PRUNE TOOL
+\`prune\` is your last resort for context management. It is a blunt instrument that removes tool outputs entirely, without ANY preservation. It is best used to eliminate noise, irrelevant information, or superseded outputs that no longer add value to the conversation. You MUST NOT prune tool outputs that you may need later. Prune is a targeted nuke, not a general cleanup tool.
+
+Contemplate only pruning when you are certain that the tool output is irrelevant to the current task or has been superseded by more recent information. If in doubt, defer for when you are definitive. Evaluate WHAT SHOULD be pruned before jumping the gun.
+</prune>
+
+TIMING
+Prefer managing context at the START of a new agentic loop (after receiving a user message) rather than at the END of your previous turn. At turn start, you have fresh signal about what the user needs next - you can better judge what's still relevant versus noise from prior work. Managing at turn end means making retention decisions before knowing what comes next.
+
+EVALUATE YOUR CONTEXT AND MANAGE REGULARLY TO AVOID CONTEXT ROT. AVOID USING MANAGEMENT TOOLS AS THE ONLY TOOL CALLS IN YOUR RESPONSE, PARALLELIZE WITH OTHER RELEVANT TOOLS TO TASK CONTINUATION (read, edit, bash...). It is imperative you understand the value or lack thereof of the context you manage and make informed decisions to maintain a decluttered, high-quality and relevant context.
+
+The session is your responsibility, and effective context management is CRITICAL to your success. Be PROACTIVE, DELIBERATE, and STRATEGIC in your approach to context management. The session is your oyster - keep it clean, relevant, and high-quality to ensure optimal performance and successful task completion.
+
+Be respectful of the user's API usage, manage context methodically as you work through the task and avoid calling ONLY context management tools in your responses.
+</instruction>
+
+<manual><instruction name=manual_mode policy_level=critical>
+Manual mode is enabled. Do NOT use distill, compress, or prune unless the user has explicitly triggered it through a manual marker.
+
+<prune>Only use the prune tool after seeing \`<prune triggered manually>\` in the current user instruction context.</prune>
+<distill>Only use the distill tool after seeing \`<distill triggered manually>\` in the current user instruction context.</distill>
+<compress>Only use the compress tool after seeing \`<compress triggered manually>\` in the current user instruction context.</compress>
+
+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.
+</instruction></manual>
+
+<instruction name=injected_context_handling policy_level=critical>
+This chat environment injects context information on your behalf in the form of a <prunable-tools> list to help you manage context effectively. Carefully read the list and use it to inform your management decisions. The list is automatically updated after each turn to reflect the current state of manageable tools and context usage. If no list is present, do NOT attempt to prune anything.
+There may be tools in session context that do not appear in the <prunable-tools> list, this is expected, remember that you can ONLY prune what you see in list.
+</instruction>
+</system-reminder>
+`

package/src/dcp/prompts/index.ts

@@ -0,0 +1,59 @@
+// Generated prompts (from .md files via scripts/generate-prompts.ts)
+import { SYSTEM as SYSTEM_PROMPT } from "./_codegen/system.generated"
+import { NUDGE } from "./_codegen/nudge.generated"
+import { COMPRESS_NUDGE } from "./_codegen/compress-nudge.generated"
+import { PRUNE as PRUNE_TOOL_SPEC } from "./_codegen/prune.generated"
+import { DISTILL as DISTILL_TOOL_SPEC } from "./_codegen/distill.generated"
+import { COMPRESS as COMPRESS_TOOL_SPEC } from "./_codegen/compress.generated"
+
+export interface ToolFlags {
+    distill: boolean
+    compress: boolean
+    prune: boolean
+    manual: boolean
+}
+
+function processConditionals(template: string, flags: ToolFlags): string {
+    const tools = ["distill", "compress", "prune", "manual"] as const
+    let result = template
+    // Strip comments: // ... //
+    result = result.replace(/\/\/.*?\/\//g, "")
+    // Process tool conditionals
+    for (const tool of tools) {
+        const regex = new RegExp(`<${tool}>([\\s\\S]*?)</${tool}>`, "g")
+        result = result.replace(regex, (_, content) => (flags[tool] ? content : ""))
+    }
+    // Collapse multiple blank/whitespace-only lines to single blank line
+    return result.replace(/\n([ \t]*\n)+/g, "\n\n").trim()
+}
+
+export function renderSystemPrompt(flags: ToolFlags): string {
+    return processConditionals(SYSTEM_PROMPT, flags)
+}
+
+export function renderNudge(flags: ToolFlags): string {
+    return processConditionals(NUDGE, flags)
+}
+
+export function renderCompressNudge(): string {
+    return COMPRESS_NUDGE
+}
+
+const PROMPTS: Record<string, string> = {
+    "prune-tool-spec": PRUNE_TOOL_SPEC,
+    "distill-tool-spec": DISTILL_TOOL_SPEC,
+    "compress-tool-spec": COMPRESS_TOOL_SPEC,
+}
+
+export function loadPrompt(name: string, vars?: Record<string, string>): string {
+    let content = PROMPTS[name]
+    if (!content) {
+        throw new Error(`Prompt not found: ${name}`)
+    }
+    if (vars) {
+        for (const [key, value] of Object.entries(vars)) {
+            content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value)
+        }
+    }
+    return content
+}

package/src/dcp/protected-file-patterns.ts

@@ -0,0 +1,113 @@
+function normalizePath(input: string): string {
+    return input.replaceAll("\\\\", "/")
+}
+
+function escapeRegExpChar(ch: string): string {
+    return /[\\.^$+{}()|\[\]]/.test(ch) ? `\\${ch}` : ch
+}
+
+/**
+ * Basic glob matching with support for `**`, `*`, and `?`.
+ *
+ * Notes:
+ * - Matching is performed against the full (normalized) string.
+ * - `*` and `?` do not match `/`.
+ * - `**` matches across `/`.
+ */
+export function matchesGlob(inputPath: string, pattern: string): boolean {
+    if (!pattern) return false
+
+    const input = normalizePath(inputPath)
+    const pat = normalizePath(pattern)
+
+    let regex = "^"
+
+    for (let i = 0; i < pat.length; i++) {
+        const ch = pat[i]!
+
+        if (ch === "*") {
+            const next = pat[i + 1]
+            if (next === "*") {
+                const after = pat[i + 2]
+                if (after === "/") {
+                    // **/  (zero or more directories)
+                    regex += "(?:.*/)?"
+                    i += 2
+                    continue
+                }
+
+                // **
+                regex += ".*"
+                i++
+                continue
+            }
+
+            // *
+            regex += "[^/]*"
+            continue
+        }
+
+        if (ch === "?") {
+            regex += "[^/]"
+            continue
+        }
+
+        if (ch === "/") {
+            regex += "/"
+            continue
+        }
+
+        regex += escapeRegExpChar(ch)
+    }
+
+    regex += "$"
+
+    return new RegExp(regex).test(input)
+}
+
+export function getFilePathsFromParameters(tool: string, parameters: unknown): string[] {
+    if (typeof parameters !== "object" || parameters === null) {
+        return []
+    }
+
+    const paths: string[] = []
+    const params = parameters as Record<string, any>
+
+    // 1. apply_patch uses patchText with embedded paths
+    if (tool === "apply_patch" && typeof params.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        let match
+        while ((match = pathRegex.exec(params.patchText)) !== null) {
+            paths.push(match[1]!.trim())
+        }
+    }
+
+    // 2. multiedit uses top-level filePath and nested edits array
+    if (tool === "multiedit") {
+        if (typeof params.filePath === "string") {
+            paths.push(params.filePath)
+        }
+        if (Array.isArray(params.edits)) {
+            for (const edit of params.edits) {
+                if (edit && typeof edit.filePath === "string") {
+                    paths.push(edit.filePath)
+                }
+            }
+        }
+    }
+
+    // 3. Default check for common filePath parameter (read, write, edit, etc)
+    if (typeof params.filePath === "string") {
+        paths.push(params.filePath)
+    }
+
+    // Return unique non-empty paths
+    return [...new Set(paths)].filter((p) => p.length > 0)
+}
+
+export function isProtected(filePaths: string[], patterns: string[]): boolean {
+    if (!filePaths || filePaths.length === 0) return false
+    if (!patterns || patterns.length === 0) return false
+
+    return filePaths.some((path) => patterns.some((pattern) => matchesGlob(path, pattern)))
+}