@comfanion/usethis_search 4.3.0-dev.2 → 4.3.0-dev.4

package/hooks/message-before.ts

@@ -1,33 +1,28 @@
 /**
- * Workspace Context Injection Hook
+ * History Pruning Hook (v3 — workspace-only, DCP handles the rest)
  *
- * Uses "experimental.chat.messages.transform" to inject workspace chunks
- * into the conversation context. The AI sees attached chunks as part of
- * the message stream — no read() needed.
+ * Uses "experimental.chat.messages.transform" to prune old workspace tool
+ * outputs from chat history. Only the LAST workspace state is kept in context.
  *
- * Architecture:
- *   search("auth") → workspaceCache.attach(chunks)
- *   [this hook]    → inject cached chunks into messages (grouped by file)
- *   AI sees:       chunk content organized by file
- *   Chat history:  search outputs auto-pruned (chunks already in workspace)
+ * v3: Removed read pruning and tool compaction — delegated to DCP plugin
+ *     (@tarquinen/opencode-dcp) which handles deduplication, supersede-writes,
+ *     error purging, and agent-facing discard/extract tools.
  *
- * Two responsibilities:
- *   1. INJECT: synthetic <workspace_context> message before last user message
- *   2. PRUNE:  replace old search tool outputs with compact summaries
- *      (the chunk content is already in workspace injection — no need to keep
- *       the big search output in chat history)
+ *     This hook ONLY handles workspace state pruning — something DCP can't do
+ *     because it doesn't understand that different search queries produce
+ *     workspace state blocks that supersede each other.
  *
- * Injection strategy:
- *   - Injects a synthetic user message with <workspace_context> BEFORE
- *     the last user message (so AI sees chunks as "already known" context)
- *   - Uses cache_control: ephemeral for Anthropic prompt caching (90% savings)
- *   - Groups chunks by file: search-main first, then search-graph, then manual
- *   - Within each file: chunks sorted by chunkIndex (order in file)
- *   - Shows chunk metadata: function name, heading, line numbers
+ * Pruning strategy:
+ *   Find all outputs from search/workspace_* tools that contain
+ *   <workspace_state> blocks. Keep only the LAST one. Replace the rest
+ *   with compact 1-line summaries.
+ *
+ * DCP companion config (.opencode/dcp.jsonc):
+ *   Our workspace tools are added to DCP's protectedTools so DCP
+ *   doesn't try to prune them (we handle them ourselves).
  */
 
 import type { SessionState } from "./types.ts"
-import { workspaceCache } from "../cache/manager.ts"
 
 // ── Types matching OpenCode plugin message format ───────────────────────────
 
@@ -35,6 +30,10 @@ interface MessagePart {
   type: string
   content?: string
   text?: string
+  tool?: string
+  state?: { status?: string; output?: string }
+  input?: any
+  id?: string
   [key: string]: any
 }
 
@@ -47,332 +46,53 @@ interface Message {
   [key: string]: any
 }
 
