fix: restore onIdle LLM analysis and remove dead code

- Restore model-selector.ts for LLM model selection with provider fallback
- Restore runLlmAnalysis() and replacePrunedToolOutputs() in janitor.ts
- Restore buildAnalysisPrompt() and minimizeMessages() in prompt.ts
- Restore pruning.txt prompt template
- Restore ModelInfo interface and state.model map for model caching
- Add model caching back to hooks.ts chat.params handler
- Remove dead code: getNumericIdsForActual, getNumericId, getAllMappings, hasMapping, getNextId

Author: Tarquinen

lib/api-formats/prunable-list.ts

@@ -11,7 +11,7 @@
  */
 
 import { extractParameterKey } from '../ui/display-utils'
-import { getOrCreateNumericId, getNumericId } from '../state/id-mapping'
+import { getOrCreateNumericId } from '../state/id-mapping'
 
 export interface ToolMetadata {
     tool: string
@@ -107,23 +107,6 @@ export function buildEndInjection(
     return parts.join('\n\n')
 }
 
-/**
- * Gets the numeric IDs for a list of actual tool call IDs.
- * Used when the prune tool needs to show what was pruned.
- */
-export function getNumericIdsForActual(
-    sessionId: string,
-    actualIds: string[]
-): number[] {
-    return actualIds
-        .map(id => getNumericId(sessionId, id))
-        .filter((id): id is number => id !== undefined)
-}
-
-// ============================================================================
-// Injection Functions
-// ============================================================================
-
 // ============================================================================
 // OpenAI Chat / Anthropic Format
 // ============================================================================

lib/core/janitor.ts

@@ -1,6 +1,9 @@
+import { z } from "zod"
 import type { Logger } from "../logger"
 import type { PruningStrategy } from "../config"
 import type { PluginState } from "../state"
+import { buildAnalysisPrompt } from "./prompt"
+import { selectModel, extractModelFromSession } from "../model-selector"
 import { estimateTokensBatch, formatTokenCount } from "../tokenizer"
 import { saveSessionState } from "../state/persistence"
 import { ensureSessionRestored } from "../state"
@@ -142,9 +145,21 @@ async function runWithStrategies(
             return !metadata || !config.protectedTools.includes(metadata.tool)
         }).length
 
-        // For onIdle, we currently don't have AI analysis implemented
-        // This is a placeholder for future idle pruning strategies
-        const llmPrunedIds: string[] = []
+        // PHASE 1: LLM ANALYSIS
+        let llmPrunedIds: string[] = []
+
+        if (strategies.includes('ai-analysis') && unprunedToolCallIds.length > 0) {
+            llmPrunedIds = await runLlmAnalysis(
+                ctx,
+                sessionID,
+                sessionInfo,
+                messages,
+                unprunedToolCallIds,
+                alreadyPrunedIds,
+                toolMetadata,
+                options
+            )
+        }
 
         const finalNewlyPrunedIds = llmPrunedIds.filter(id => !alreadyPrunedIds.includes(id))
 
@@ -237,6 +252,147 @@ async function runWithStrategies(
     }
 }
 
