openrecall 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrecall",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Cross-session memory plugin for OpenCode with full-text search, tagging, and auto-recall",
   "module": "src/index.ts",
   "main": "src/index.ts",
@@ -40,7 +40,13 @@
   "license": "MIT",
   "author": "ASidorenkoCode",
   "dependencies": {
-    "@opencode-ai/plugin": "^1.2.2"
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "@opencode-ai/plugin": "^1.2.2",
+    "@opencode-ai/sdk": "^1.1.48",
+    "fuzzball": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "ulid": "^3.0.2",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/agent.ts

@@ -1,4 +1,4 @@
-import { storeMemory, searchByTag, getTagsForMemory } from "./memory"
+import { storeMemory, searchByTag, getTagsForMemory, deleteMemory, updateMemory, setTags } from "./memory"
 import { isDbAvailable } from "./db"
 import * as fs from "fs"
 import * as path from "path"
@@ -57,6 +57,92 @@ function buildFingerprintTags(filePath: string, directory?: string): string[] {
   return tags
 }
 
+/**
+ * Remove all existing memories tagged with a specific filepath.
+ */
+function purgeFileMemories(absPath: string, projectId: string): number {
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 50 })
+  for (const m of existing) {
+    deleteMemory(m.id)
+  }
+  return existing.length
+}
+
+/**
+ * Check if a file already has a fresh memory. Returns true if fresh (skip store).
+ * If stale, purges old memories so caller can store fresh ones.
+ */
+function isFileFreshInMemory(absPath: string, projectId: string, directory?: string): boolean {
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 1 })
+  if (existing.length === 0) return false
+
+  const memory = existing[0]!
+  const memoryTags = getTagsForMemory(memory.id)
+
+  let storedGitHash: string | undefined
+  let storedMtime: number | undefined
+  for (const t of memoryTags) {
+    if (t.startsWith("git:")) storedGitHash = t.slice(4)
+    if (t.startsWith("mtime:")) storedMtime = parseFloat(t.slice(6))
+  }
+
+  const current = getFileFingerprint(absPath, directory)
+
+  // Compare git hash first
+  if (current.gitHash && storedGitHash && current.gitHash === storedGitHash) {
+    return true // fresh
+  }
+
+  // Fall back to mtime
+  if (!current.gitHash && storedMtime !== undefined && current.mtime > 0) {
+    if (Math.abs(current.mtime - storedMtime) < 1000) return true // fresh
+  }
+
+  // Stale — purge old memories for this file
+  purgeFileMemories(absPath, projectId)
+  return false
+}
+
+/**
+ * Upsert a single file memory: update existing or create new.
+ * For read-tool tracking where we want exactly one memory per file.
+ */
+function upsertFileMemory(
+  content: string,
+  projectId: string,
+  filePath: string,
+  tags: string[],
+  source: string,
+  sessionId?: string,
+): void {
+  const absPath = path.resolve(filePath)
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 1 })
+
+  if (existing.length > 0) {
+    const memory = existing[0]!
+    updateMemory(memory.id, { content, source })
+    // Refresh fingerprint tags
+    const fpTags = buildFingerprintTags(filePath)
+    const nonFpTags = getTagsForMemory(memory.id).filter(
+      (t) => !t.startsWith("git:") && !t.startsWith("mtime:"),
+    )
+    setTags(memory.id, [...nonFpTags, ...fpTags])
+  } else {
+    storeMemory({
+      content,
+      category: "discovery",
+      projectId,
+      sessionId,
+      source,
+      tags,
+      force: true,
+    })
+  }
+}
+
 /**
  * Check if a stored file memory is still fresh by comparing fingerprints.
  * Returns { fresh, memory, storedContent } or null if no memory found.
@@ -159,11 +245,14 @@ export function scanProjectFiles(directory: string, projectId: string): void {
       // Skip large files (> 50KB)
       if (stat.size > 50 * 1024) continue
 
-      // Use mtime as cache key to avoid re-scanning unchanged files
+      // Skip if already scanned this process lifetime
       const cacheKey = `${fullPath}:${stat.mtimeMs}`
       if (scannedFiles.has(cacheKey)) continue
       scannedFiles.add(cacheKey)
 
+      // Skip if memory already has fresh content for this file
+      if (isFileFreshInMemory(fullPath, projectId, directory)) continue
+
       const content = fs.readFileSync(fullPath, "utf-8")
       if (!content.trim()) continue
 
@@ -224,7 +313,6 @@ function storePackageJsonMemory(content: string, projectId: string, filePath: st
         projectId,
         source: `file-scan: ${filePath}`,
         tags: ["project-config", "package.json", ...fpTags],
-        force: true,
       })
     }
   } catch {
@@ -254,7 +342,6 @@ function storeFileChunks(content: string, projectId: string, filePath: string, d
         projectId,
         source: `file-scan: ${filePath} (section ${i + 1})`,
         tags: ["file-content", path.basename(filePath).toLowerCase(), ...fpTags],
-        force: true,
       })
       stored++
     } catch {
@@ -329,15 +416,14 @@ export function extractFileKnowledge(
       const basename = path.basename(filePath)
       const fpTags = buildFingerprintTags(filePath)
 
-      storeMemory({
-        content: `File ${basename}: ${preview}`,
-        category: "discovery",
+      upsertFileMemory(
+        `File ${basename}: ${preview}`,
         projectId,
+        filePath,
+        ["file-content", basename.toLowerCase(), ...fpTags],
+        `tool-read: ${filePath}`,
         sessionId,
-        source: `tool-read: ${filePath}`,
-        tags: ["file-content", basename.toLowerCase(), ...fpTags],
-        force: true,
-      })
+      )
     } else if (toolName === "edit" || toolName === "write") {
       // Store what was edited/written
       const basename = path.basename(filePath)

package/src/dcp/auth.ts

@@ -0,0 +1,37 @@
+export function isSecureMode(): boolean {
+    return !!process.env.OPENCODE_SERVER_PASSWORD
+}
+
+export function getAuthorizationHeader(): string | undefined {
+    const password = process.env.OPENCODE_SERVER_PASSWORD
+    if (!password) return undefined
+
+    const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
+    // Use Buffer for Node.js base64 encoding (btoa may not be available in all Node versions)
+    const credentials = Buffer.from(`${username}:${password}`).toString("base64")
+    return `Basic ${credentials}`
+}
+
+export function configureClientAuth(client: any): any {
+    const authHeader = getAuthorizationHeader()
+
+    if (!authHeader) {
+        return client
+    }
+
+    // The SDK client has an internal client with request interceptors
+    // Access the underlying client to add the interceptor
+    const innerClient = client._client || client.client
+
+    if (innerClient?.interceptors?.request) {
+        innerClient.interceptors.request.use((request: Request) => {
+            // Only add auth header if not already present
+            if (!request.headers.has("Authorization")) {
+                request.headers.set("Authorization", authHeader)
+            }
+            return request
+        })
+    }
+
+    return client
+}

package/src/dcp/commands/context.ts

@@ -0,0 +1,265 @@
+/**
+ * DCP Context Command
+ * Shows a visual breakdown of token usage in the current session.
+ *
+ * TOKEN CALCULATION STRATEGY
+ * ==========================
+ * We minimize tokenizer estimation by leveraging API-reported values wherever possible.
+ *
+ * WHAT WE GET FROM THE API (exact):
+ *   - tokens.input    : Input tokens for each assistant response
+ *   - tokens.output   : Output tokens generated (includes text + tool calls)
+ *   - tokens.reasoning: Reasoning tokens used
+ *   - tokens.cache    : Cache read/write tokens
+ *
+ * HOW WE CALCULATE EACH CATEGORY:
+ *
+ *   SYSTEM = firstAssistant.input + cache.read - tokenizer(firstUserMessage)
+ *            The first response's input contains system + first user message.
+ *
+ *   TOOLS  = tokenizer(toolInputs + toolOutputs) - prunedTokens
+ *            We must tokenize tools anyway for pruning decisions.
+ *
+ *   USER   = tokenizer(all user messages)
+ *            User messages are typically small, so estimation is acceptable.
+ *
+ *   ASSISTANT = total - system - user - tools
+ *               Calculated as residual. This absorbs:
+ *               - Assistant text output tokens
+ *               - Reasoning tokens (if persisted by the model)
+ *               - Any estimation errors
+ *
+ *   TOTAL  = input + output + reasoning + cache.read + cache.write
+ *            Matches opencode's UI display.
+ *
+ * WHY ASSISTANT IS THE RESIDUAL:
+ *   If reasoning tokens persist in context (model-dependent), they semantically
+ *   belong with "Assistant" since reasoning IS assistant-generated content.
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatTokenCount } from "../ui/utils"
+import { isMessageCompacted } from "../shared-utils"
+import { isIgnoredUserMessage } from "../messages/utils"
+import { countTokens, getCurrentParams } from "../strategies/utils"
+import type { AssistantMessage, TextPart, ToolPart } from "@opencode-ai/sdk/v2"
+
+export interface ContextCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+interface TokenBreakdown {
+    system: number
+    user: number
+    assistant: number
+    tools: number
+    toolCount: number
+    prunedTokens: number
+    prunedToolCount: number
+    prunedMessageCount: number
+    total: number
+}
+
+function analyzeTokens(state: SessionState, messages: WithParts[]): TokenBreakdown {
+    const breakdown: TokenBreakdown = {
+        system: 0,
+        user: 0,
+        assistant: 0,
+        tools: 0,
+        toolCount: 0,
+        prunedTokens: state.stats.totalPruneTokens,
+        prunedToolCount: state.prune.tools.size,
+        prunedMessageCount: state.prune.messages.size,
+        total: 0,
+    }
+
+    let firstAssistant: AssistantMessage | undefined
+    for (const msg of messages) {
+        if (msg.info.role === "assistant") {
+            const assistantInfo = msg.info as AssistantMessage
+            if (assistantInfo.tokens?.input > 0 || assistantInfo.tokens?.cache?.read > 0) {
+                firstAssistant = assistantInfo
+                break
+            }
+        }
+    }
+
+    let lastAssistant: AssistantMessage | undefined
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]!
+        if (msg.info.role === "assistant") {
+            const assistantInfo = msg.info as AssistantMessage
+            if (assistantInfo.tokens?.output > 0) {
+                lastAssistant = assistantInfo
+                break
+            }
+        }
+    }
+
+    const apiInput = lastAssistant?.tokens?.input || 0
+    const apiOutput = lastAssistant?.tokens?.output || 0
+    const apiReasoning = lastAssistant?.tokens?.reasoning || 0
+    const apiCacheRead = lastAssistant?.tokens?.cache?.read || 0
+    const apiCacheWrite = lastAssistant?.tokens?.cache?.write || 0
+    breakdown.total = apiInput + apiOutput + apiReasoning + apiCacheRead + apiCacheWrite
+
+    const userTextParts: string[] = []
+    const toolInputParts: string[] = []
+    const toolOutputParts: string[] = []
+    let firstUserText = ""
+    let foundFirstUser = false
+    const foundToolIds = new Set<string>()
+
+    for (const msg of messages) {
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        const isCompacted = isMessageCompacted(state, msg)
+        const isIgnoredUser = msg.info.role === "user" && isIgnoredUserMessage(msg)
+
+        for (const part of parts) {
+            if (part.type === "tool") {
+                const toolPart = part as ToolPart
+                if (toolPart.callID && !foundToolIds.has(toolPart.callID)) {
+                    breakdown.toolCount++
+                    foundToolIds.add(toolPart.callID)
+                }
+
+                const isPruned = toolPart.callID && state.prune.tools.has(toolPart.callID)
+                if (!isCompacted && !isPruned) {
+                    if (toolPart.state?.input) {
+                        const inputStr =
+                            typeof toolPart.state.input === "string"
+                                ? toolPart.state.input
+                                : JSON.stringify(toolPart.state.input)
+                        toolInputParts.push(inputStr)
+                    }
+
+                    if (toolPart.state?.status === "completed" && toolPart.state?.output) {
+                        const outputStr =
+                            typeof toolPart.state.output === "string"
+                                ? toolPart.state.output
+                                : JSON.stringify(toolPart.state.output)
+                        toolOutputParts.push(outputStr)
+                    }
+                }
+            } else if (
+                part.type === "text" &&
+                msg.info.role === "user" &&
+                !isCompacted &&
+                !isIgnoredUser
+            ) {
+                const textPart = part as TextPart
+                const text = textPart.text || ""
+                userTextParts.push(text)
+                if (!foundFirstUser) {
+                    firstUserText += text
+                }
+            }
+        }
+
+        if (msg.info.role === "user" && !isIgnoredUser && !foundFirstUser) {
+            foundFirstUser = true
+        }
+    }
+
+    const firstUserTokens = countTokens(firstUserText)
+    breakdown.user = countTokens(userTextParts.join("\n"))
+    const toolInputTokens = countTokens(toolInputParts.join("\n"))
+    const toolOutputTokens = countTokens(toolOutputParts.join("\n"))
+
+    if (firstAssistant) {
+        const firstInput =
+            (firstAssistant.tokens?.input || 0) + (firstAssistant.tokens?.cache?.read || 0)
+        breakdown.system = Math.max(0, firstInput - firstUserTokens)
+    }
+
+    breakdown.tools = toolInputTokens + toolOutputTokens
+    breakdown.assistant = Math.max(
+        0,
+        breakdown.total - breakdown.system - breakdown.user - breakdown.tools,
+    )
+
+    return breakdown
+}
+
+function createBar(value: number, maxValue: number, width: number, char: string = "█"): string {
+    if (maxValue === 0) return ""
+    const filled = Math.round((value / maxValue) * width)
+    const bar = char.repeat(Math.max(0, filled))
+    return bar
+}
+
+function formatContextMessage(breakdown: TokenBreakdown): string {
+    const lines: string[] = []
+    const barWidth = 30
+
+    const toolsInContext = breakdown.toolCount - breakdown.prunedToolCount
+    const toolsLabel = `Tools (${toolsInContext})`
+
+    const categories = [
+        { label: "System", value: breakdown.system, char: "█" },
+        { label: "User", value: breakdown.user, char: "▓" },
+        { label: "Assistant", value: breakdown.assistant, char: "▒" },
+        { label: toolsLabel, value: breakdown.tools, char: "░" },
+    ] as const
+
+    const maxLabelLen = Math.max(...categories.map((c) => c.label.length))
+
+    lines.push("╭───────────────────────────────────────────────────────────╮")
+    lines.push("│                  DCP Context Analysis                     │")
+    lines.push("╰───────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push("Session Context Breakdown:")
+    lines.push("─".repeat(60))
+    lines.push("")
+
+    for (const cat of categories) {
+        const bar = createBar(cat.value, breakdown.total, barWidth, cat.char)
+        const percentage =
+            breakdown.total > 0 ? ((cat.value / breakdown.total) * 100).toFixed(1) : "0.0"
+        const labelWithPct = `${cat.label.padEnd(maxLabelLen)} ${percentage.padStart(5)}% `
+        const valueStr = formatTokenCount(cat.value).padStart(13)
+        lines.push(`${labelWithPct}│${bar.padEnd(barWidth)}│${valueStr}`)
+    }
+
+    lines.push("")
+    lines.push("─".repeat(60))
+    lines.push("")
+
+    lines.push("Summary:")
+
+    if (breakdown.prunedTokens > 0) {
+        const withoutPruning = breakdown.total + breakdown.prunedTokens
+        const pruned = []
+        if (breakdown.prunedToolCount > 0) pruned.push(`${breakdown.prunedToolCount} tools`)
+        if (breakdown.prunedMessageCount > 0)
+            pruned.push(`${breakdown.prunedMessageCount} messages`)
+        lines.push(
+            `  Pruned:          ${pruned.join(", ")} (~${formatTokenCount(breakdown.prunedTokens)})`,
+        )
+        lines.push(`  Current context: ~${formatTokenCount(breakdown.total)}`)
+        lines.push(`  Without DCP:     ~${formatTokenCount(withoutPruning)}`)
+    } else {
+        lines.push(`  Current context: ~${formatTokenCount(breakdown.total)}`)
+    }
+
+    lines.push("")
+
+    return lines.join("\n")
+}
+
+export async function handleContextCommand(ctx: ContextCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    const breakdown = analyzeTokens(state, messages)
+
+    const message = formatContextMessage(breakdown)
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+}

package/src/dcp/commands/help.ts

@@ -0,0 +1,73 @@
+/**
+ * DCP Help command handler.
+ * Shows available DCP commands and their descriptions.
+ */
+
+import type { Logger } from "../logger"
+import type { PluginConfig } from "../config"
+import type { SessionState, WithParts } from "../state"
+import { sendIgnoredMessage } from "../ui/notification"
+import { getCurrentParams } from "../strategies/utils"
+
+export interface HelpCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+const BASE_COMMANDS: [string, string][] = [
+    ["/dcp context", "Show token usage breakdown for current session"],
+    ["/dcp stats", "Show DCP pruning statistics"],
+    ["/dcp sweep [n]", "Prune tools since last user message, or last n tools"],
+    ["/dcp manual [on|off]", "Toggle manual mode or set explicit state"],
+]
+
+const TOOL_COMMANDS: Record<string, [string, string]> = {
+    prune: ["/dcp prune [focus]", "Trigger manual prune tool execution"],
+    distill: ["/dcp distill [focus]", "Trigger manual distill tool execution"],
+    compress: ["/dcp compress [focus]", "Trigger manual compress tool execution"],
+}
+
+function getVisibleCommands(config: PluginConfig): [string, string][] {
+    const commands = [...BASE_COMMANDS]
+    for (const tool of ["prune", "distill", "compress"] as const) {
+        if (config.tools[tool].permission !== "deny") {
+            commands.push(TOOL_COMMANDS[tool]!)
+        }
+    }
+    return commands
+}
+
+function formatHelpMessage(manualMode: boolean, config: PluginConfig): string {
+    const commands = getVisibleCommands(config)
+    const colWidth = Math.max(...commands.map(([cmd]) => cmd.length)) + 4
+    const lines: string[] = []
+
+    lines.push("╭─────────────────────────────────────────────────────────────────────────╮")
+    lines.push("│                              DCP Commands                               │")
+    lines.push("╰─────────────────────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push(`  ${"Manual mode:".padEnd(colWidth)}${manualMode ? "ON" : "OFF"}`)
+    lines.push("")
+    for (const [cmd, desc] of commands) {
+        lines.push(`  ${cmd.padEnd(colWidth)}${desc}`)
+    }
+    lines.push("")
+
+    return lines.join("\n")
+}
+
+export async function handleHelpCommand(ctx: HelpCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    const { config } = ctx
+    const message = formatHelpMessage(state.manualMode, config)
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Help command executed")
+}

package/src/dcp/commands/manual.ts

@@ -0,0 +1,131 @@
+/**
+ * DCP Manual mode command handler.
+ * Handles toggling manual mode and triggering individual tool executions.
+ *
+ * Usage:
+ *   /dcp manual [on|off]  - Toggle manual mode or set explicit state
+ *   /dcp prune [focus]     - Trigger manual prune execution
+ *   /dcp distill [focus]   - Trigger manual distill execution
+ *   /dcp compress [focus]  - Trigger manual compress execution
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import type { PluginConfig } from "../config"
+import { sendIgnoredMessage } from "../ui/notification"
+import { getCurrentParams } from "../strategies/utils"
+import { syncToolCache } from "../state/tool-cache"
+import { buildToolIdList } from "../messages/utils"
+import { buildPrunableToolsList } from "../messages/inject"
+
+const MANUAL_MODE_ON =
+    "Manual mode is now ON. Use /dcp prune, /dcp distill, or /dcp compress to trigger context tools manually."
+
+const MANUAL_MODE_OFF = "Manual mode is now OFF."
+
+const NO_PRUNABLE_TOOLS = "No prunable tool outputs are currently available for manual triggering."
+
+const PRUNE_TRIGGER_PROMPT = [
+    "<prune triggered manually>",
+    "Manual mode trigger received. You must now use the prune tool exactly once.",
+    "Find the most significant set of prunable tool outputs to remove safely.",
+    "Follow prune policy and avoid pruning outputs that may be needed later.",
+    "Return after prune with a brief explanation of what you pruned and why.",
+].join("\n\n")
+
+const DISTILL_TRIGGER_PROMPT = [
+    "<distill triggered manually>",
+    "Manual mode trigger received. You must now use the distill tool.",
+    "Select the most information-dense prunable outputs and distill them into complete technical substitutes.",
+    "Be exhaustive and preserve all critical technical details.",
+    "Return after distill with a brief explanation of what was distilled and why.",
+].join("\n\n")
+
+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.",
+].join("\n\n")
+
+function getTriggerPrompt(
+    tool: "prune" | "distill" | "compress",
+    context?: string,
+    userFocus?: string,
+): string {
+    const base =
+        tool === "prune"
+            ? PRUNE_TRIGGER_PROMPT
+            : tool === "distill"
+              ? DISTILL_TRIGGER_PROMPT
+              : COMPRESS_TRIGGER_PROMPT
+
+    const sections = [base]
+    if (userFocus && userFocus.trim().length > 0) {
+        sections.push(`Additional user focus:\n${userFocus.trim()}`)
+    }
+    if (context) {
+        sections.push(context)
+    }
+
+    return sections.join("\n\n")
+}
+
+export interface ManualCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+export async function handleManualToggleCommand(
+    ctx: ManualCommandContext,
+    modeArg?: string,
+): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    if (modeArg === "on") {
+        state.manualMode = true
+    } else if (modeArg === "off") {
+        state.manualMode = false
+    } else {
+        state.manualMode = !state.manualMode
+    }
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(
+        client,
+        sessionId,
+        state.manualMode ? MANUAL_MODE_ON : MANUAL_MODE_OFF,
+        params,
+        logger,
+    )
+
+    logger.info("Manual mode toggled", { manualMode: state.manualMode })
+}
+
+export async function handleManualTriggerCommand(
+    ctx: ManualCommandContext,
+    tool: "prune" | "distill" | "compress",
+    userFocus?: string,
+): Promise<string | null> {
+    const { client, state, config, logger, sessionId, messages } = ctx
+
+    if (tool === "prune" || tool === "distill") {
+        syncToolCache(state, config, logger, messages)
+        buildToolIdList(state, messages, logger)
+        const prunableToolsList = buildPrunableToolsList(state, config, logger)
+        if (!prunableToolsList) {
+            const params = getCurrentParams(state, messages, logger)
+            await sendIgnoredMessage(client, sessionId, NO_PRUNABLE_TOOLS, params, logger)
+            return null
+        }
+
+        return getTriggerPrompt(tool, prunableToolsList, userFocus)
+    }
+
+    return getTriggerPrompt("compress", undefined, userFocus)
+}