+// ── Constants ───────────────────────────────────────────────────────────────
+
+/** Tools that return full workspace state in their output. */
+const WORKSPACE_TOOLS = new Set([
+  "search",
+  "workspace_list",
+  "workspace_forget",
+  "workspace_clear",
+  "workspace_restore",
+])
+
+/** Minimum output length to consider pruning. Short outputs are kept as-is. */
+const MIN_PRUNE_LENGTH = 500
+
 // ── Hook ────────────────────────────────────────────────────────────────────
 
 /**
- * Create the messages transform handler that injects workspace context.
+ * Create the history pruning handler.
+ * Only prunes old workspace state outputs — DCP handles everything else.
  */
 export function createWorkspaceInjectionHandler(state: SessionState) {
   return async (_input: {}, output: { messages: Message[] }) => {
-    // Don't inject or prune for sub-agents (title generation, etc.)
+    // Don't prune for sub-agents (title generation, etc.)
     if (state.isSubAgent) return
 
-    // ── Prune & Compact: optimize chat history ────────────────────────────
-    // 1. Prune: replace old tool outputs with compact summaries
-    // 2. Compact: remove old tool calls entirely (keep last N turns)
-    // Files are already in workspace injection — no need for big outputs
-    // in chat history. This runs even when workspace is empty
-    // (handles case where workspace was cleared but old outputs remain).
-    const wsConfig = workspaceCache.getConfig()
-    if (wsConfig.autoPruneSearch !== false) {
-      pruneSearchToolOutputs(output.messages)
-      pruneReadToolOutputs(output.messages)
-      compactOldToolCalls(output.messages)
-    }
-
-    let entries = workspaceCache.getAll()
-
-    // Nothing in workspace — skip injection (but pruning already happened)
-    if (entries.length === 0) return
-
-    // ── Freshen: re-read changed files from disk ──────────────────────────
-    const { updated, removed } = await workspaceCache.freshen()
-    if (updated > 0 || removed > 0) {
-      // Re-fetch entries after freshen (some may be removed)
-      entries = workspaceCache.getAll()
-      if (entries.length === 0) return
-    }
-
-     // ── Build workspace context block ─────────────────────────────────────
-     const totalTokens = workspaceCache.totalTokens
-     const chunkCount = entries.length
-
-     // Group chunks by file path
-     const byFile = new Map<string, typeof entries>()
-     for (const entry of entries) {
-       if (!byFile.has(entry.path)) {
-         byFile.set(entry.path, [])
-       }
-       byFile.get(entry.path)!.push(entry)
-     }
-
-     // Sort chunks within each file by chunkIndex
-     for (const chunks of byFile.values()) {
-       chunks.sort((a, b) => a.chunkIndex - b.chunkIndex)
-     }
-
-     const fileCount = byFile.size
-
-     let workspace = `<workspace_context chunks="${chunkCount}" files="${fileCount}" tokens="${totalTokens}">\n`
-
-     // Group by role for clear structure
-     const mainFiles = entries.filter(e => e.role === "search-main")
-     const contextFiles = entries.filter(e => e.role === "search-context")
-     const graphFiles = entries.filter(e => e.role === "search-graph")
-     const manualFiles = entries.filter(e => e.role === "manual")
-
-     // Main search results
-     if (mainFiles.length > 0) {
-       workspace += formatChunksByFile(mainFiles, byFile)
-     }
-
-     // Expanded context (class methods, class headers)
-     if (contextFiles.length > 0) {
-       workspace += `\n<!-- Expanded context (class methods/headers for completeness) -->\n`
-       workspace += formatChunksByFile(contextFiles, byFile)
-     }
-
-     // Graph relations (imports, extends, used_by)
-     if (graphFiles.length > 0) {
-       workspace += `\n<!-- Search graph relations -->\n`
-       workspace += formatChunksByFile(graphFiles, byFile)
-     }
-
-     // Manually attached chunks
-     if (manualFiles.length > 0) {
-       workspace += `\n<!-- Manually attached -->\n`
-       workspace += formatChunksByFile(manualFiles, byFile)
-     }
-
-     workspace += `</workspace_context>`
-
-    // ── Inject into messages ──────────────────────────────────────────────
-    // Get base message for creating proper synthetic message
-    const lastUserMessage = findLastUserMessage(output.messages)
-    if (!lastUserMessage) return
-
-    // Create proper synthetic workspace message (like DCP does)
-    const workspaceMessage = createSyntheticUserMessage(lastUserMessage, workspace)
-
-    // Add to end of messages (like DCP does with push, not splice)
-    output.messages.push(workspaceMessage)
-  }
-}
-
-/**
- * Create a properly-formed synthetic user message for workspace injection.
- * Follows OpenCode SDK message format to avoid "Invalid prompt" errors.
- */
-function createSyntheticUserMessage(baseMessage: Message, content: string): Message {
-  const userInfo = baseMessage.info as any
-  const now = Date.now()
-
-  return {
-    info: {
-      id: "msg_workspace_01234567890123",
-      sessionID: userInfo.sessionID,
-      role: "user",
-      agent: userInfo.agent || "code",
-      model: userInfo.model,
-      time: { created: now },
-      variant: userInfo.variant,
-    },
-    parts: [
-      {
-        id: "prt_workspace_01234567890123",
-        sessionID: userInfo.sessionID,
-        messageID: "msg_workspace_01234567890123",
-        type: "text",
-        text: content,  // TEXT not content!
-        // Anthropic prompt caching for 90% token savings
-        cache_control: { type: "ephemeral" },
-      },
-    ],
-  }
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-/**
- * Format chunks grouped by file path.
- * Groups chunks from the same file together, sorted by chunkIndex.
- */
-function formatChunksByFile(
-  entries: ReturnType<typeof workspaceCache.getAll>,
-  byFile: Map<string, ReturnType<typeof workspaceCache.getAll>>
-): string {
-  let output = ""
-  const processedFiles = new Set<string>()
-
-  for (const entry of entries) {
-    // Skip if we already processed this file
-    if (processedFiles.has(entry.path)) continue
-    processedFiles.add(entry.path)
-
-    const chunks = byFile.get(entry.path) || []
-    output += formatFileWithChunks(entry.path, chunks)
-  }
-
-  return output
-}
-
-/**
- * Format a single file with all its chunks.
- */
-function formatFileWithChunks(
-  filePath: string,
-  chunks: ReturnType<typeof workspaceCache.getAll>
-): string {
-  let block = `\n## ${filePath}\n`
-
-  // Chunk list comment: "Chunks: 2, 5 (partial file)"
-  const chunkIndices = chunks.map(c => c.chunkIndex).join(", ")
-  const isPartial = chunks.length > 0 ? " (partial file)" : ""
-  block += `<!-- Chunks: ${chunkIndices}${isPartial} -->\n`
-
-  // Format each chunk
-  for (const chunk of chunks) {
-    block += formatChunk(chunk)
-  }
-
-  return block
-}
-
-/**
- * Format a single chunk with metadata and line numbers (cat -n style).
- * This allows the agent to see exact line numbers without needing grep.
- */
-function formatChunk(entry: ReturnType<typeof workspaceCache.getAll>[0]): string {
-  let block = ""
-
-  // Chunk subheader: "### Chunk N: description"
-  const description = entry.metadata?.function_name || entry.metadata?.heading_context || "code"
-  block += `\n### Chunk ${entry.chunkIndex}: ${description}\n`
-
-  // Chunk metadata line
-  const meta: string[] = []
-  if (entry.score !== undefined) meta.push(`score: ${entry.score.toFixed(3)}`)
-  if (entry.metadata?.language) meta.push(entry.metadata.language)
-  if (entry.metadata?.class_name) meta.push(`class: ${entry.metadata.class_name}`)
-  if (entry.metadata?.startLine !== undefined && entry.metadata?.endLine !== undefined) {
-    meta.push(`lines: ${entry.metadata.startLine}-${entry.metadata.endLine}`)
+    pruneWorkspaceToolOutputs(output.messages)
   }
-  if (entry.metadata?.relation) {
-    const mainBase = entry.metadata.mainChunkId?.split(":").pop() || "?"
-    meta.push(`${entry.metadata.relation} from ${mainBase}`)
-  }
-
-  if (meta.length > 0) {
-    block += `<!-- ${meta.join(" | ")} -->\n`
-  }
-
-  // Chunk content WITH LINE NUMBERS (cat -n style)
-  // This allows agent to reference exact lines without grep
-  const startLine = entry.metadata?.startLine ?? 1
-  const lines = entry.content.split("\n")
-  const lang = entry.metadata?.language || ""
-  
-  block += `\`\`\`${lang}\n`
-  
-  for (let i = 0; i < lines.length; i++) {
-    const lineNum = startLine + i
-    const lineContent = lines[i]
-    // Format: "  123| line content" (5 chars for line number + tab)
-    block += `${lineNum.toString().padStart(5, " ")}| ${lineContent}\n`
-  }
-  
-  block += `\`\`\`\n`
-
-  return block
 }
 
-function findLastUserMessage(messages: Message[]): Message | null {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.info?.role === "user") {
-      return messages[i]
-    }
-  }
-  return null
-}
-
-// ── Tool output pruning ─────────────────────────────────────────────────────
-
-/**
- * Minimum output length to consider pruning.
- * Short outputs (errors, "no results") are kept as-is.
- */
-const MIN_PRUNE_LENGTH = 500
-
-/**
- * Marker prefix that search tool outputs start with.
- * Used to identify search results in chat history.
- */
-const SEARCH_OUTPUT_MARKER = '## Search: "'
+// ── Workspace Tool Pruning ──────────────────────────────────────────────────
 
 /**
- * Replace search tool outputs in chat history with compact summaries.
+ * Replace old workspace tool outputs with compact summaries.
  *
- * Why: search() returns a big markdown block with file listings, scores, etc.
- * After workspace injection, the full file content is already in context.
- * Keeping the search output wastes tokens — replace it with a 1-line summary.
- *
- * Only prunes completed search calls with output longer than MIN_PRUNE_LENGTH.
- * The last search output is kept (the agent may still be referencing it).
- */
-export function pruneSearchToolOutputs(messages: Message[]): void {
-  // Find all search tool parts (completed, with long output)
-  const searchParts: { msgIdx: number; partIdx: number; part: MessagePart }[] = []
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]
-    const parts = Array.isArray(msg.parts) ? msg.parts : []
-
-    for (let j = 0; j < parts.length; j++) {
-      const part = parts[j]
-      if (
-        part.type === "tool" &&
-        part.tool === "search" &&
-        part.state?.status === "completed" &&
-        typeof part.state?.output === "string" &&
-        part.state.output.length > MIN_PRUNE_LENGTH &&
-        part.state.output.startsWith(SEARCH_OUTPUT_MARKER)
-      ) {
-        searchParts.push({ msgIdx: i, partIdx: j, part })
-      }
-    }
-  }
-
-  // Keep the last search output (agent may reference it) — prune the rest
-  if (searchParts.length <= 1) return
-
-  const toPrune = searchParts.slice(0, -1)
-
-  for (const { part } of toPrune) {
-    const output = part.state.output as string
-
-    // Extract query from output: ## Search: "query" (...)
-    const queryMatch = output.match(/^## Search: "([^"]+)"/)
-    const query = queryMatch?.[1] || "?"
-
-    // Extract file count from output: *N files (M chunks)...*
-    const filesMatch = output.match(/\*(\d+) files? \((\d+) chunks?\)/)
-    const fileCount = filesMatch?.[1] || "?"
-    const chunkCount = filesMatch?.[2] || "?"
-
-    // Extract attached count: ### Attached to workspace (N files)
-    const attachedMatch = output.match(/### Attached to workspace \((\d+) files?\)/)
-    const attachedCount = attachedMatch?.[1] || "0"
-
-    // Replace with compact summary
-    part.state.output =
-      `[Search "${query}" — ${fileCount} files (${chunkCount} chunks), ` +
-      `${attachedCount} attached to workspace. Full content available via workspace context.]`
-  }
-}
-
-/**
- * Replace read() tool outputs in chat history with compact summaries.
+ * Workspace tools (search, workspace_list, etc.) return full workspace
+ * state in their output. Only the LAST such output is kept — all previous
+ * ones are replaced with a 1-line summary.
  *
- * Why: read() returns full file content or large chunks.
- * After workspace injection (or auto-attach), the content is already in context.
- * Keeping the read output wastes tokens — replace it with a 1-line summary.
+ * This ensures only ONE copy of workspace state is in context at any time.
  *
- * Only prunes completed read calls with output longer than MIN_PRUNE_LENGTH.
- * The last read output is kept (the agent may still be referencing it).
+ * Note: DCP's deduplication only prunes IDENTICAL tool calls (same params).
+ * Two different search queries wouldn't be deduplicated by DCP, but both
+ * contain workspace state that supersedes each other. That's why we need
+ * this workspace-specific pruning.
  */
-export function pruneReadToolOutputs(messages: Message[]): void {
-  // Find all read tool parts (completed, with long output)
-  const readParts: { msgIdx: number; partIdx: number; part: MessagePart }[] = []
+export function pruneWorkspaceToolOutputs(messages: Message[]): void {
+  const wsParts: { msgIdx: number; partIdx: number; part: MessagePart }[] = []
 
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i]
@@ -382,185 +102,41 @@ export function pruneReadToolOutputs(messages: Message[]): void {
       const part = parts[j]
       if (
         part.type === "tool" &&
-        (part.tool === "read" || part.tool === "Read") &&
+        part.tool &&
+        WORKSPACE_TOOLS.has(part.tool) &&
         part.state?.status === "completed" &&
         typeof part.state?.output === "string" &&
         part.state.output.length > MIN_PRUNE_LENGTH
       ) {
-        readParts.push({ msgIdx: i, partIdx: j, part })
+        wsParts.push({ msgIdx: i, partIdx: j, part })
       }
     }
   }
 
-  // Keep the last read output (agent may reference it) — prune the rest
-  if (readParts.length <= 1) return
+  // Keep the last workspace tool output — prune the rest
+  if (wsParts.length <= 1) return
 
-  const toPrune = readParts.slice(0, -1)
+  const toPrune = wsParts.slice(0, -1)
 
   for (const { part } of toPrune) {
-    const output = part.state.output as string
-
-    // Extract file path from output or input
-    const filePath = part.input?.filePath || extractFilePathFromOutput(output)
+    const output = part.state!.output as string
 
-    // Check if it's a substituted output (already compact)
-    if (output.startsWith("[File ") || output.startsWith("[Lines ") || output.startsWith("✓ Attached chunk")) {
-      // Already substituted — keep as-is
-      continue
-    }
-
-    // Replace with compact summary
-    part.state.output = `[Read "${filePath || "file"}" — content available in workspace context]`
-  }
-}
-
-/**
- * Extract file path from read() output.
- * Output usually starts with file path or has markers.
- */
-function extractFilePathFromOutput(output: string): string | null {
-  // Try to find file path in first line
-  const firstLine = output.split("\n")[0]
-  
-  // Pattern: "## path/to/file.ts" or "path/to/file.ts"
-  const pathMatch = firstLine.match(/##?\s*(.+?\.(ts|js|go|py|md|txt|yaml|json|tsx|jsx|rs|java|kt|swift|c|cpp|h|cs|rb|php))/)
-  if (pathMatch) {
-    return pathMatch[1].trim()
-  }
-  
-  return null
-}
-
-// ── Tool Call Compaction ────────────────────────────────────────────────────
-
-/**
- * Remove old tool calls (search/read) from chat history.
- * 
- * Strategy:
- * - Keep last N turns (default: 5) — agent may reference recent calls
- * - Only compact search/read tools (not edit/write/grep/glob)
- * - Only compact completed calls with pruned outputs
- * - Remove both call + output parts
- * - Add compact marker at start showing how many calls removed
- * 
- * Why: Tool calls contain full args (200+ tokens). After pruning outputs,
- * the calls themselves are redundant — chunks already in workspace.
- * 
- * Savings: ~220 tokens per compacted call × N calls = 2K-10K tokens
- */
-const KEEP_LAST_N_TURNS = 5
-const COMPACT_TOOLS = ['search', 'read', 'Read']
-
-interface ToolCallPair {
-  msgIndex: number
-  callPart: MessagePart
-  outputPart?: MessagePart
-  tool: string
-  status: string
-  turnsSinceEnd: number
-}
-
-/**
- * Compact old tool calls by removing them from chat history.
- * Keeps last N turns intact.
- */
-export function compactOldToolCalls(messages: Message[]): void {
-  // Find all tool call pairs
-  const toolPairs = findToolCallPairs(messages)
-  
-  if (toolPairs.length === 0) return
-  
-  // Calculate turns from end for each pair
-  const totalTurns = messages.length
-  
-  // Filter: only old, completed, search/read with pruned outputs
-  const toCompact = toolPairs.filter(pair => {
-    const turnsFromEnd = totalTurns - pair.msgIndex
-    return (
-      turnsFromEnd > KEEP_LAST_N_TURNS &&
-      pair.status === 'completed' &&
-      COMPACT_TOOLS.includes(pair.tool) &&
-      pair.outputPart &&
-      isPrunedOutput(pair.outputPart.state?.output || '')
-    )
-  })
-  
-  if (toCompact.length === 0) return
-  
-  // Remove tool parts from messages
-  const removedIds = new Set<string>()
-  
-  for (const pair of toCompact) {
-    removedIds.add(pair.callPart.id)
-    if (pair.outputPart) {
-      removedIds.add(pair.outputPart.id)
-    }
-  }
-  
-  // Filter out removed parts from messages
-  for (const msg of messages) {
-    if (!msg.parts || !Array.isArray(msg.parts)) continue
-    msg.parts = msg.parts.filter(part => !removedIds.has(part.id))
-  }
-  
-  // Add compact marker to first user message
-  const firstUserMsg = messages.find(m => m?.info?.role === 'user')
-  if (firstUserMsg && firstUserMsg.parts) {
-    const marker = {
-      type: 'text',
-      text: `<!-- ${toCompact.length} tool calls compacted (search/read results in workspace) -->`,
-      id: 'compact-marker-' + Date.now(),
-    }
-    firstUserMsg.parts.unshift(marker)
-  }
-}
+    // Extract info from workspace_state tag
+    const wsMatch = output.match(/<workspace_state\s+chunks="(\d+)"\s+files="(\d+)"\s+tokens="(\d+)"/)
+    const chunks = wsMatch?.[1] || "?"
+    const files = wsMatch?.[2] || "?"
+    const tokens = wsMatch?.[3] || "?"
 
-/**
- * Find all tool call + output pairs in messages.
- */
-function findToolCallPairs(messages: Message[]): ToolCallPair[] {
-  const pairs: ToolCallPair[] = []
-  
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]
-    if (!msg.parts || !Array.isArray(msg.parts)) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === 'tool' && part.tool) {
-        const status = part.state?.status || 'unknown'
-        
-        // Find matching output part (usually in same message or next)
-        let outputPart: MessagePart | undefined
-        
-        // Check same message first
-        for (const p of msg.parts) {
-          if (p.type === 'tool' && p.tool === part.tool && p.state?.output && p.id !== part.id) {
-            outputPart = p
-            break
-          }
-        }
-        
-        pairs.push({
-          msgIndex: i,
-          callPart: part,
-          outputPart,
-          tool: part.tool,
-          status,
-          turnsSinceEnd: 0, // Will be calculated in compactOldToolCalls
-        })
-      }
+    // For search: extract query
+    const queryMatch = output.match(/^## Search: "([^"]+)"/)
+    const query = queryMatch?.[1]
+
+    if (query) {
+      part.state!.output =
+        `[Search "${query}" — workspace had ${chunks} chunks, ${files} files, ${tokens} tokens. Superseded by newer state.]`
+    } else {
+      part.state!.output =
+        `[Workspace state: ${chunks} chunks, ${files} files, ${tokens} tokens. Superseded by newer state.]`
     }
   }