+// ============================================================================
+// LLM Analysis
+// ============================================================================
+
+async function runLlmAnalysis(
+    ctx: JanitorContext,
+    sessionID: string,
+    sessionInfo: any,
+    messages: any[],
+    unprunedToolCallIds: string[],
+    alreadyPrunedIds: string[],
+    toolMetadata: Map<string, { tool: string, parameters?: any }>,
+    options: PruningOptions
+): Promise<string[]> {
+    const { client, state, logger, config } = ctx
+
+    const protectedToolCallIds: string[] = []
+    const prunableToolCallIds = unprunedToolCallIds.filter(id => {
+        const metadata = toolMetadata.get(id)
+        if (metadata && config.protectedTools.includes(metadata.tool)) {
+            protectedToolCallIds.push(id)
+            return false
+        }
+        return true
+    })
+
+    if (prunableToolCallIds.length === 0) {
+        return []
+    }
+
+    const cachedModelInfo = state.model.get(sessionID)
+    const sessionModelInfo = extractModelFromSession(sessionInfo, logger)
+    const currentModelInfo = cachedModelInfo || sessionModelInfo
+
+    const modelSelection = await selectModel(currentModelInfo, logger, config.model, config.workingDirectory)
+
+    logger.info("janitor", `Model: ${modelSelection.modelInfo.providerID}/${modelSelection.modelInfo.modelID}`, {
+        source: modelSelection.source
+    })
+
+    if (modelSelection.failedModel && config.showModelErrorToasts) {
+        const skipAi = modelSelection.source === 'fallback' && config.strictModelSelection
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: skipAi ? "DCP: AI analysis skipped" : "DCP: Model fallback",
+                    message: skipAi
+                        ? `${modelSelection.failedModel.providerID}/${modelSelection.failedModel.modelID} failed\nAI analysis skipped (strictModelSelection enabled)`
+                        : `${modelSelection.failedModel.providerID}/${modelSelection.failedModel.modelID} failed\nUsing ${modelSelection.modelInfo.providerID}/${modelSelection.modelInfo.modelID}`,
+                    variant: "info",
+                    duration: 5000
+                }
+            })
+        } catch (toastError: any) {
+            // Ignore toast errors
+        }
+    }
+
+    if (modelSelection.source === 'fallback' && config.strictModelSelection) {
+        logger.info("janitor", "Skipping AI analysis (fallback model, strictModelSelection enabled)")
+        return []
+    }
+
+    const { generateObject } = await import('ai')
+
+    const sanitizedMessages = replacePrunedToolOutputs(messages, alreadyPrunedIds)
+
+    const analysisPrompt = buildAnalysisPrompt(
+        prunableToolCallIds,
+        sanitizedMessages,
+        alreadyPrunedIds,
+        protectedToolCallIds,
+        options.reason
+    )
+
+    await logger.saveWrappedContext(
+        "janitor-shadow",
+        [{ role: "user", content: analysisPrompt }],
+        {
+            sessionID,
+            modelProvider: modelSelection.modelInfo.providerID,
+            modelID: modelSelection.modelInfo.modelID,
+            candidateToolCount: prunableToolCallIds.length,
+            alreadyPrunedCount: alreadyPrunedIds.length,
+            protectedToolCount: protectedToolCallIds.length,
+            trigger: options.trigger,
+            reason: options.reason
+        }
+    )
+
+    const result = await generateObject({
+        model: modelSelection.model,
+        schema: z.object({
+            pruned_tool_call_ids: z.array(z.string()),
+            reasoning: z.string(),
+        }),
+        prompt: analysisPrompt
+    })
+
+    const rawLlmPrunedIds = result.object.pruned_tool_call_ids
+    const llmPrunedIds = rawLlmPrunedIds.filter(id =>
+        prunableToolCallIds.includes(id.toLowerCase())
+    )
+
+    if (llmPrunedIds.length > 0) {
+        const reasoning = result.object.reasoning.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim()
+        logger.info("janitor", `LLM reasoning: ${reasoning.substring(0, 200)}${reasoning.length > 200 ? '...' : ''}`)
+    }
+
+    return llmPrunedIds
+}
+
+function replacePrunedToolOutputs(messages: any[], prunedIds: string[]): any[] {
+    if (prunedIds.length === 0) return messages
+
+    const prunedIdsSet = new Set(prunedIds.map(id => id.toLowerCase()))
+
+    return messages.map(msg => {
+        if (!msg.parts) return msg
+
+        return {
+            ...msg,
+            parts: msg.parts.map((part: any) => {
+                if (part.type === 'tool' &&
+                    part.callID &&
+                    prunedIdsSet.has(part.callID.toLowerCase()) &&
+                    part.state?.output) {
+                    return {
+                        ...part,
+                        state: {
+                            ...part.state,
+                            output: '[Output removed to save context - information superseded or no longer needed]'
+                        }
+                    }
+                }
+                return part
+            })
+        }
+    })
+}
+
 // ============================================================================
 // Message parsing
 // ============================================================================

lib/core/prompt.ts

@@ -11,3 +11,130 @@ export function loadPrompt(name: string, vars?: Record<string, string>): string
     }
     return content
 }
+
+function minimizeMessages(messages: any[], alreadyPrunedIds?: string[], protectedToolCallIds?: string[]): any[] {
+    const prunedIdsSet = alreadyPrunedIds ? new Set(alreadyPrunedIds.map(id => id.toLowerCase())) : new Set()
+    const protectedIdsSet = protectedToolCallIds ? new Set(protectedToolCallIds.map(id => id.toLowerCase())) : new Set()
+
+    return messages.map(msg => {
+        const minimized: any = {
+            role: msg.info?.role
+        }
+
+        if (msg.parts) {
+            minimized.parts = msg.parts
+                .filter((part: any) => {
+                    if (part.type === 'step-start' || part.type === 'step-finish') {
+                        return false
+                    }
+                    return true
+                })
+                .map((part: any) => {
+                    if (part.type === 'text') {
+                        if (part.ignored) {
+                            return null
+                        }
+                        return {
+                            type: 'text',
+                            text: part.text
+                        }
+                    }
+
+                    // TODO: This should use the opencode normalized system instead of per provider settings
+                    if (part.type === 'reasoning') {
+                        // Calculate encrypted content size if present
+                        let encryptedContentLength = 0
+                        if (part.metadata?.openai?.reasoningEncryptedContent) {
+                            encryptedContentLength = part.metadata.openai.reasoningEncryptedContent.length
+                        } else if (part.metadata?.anthropic?.signature) {
+                            encryptedContentLength = part.metadata.anthropic.signature.length
+                        } else if (part.metadata?.google?.thoughtSignature) {
+                            encryptedContentLength = part.metadata.google.thoughtSignature.length
+                        }
+
+                        return {
+                            type: 'reasoning',
+                            text: part.text,
+                            textLength: part.text?.length || 0,
+                            encryptedContentLength,
+                            ...(part.time && { time: part.time }),
+                            ...(part.metadata && { metadataKeys: Object.keys(part.metadata) })
+                        }
+                    }
+
+                    if (part.type === 'tool') {
+                        const callIDLower = part.callID?.toLowerCase()
+                        const isAlreadyPruned = prunedIdsSet.has(callIDLower)
+                        const isProtected = protectedIdsSet.has(callIDLower)
+
+                        let displayCallID = part.callID
+                        if (isAlreadyPruned) {
+                            displayCallID = '<already-pruned>'
+                        } else if (isProtected) {
+                            displayCallID = '<protected>'
+                        }
+
+                        const toolPart: any = {
+                            type: 'tool',
+                            toolCallID: displayCallID,
+                            tool: part.tool
+                        }
+
+                        if (part.state?.output) {
+                            toolPart.output = part.state.output
+                        }
+
+                        if (part.state?.input) {
+                            const input = part.state.input
+
+                            if (input.filePath && (part.tool === 'write' || part.tool === 'edit' || part.tool === 'multiedit' || part.tool === 'patch')) {
+                                toolPart.input = input
+                            }
+                            else if (input.filePath) {
+                                toolPart.input = { filePath: input.filePath }
+                            }
+                            else if (input.tool_calls && Array.isArray(input.tool_calls)) {
+                                toolPart.input = {
+                                    batch_summary: `${input.tool_calls.length} tool calls`,
+                                    tools: input.tool_calls.map((tc: any) => tc.tool)
+                                }
+                            }
+                            else {
+                                toolPart.input = input
+                            }
+                        }
+
+                        return toolPart
+                    }
+
+                    return null
+                })
+                .filter(Boolean)
+        }
+
+        return minimized
+    }).filter(msg => {
+        return msg.parts && msg.parts.length > 0
+    })
+}
+
+export function buildAnalysisPrompt(
+    unprunedToolCallIds: string[],
+    messages: any[],
+    alreadyPrunedIds?: string[],
+    protectedToolCallIds?: string[],
+    reason?: string
+): string {
+    const minimizedMessages = minimizeMessages(messages, alreadyPrunedIds, protectedToolCallIds)
+    const messagesJson = JSON.stringify(minimizedMessages, null, 2).replace(/\\n/g, '\n')
+
+    const reasonContext = reason
+        ? `\nContext: The AI has requested pruning with the following reason: "${reason}"\nUse this context to inform your decisions about what is most relevant to keep.`
+        : ''
+
+    return loadPrompt("pruning", {
+        reason_context: reasonContext,
+        available_tool_call_ids: unprunedToolCallIds.join(", "),
+        session_history: messagesJson
+    })
+}

lib/hooks.ts

@@ -65,6 +65,7 @@ export function createChatParamsHandler(
     return async (input: any, _output: any) => {
         const sessionId = input.sessionID
         let providerID = (input.provider as any)?.info?.id || input.provider?.id
+        const modelID = input.model?.id
 
         if (!providerID && input.message?.model?.providerID) {
             providerID = input.message.model.providerID
@@ -89,6 +90,14 @@ export function createChatParamsHandler(
             }
         }
 
+        // Cache model info for the session (used by janitor for model selection)
+        if (providerID && modelID) {
+            state.model.set(sessionId, {
+                providerID: providerID,
+                modelID: modelID
+            })
+        }
+
         // Build position-based mapping for Gemini (which loses tool call IDs in native format)
         if (providerID === 'google' || providerID === 'google-vertex') {
             try {