-  
-  return pairs
-}
-
-/**
- * Check if output is pruned (compact format).
- */
-function isPrunedOutput(output: string): boolean {
-  if (!output) return false
-  
-  // Pruned outputs start with [ or ✓
-  return output.startsWith('[') || output.startsWith('✓')
 }

package/index.ts

@@ -5,7 +5,6 @@ import { workspace_list, workspace_forget, workspace_clear, workspace_restore }
 import FileIndexerPlugin from "./file-indexer"
 import { workspaceCache } from "./cache/manager"
 import { createWorkspaceInjectionHandler } from "./hooks/message-before"
-import { createToolSubstitutionHandler } from "./hooks/tool-substitution"
 import { createSessionState } from "./hooks/types"
 import { getWorkspaceConfig } from "./vectorizer/index.ts"
 
@@ -46,12 +45,10 @@ const UsethisSearchPlugin: Plugin = async ({ directory, client }) => {
 
     // ── Hooks ───────────────────────────────────────────────────────────
 
-    // Inject workspace files into message context (before LLM sees them)
+    // Prune old workspace/search tool outputs from chat history
+    // (no injection — each tool returns workspace state inline)
     "experimental.chat.messages.transform": createWorkspaceInjectionHandler(state),
 
-    // Substitute tool outputs when files are in workspace
-    "tool.execute.after": createToolSubstitutionHandler(state),
-
     // Detect sub-agents (title gen, summarizer) via system prompt
     "experimental.chat.system.transform": async (_input: unknown, output: { system: string[] }) => {
       const systemText = output.system.join("\n")

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "4.3.0-dev.2",
-  "description": "OpenCode plugin: semantic search with auto-attach, line numbers in workspace, simplified API (v4.3: auto-detect modes, read() caching, tool call compaction, 99% token reduction, no grep needed, LSP memory leak fixed)",
+  "version": "4.3.0-dev.4",
+  "description": "OpenCode plugin: semantic search with context-efficient workspace state (v4.3: no injection, each tool returns full state inline, auto-prune history, auto-detect modes, line numbers, LSP memory leak fixed)",
   "type": "module",
   "main": "./index.ts",
   "exports": {
@@ -25,6 +25,7 @@
     "tools/search.ts",
     "tools/codeindex.ts",
     "tools/workspace.ts",
+    "tools/workspace-state.ts",
     "tools/read-interceptor.ts",
     "cache/manager.ts",
     "hooks/message-before.ts",

package/tools/search.ts

@@ -1,10 +1,10 @@
 /**
- * Semantic Code Search Tool (v5 — chunk-based workspace injection)
+ * Semantic Code Search Tool (v6 — context-efficient workspace state)
  *
  * Uses local embeddings + LanceDB vector store via bundled vectorizer.
- * v5: Top N chunks + graph relations attached to workspace (chunk content only).
- *     Rest returned as summary only.
- *     AI sees chunks via message.before injection — no read() needed.
+ * v6: Each tool call returns full workspace state inline.
+ *     Previous call outputs are pruned from history by message-before hook.
+ *     No injection — workspace lives only in the latest tool output.
  *
  * Index data is stored in `.opencode/vectors/<index>/`.
  */
@@ -15,6 +15,7 @@ import fs from "fs/promises"
 
 import { CodebaseIndexer, getSearchConfig, getIndexer, releaseIndexer } from "../vectorizer/index.ts"
 import { workspaceCache } from "../cache/manager.ts"
+import { buildWorkspaceOutput } from "./workspace-state.ts"
 
 // ── Context Expansion Helpers ─────────────────────────────────────────────
 
@@ -186,7 +187,8 @@ Accepts any query - semantic search, file path, or chunk ID:
 - "src/auth.ts:chunk-5" → attaches specific chunk
 
 Results are optimized for context - top chunks auto-attached with expanded context 
-(related code, imports, class methods).
+(related code, imports, class methods). Returns full workspace state inline.
+Previous search outputs are automatically pruned from history.
 
 IMPORTANT: Workspace has limited token budget. Use workspace_forget() to remove 
 irrelevant files or old searches before adding new context.
@@ -287,7 +289,9 @@ Examples:
           workspaceCache.save().catch(() => {})
 
           const entry = workspaceCache.get(chunkId!)!
-          return `✓ Attached chunk to workspace\n\nChunk: ${chunkId}\nFile: ${chunk.file}\nTokens: ${entry.tokens.toLocaleString()}\nLanguage: ${chunk.language}\nLines: ${chunk.start_line}-${chunk.end_line}\n\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+          let result = `✓ Attached chunk to workspace\n\nChunk: ${chunkId}\nFile: ${chunk.file}\nTokens: ${entry.tokens.toLocaleString()}\nLanguage: ${chunk.language}\nLines: ${chunk.start_line}-${chunk.end_line}`
+          result += buildWorkspaceOutput()
+          return result
         } finally {
           releaseIndexer(projectRoot, indexName)
         }
@@ -333,7 +337,9 @@ Examples:
 
           workspaceCache.save().catch(() => {})
 
-          return `✓ Attached file to workspace\n\nFile: ${filePath}\nChunks: ${chunks.length}\nTokens: ${totalTokens.toLocaleString()}\nLanguage: ${chunks[0].language}\n\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+          let result = `✓ Attached file to workspace\n\nFile: ${filePath}\nChunks: ${chunks.length}\nTokens: ${totalTokens.toLocaleString()}\nLanguage: ${chunks[0].language}`
+          result += buildWorkspaceOutput()
+          return result
         } finally {
           releaseIndexer(projectRoot, indexName)
         }
@@ -515,7 +521,9 @@ Examples:
        if (topChunks.length === 0) {
          const scope = args.searchAll ? "any index" : `index "${indexName}"`
          const filterNote = args.filter ? ` with filter "${args.filter}"` : ""
-         return `No results found in ${scope}${filterNote} for: "${semanticQuery}" (min score: ${minScore})\n\nTry:\n- Different keywords or phrasing\n- Remove or broaden the filter\n- search({ query: "...", searchAll: true })`
+         let noResultsOutput = `No results found in ${scope}${filterNote} for: "${semanticQuery}" (min score: ${minScore})\n\nTry:\n- Different keywords or phrasing\n- Remove or broaden the filter\n- search({ query: "...", searchAll: true })`
+         noResultsOutput += buildWorkspaceOutput()
+         return noResultsOutput
        }
 
        // ══════════════════════════════════════════════════════════════════════
@@ -718,12 +726,13 @@ Examples:
          output += `\nUse \`workspace.attach(chunkId)\` to attach additional chunks.\n`
        }
 
-       // ── Footer ────────────────────────────────────────────────────────────
+       // ── Footer: total found ────────────────────────────────────────────
        const totalChunks = allResults.length
        output += `\n---\n`
-       output += `*${totalChunks} chunks found | `
-       output += `Workspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens*\n`
-       output += `*Attached chunks are in workspace context — reference them directly without read().*`
+       output += `*${totalChunks} chunks found*`
+
+       // ── Append full workspace state (replaces old injection approach) ──
+       output += buildWorkspaceOutput()
 
       return output
     } catch (error: any) {

package/tools/workspace-state.ts

@@ -0,0 +1,129 @@
+/**
+ * Workspace State Output Builder
+ *
+ * Builds full workspace state including chunk contents for tool responses.
+ * Each search/workspace tool appends this to its output.
+ * Previous tool outputs containing workspace state are pruned from history
+ * by the message-before hook — only the LATEST state is kept in context.
+ *
+ * This replaces the old injection approach (synthetic user message with
+ * <workspace_context>) — now each tool returns the state directly.
+ */
+
+import { workspaceCache, type WorkspaceEntry } from "../cache/manager.ts"
+
+/**
+ * Build the full workspace state output.
+ * Contains all chunks grouped by file with full content and metadata.
+ *
+ * Called by search(), workspace_list(), workspace_forget(),
+ * workspace_clear(), workspace_restore().
+ *
+ * Returns a <workspace_state> XML block that the agent can reference.
+ * The block is self-contained — all chunk content is inline.
+ */
+export function buildWorkspaceOutput(): string {
+  const entries = workspaceCache.getAll()
+  const totalTokens = workspaceCache.totalTokens
+  const chunkCount = entries.length
+
+  if (chunkCount === 0) {
+    return `\n<workspace_state chunks="0" files="0" tokens="0">\nWorkspace is empty.\n</workspace_state>`
+  }
+
+  // Group chunks by file path
+  const byFile = new Map<string, WorkspaceEntry[]>()
+  for (const entry of entries) {
+    if (!byFile.has(entry.path)) {
+      byFile.set(entry.path, [])
+    }
+    byFile.get(entry.path)!.push(entry)
+  }
+
+  // Sort chunks within each file by chunkIndex
+  for (const chunks of byFile.values()) {
+    chunks.sort((a, b) => a.chunkIndex - b.chunkIndex)
+  }
+
+  const fileCount = byFile.size
+  const config = workspaceCache.getConfig()
+  const pct = Math.round((totalTokens / config.maxTokens) * 100)
+
+  let output = `\n<workspace_state chunks="${chunkCount}" files="${fileCount}" tokens="${totalTokens}" budget="${pct}%">\n`
+
+  // Format all files with their chunks (ordered by role priority)
+  const processedFiles = new Set<string>()
+
+  for (const entry of entries) {
+    if (processedFiles.has(entry.path)) continue
+    processedFiles.add(entry.path)
+
+    const chunks = byFile.get(entry.path) || []
+    output += formatFileWithChunks(entry.path, chunks)
+  }
+
+  output += `\n</workspace_state>`
+
+  return output
+}
+
+// ── Formatting helpers ──────────────────────────────────────────────────────
+
+/**
+ * Format a single file with all its chunks.
+ */
+function formatFileWithChunks(filePath: string, chunks: WorkspaceEntry[]): string {
+  let block = `\n## ${filePath}\n`
+
+  const chunkIndices = chunks.map(c => c.chunkIndex).join(", ")
+  block += `<!-- Chunks: ${chunkIndices} -->\n`
+
+  for (const chunk of chunks) {
+    block += formatChunk(chunk)
+  }
+
+  return block
+}
+
+/**
+ * Format a single chunk with metadata and line numbers (cat -n style).
+ * This allows the agent to see exact line numbers without needing grep.
+ */
+function formatChunk(entry: WorkspaceEntry): string {
+  let block = ""
+
+  const description = entry.metadata?.function_name || entry.metadata?.heading_context || "code"
+  block += `\n### Chunk ${entry.chunkIndex}: ${description}\n`
+
+  const meta: string[] = []
+  if (entry.score !== undefined) meta.push(`score: ${entry.score.toFixed(3)}`)
+  if (entry.metadata?.language) meta.push(entry.metadata.language)
+  if (entry.metadata?.class_name) meta.push(`class: ${entry.metadata.class_name}`)
+  if (entry.metadata?.startLine !== undefined && entry.metadata?.endLine !== undefined) {
+    meta.push(`lines: ${entry.metadata.startLine}-${entry.metadata.endLine}`)
+  }
+  if (entry.metadata?.relation) {
+    const mainBase = entry.metadata.mainChunkId?.split(":").pop() || "?"
+    meta.push(`${entry.metadata.relation} from ${mainBase}`)
+  }
+
+  if (meta.length > 0) {
+    block += `<!-- ${meta.join(" | ")} -->\n`
+  }
+
+  // Chunk content with line numbers
+  const startLine = entry.metadata?.startLine ?? 1
+  const lines = entry.content.split("\n")
+  const lang = entry.metadata?.language || ""
+
+  block += `\`\`\`${lang}\n`
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = startLine + i
+    block += `${lineNum.toString().padStart(5, " ")}| ${lines[i]}\n`
+  }
+
+  block += `\`\`\`\n`
+
+  return block
+}

package/tools/workspace.ts

@@ -1,157 +1,31 @@
 /**
- * Workspace Management Tools (Chunk-Based)
+ * Workspace Management Tools (v2 — context-efficient)
  *
  * Manual control over the workspace cache:
- *   workspace_list    — show all attached chunks grouped by file
- *   workspace_attach  — manually attach a file as single chunk
- *   workspace_detach  — remove chunks by chunkId, path, query, or age
- *   workspace_clear   — remove all chunks
- *   workspace_restore — restore a saved session snapshot
+ *   workspace_list    — show full workspace state with chunk content
+ *   workspace_forget  — remove chunks, return updated state
+ *   workspace_clear   — remove all chunks, return empty state
+ *   workspace_restore — restore a saved session snapshot, return state
  *
- * Chunk-based architecture:
- *   - Each file can be split into multiple chunks (e.g. "src/auth.ts:chunk-5")
- *   - Chunks are keyed by chunkId, grouped by file for display
- *   - Manual attach treats file as single chunk (chunkIndex=0, chunkId=path:chunk-0)
+ * v2: Each tool returns full workspace state inline (via buildWorkspaceOutput).
+ *     Previous tool outputs are pruned from history by message-before hook.
+ *     No injection — workspace lives only in the latest tool output.
  */
 
 import { tool } from "@opencode-ai/plugin"
-import path from "path"
-import fs from "fs/promises"
-import crypto from "crypto"
 
 import { workspaceCache } from "../cache/manager.ts"
+import { buildWorkspaceOutput } from "./workspace-state.ts"
 
 // ── workspace.list ──────────────────────────────────────────────────────────
 
 export const workspace_list = tool({
-  description: `List all chunks currently in workspace context, grouped by file. Shows chunk count, roles, scores, and token counts.`,
+  description: `Show full workspace state with all chunk content. Returns file listing and inline content for every attached chunk.`,
 
   args: {},
 
   async execute() {
-    const entries = workspaceCache.getAll()
-
-    if (entries.length === 0) {
-      return `Workspace is empty.\n\nUse search() to find and attach chunks, or workspace_attach("path") to add a file manually.`
-    }
-
-    const sessionId = workspaceCache.getSessionId()
-    let output = `## Workspace Status\n\n`
-    if (sessionId) {
-      output += `Session: ${sessionId}\n`
-    }
-    output += `Chunks: ${workspaceCache.size}\n`
-    output += `Total tokens: ${workspaceCache.totalTokens.toLocaleString()}\n\n`
-
-    // Group chunks by file
-    const fileGroups = new Map<string, typeof entries>()
-    for (const entry of entries) {
-      if (!fileGroups.has(entry.path)) {
-        fileGroups.set(entry.path, [])
-      }
-      fileGroups.get(entry.path)!.push(entry)
-    }
-
-    // Separate by role
-    const mainFiles = Array.from(fileGroups.entries()).filter(([_, chunks]) =>
-      chunks.some(c => c.role === "search-main")
-    )
-    const contextFiles = Array.from(fileGroups.entries()).filter(([_, chunks]) =>
-      chunks.some(c => c.role === "search-context") && !chunks.some(c => c.role === "search-main")
-    )
-    const graphFiles = Array.from(fileGroups.entries()).filter(([_, chunks]) =>
-      chunks.some(c => c.role === "search-graph") && !chunks.some(c => c.role === "search-main" || c.role === "search-context")
-    )
-    const manualFiles = Array.from(fileGroups.entries()).filter(([_, chunks]) =>
-      chunks.some(c => c.role === "manual") && !chunks.some(c => c.role === "search-main" || c.role === "search-graph" || c.role === "search-context")
-    )
-
-    if (mainFiles.length > 0) {
-      output += `### Search results (${mainFiles.length} files)\n`
-      for (const [filePath, chunks] of mainFiles) {
-        const totalTokens = chunks.reduce((sum, c) => sum + c.tokens, 0)
-        const score = chunks[0]?.score ? ` score: ${chunks[0].score.toFixed(3)}` : ""
-        const meta = chunks[0]?.metadata?.function_name || chunks[0]?.metadata?.class_name || ""
-        const age = Math.floor((Date.now() - chunks[0].attachedAt) / 1000 / 60)
-        
-        output += `- **${filePath}** (${chunks.length} chunk${chunks.length > 1 ? "s" : ""}, ${totalTokens.toLocaleString()} tokens)${score}${meta ? ` (${meta})` : ""} — ${age}m ago\n`
-        
-        if (chunks.length > 1) {
-          for (const chunk of chunks) {
-            output += `  • ${chunk.chunkId} — chunk ${chunk.chunkIndex}, ${chunk.tokens.toLocaleString()} tok\n`
-          }
-        }
-        
-        if (chunks[0]?.attachedBy && chunks[0].attachedBy !== "manual") {
-          output += `  query: "${chunks[0].attachedBy}"\n`
-        }
-      }
-      output += `\n`
-    }
-
-    if (contextFiles.length > 0) {
-      output += `### Expanded context (${contextFiles.length} files)\n`
-      for (const [filePath, chunks] of contextFiles) {
-        const totalTokens = chunks.reduce((sum, c) => sum + c.tokens, 0)
-        const reason = chunks[0]?.attachedBy?.match(/\((.+)\)/)?.[1] || "context"
-        const age = Math.floor((Date.now() - chunks[0].attachedAt) / 1000 / 60)
-        
-        output += `- **${filePath}** (${chunks.length} chunk${chunks.length > 1 ? "s" : ""}, ${totalTokens.toLocaleString()} tokens) — ${reason} — ${age}m ago\n`
-        
-        if (chunks.length > 1) {
-          for (const chunk of chunks) {
-            const meta = chunk.metadata?.function_name || chunk.metadata?.class_name || ""
-            output += `  • ${chunk.chunkId} — ${meta} (chunk ${chunk.chunkIndex}, ${chunk.tokens.toLocaleString()} tok)\n`
-          }
-        }
-      }
-      output += `\n`
-    }
-
-    if (graphFiles.length > 0) {
-      output += `### Graph relations (${graphFiles.length} files)\n`
-      for (const [filePath, chunks] of graphFiles) {
-        const totalTokens = chunks.reduce((sum, c) => sum + c.tokens, 0)
-        const relation = chunks[0]?.metadata?.relation || "related"
-        const mainChunkId = chunks[0]?.metadata?.mainChunkId || "?"
-        const age = Math.floor((Date.now() - chunks[0].attachedAt) / 1000 / 60)
-        
-        output += `- **${filePath}** (${chunks.length} chunk${chunks.length > 1 ? "s" : ""}, ${totalTokens.toLocaleString()} tokens) — ${relation} from ${mainChunkId} — ${age}m ago\n`
-        
-        if (chunks.length > 1) {
-          for (const chunk of chunks) {
-            output += `  • ${chunk.chunkId} — chunk ${chunk.chunkIndex}, ${chunk.tokens.toLocaleString()} tok\n`
-          }
-        }
-      }
-      output += `\n`
-    }
-
-    if (manualFiles.length > 0) {
-      output += `### Manually attached (${manualFiles.length} files)\n`
-      for (const [filePath, chunks] of manualFiles) {
-        const totalTokens = chunks.reduce((sum, c) => sum + c.tokens, 0)
-        const age = Math.floor((Date.now() - chunks[0].attachedAt) / 1000 / 60)
-        
-        output += `- **${filePath}** (${chunks.length} chunk${chunks.length > 1 ? "s" : ""}, ${totalTokens.toLocaleString()} tokens) — ${age}m ago\n`
-        
-        if (chunks.length > 1) {
-          for (const chunk of chunks) {
-            output += `  • ${chunk.chunkId} — chunk ${chunk.chunkIndex}, ${chunk.tokens.toLocaleString()} tok\n`
-          }
-        }
-      }
-      output += `\n`
-    }
-
-    // Budget info
-    const config = workspaceCache.getConfig()
-    const pct = Math.round((workspaceCache.totalTokens / config.maxTokens) * 100)
-    output += `---\n`
-    output += `*Budget: ${workspaceCache.totalTokens.toLocaleString()} / ${config.maxTokens.toLocaleString()} tokens (${pct}%) | `
-    output += `${workspaceCache.size} / ${config.maxChunks} chunks*`
-
-    return output
+    return buildWorkspaceOutput()
   },
 })
 
@@ -180,52 +54,56 @@ Examples:
 
   async execute(args) {
     let removed = 0
+    let summary = ""
     
     // Auto-detect what to remove
     // 1. Check if it's a chunk ID (contains ":chunk-")
     if (args.what.includes(":chunk-")) {
       const entry = workspaceCache.get(args.what)
       if (!entry) {
-        return `Chunk "${args.what}" not found in workspace.`
+        return `Chunk "${args.what}" not found in workspace.` + buildWorkspaceOutput()
       }
       removed = workspaceCache.detach(args.what) ? 1 : 0
       if (removed === 0) {
-        return `Failed to remove chunk "${args.what}".`
+        return `Failed to remove chunk "${args.what}".` + buildWorkspaceOutput()
       }
-      return `Removed chunk "${args.what}" from workspace.\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+      summary = `Removed chunk "${args.what}" from workspace.`
     }
     
     // 2. Check if it's a number (age in minutes)
-    const ageMatch = args.what.match(/^(\d+)$/)
-    if (ageMatch) {
-      const minutes = parseInt(ageMatch[1], 10)
+    else if (args.what.match(/^(\d+)$/)) {
+      const minutes = parseInt(args.what, 10)
       removed = workspaceCache.detachOlderThan(minutes * 60 * 1000)
-      return `Removed ${removed} chunk(s) older than ${minutes} minutes.\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+      summary = `Removed ${removed} chunk(s) older than ${minutes} minutes.`
     }
     
     // 3. Check if it's a file path (has extension or common path prefixes)
-    if (
+    else if (
       args.what.match(/\.(md|ts|js|go|py|tsx|jsx|rs|java|kt|swift|txt|yaml|json|yml|toml)$/i) ||
       args.what.match(/^(src|docs|internal|pkg|lib|app|pages|components|api)\//i) ||
       args.what.includes("/")
     ) {
       const fileChunks = workspaceCache.getChunksByPath(args.what)
       if (fileChunks.length === 0) {
-        return `File "${args.what}" not found in workspace.`
+        return `File "${args.what}" not found in workspace.` + buildWorkspaceOutput()
       }
       removed = workspaceCache.detachByPath(args.what)
       if (removed === 0) {
-        return `Failed to remove chunks from "${args.what}".`
+        return `Failed to remove chunks from "${args.what}".` + buildWorkspaceOutput()
       }
-      return `Removed ${removed} chunk(s) from "${args.what}".\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+      summary = `Removed ${removed} chunk(s) from "${args.what}".`
     }
     
     // 4. Otherwise, treat as search query
-    removed = workspaceCache.detachByQuery(args.what)
-    if (removed === 0) {
-      return `No chunks found attached by query "${args.what}".\n\nTip: Use workspace_list() to see what's in workspace.`
+    else {
+      removed = workspaceCache.detachByQuery(args.what)
+      if (removed === 0) {
+        return `No chunks found attached by query "${args.what}".` + buildWorkspaceOutput()
+      }
+      summary = `Removed ${removed} chunk(s) from search "${args.what}".`
     }
-    return `Removed ${removed} chunk(s) from search "${args.what}".\nWorkspace: ${workspaceCache.size} chunks, ${workspaceCache.totalTokens.toLocaleString()} tokens`
+
+    return summary + buildWorkspaceOutput()
   },
 })
 
@@ -241,7 +119,7 @@ export const workspace_clear = tool({
     const tokens = workspaceCache.totalTokens
     workspaceCache.clear()
 
-    return `Cleared workspace: ${count} chunks removed (${tokens.toLocaleString()} tokens freed).\nWorkspace is now empty.`
+    return `Cleared workspace: ${count} chunks removed (${tokens.toLocaleString()} tokens freed).` + buildWorkspaceOutput()
   },
 })
 
@@ -256,7 +134,7 @@ export const workspace_restore = tool({
 
   async execute(args) {
     if (!args.sessionId) {
-      // List available snapshots
+      // List available snapshots (no workspace state needed — just metadata)
       const snapshots = await workspaceCache.listSnapshots()
 
       if (snapshots.length === 0) {
@@ -279,6 +157,6 @@ export const workspace_restore = tool({
       return `Snapshot "${args.sessionId}" not found or empty.`
     }
 
-    return `Restored workspace from "${args.sessionId}".\nChunks: ${workspaceCache.size}\nTokens: ${workspaceCache.totalTokens.toLocaleString()}`
+    return `Restored workspace from "${args.sessionId}".` + buildWorkspaceOutput()
   },
 })