@openviking/opencode-plugin 0.1.5 → 0.2.0

package/index.mjs

@@ -3,17 +3,15 @@ import { fileURLToPath } from "url"
 import { initializeRuntime } from "./lib/runtime.mjs"
 import { createRepoContext } from "./lib/repo-context.mjs"
 import { createMemorySessionManager } from "./lib/memory-session.mjs"
-import { createCodeTools } from "./lib/code-tools.mjs"
-import { createMemoryTools } from "./lib/memory-tools.mjs"
 import { createMemoryRecall } from "./lib/memory-recall.mjs"
+import { createSessionInject } from "./lib/session-inject.mjs"
 import { createVikingUriGuard } from "./lib/viking-uri-guard.mjs"
-import { initLogger, loadConfig, log, resolveDataDir } from "./lib/utils.mjs"
+import { injectOpenVikingMcpConfig } from "./lib/mcp-config.mjs"
+import { loadConfig, resolveDataDir } from "./lib/config.mjs"
+import { initLogger, log, makeToast } from "./lib/utils.mjs"
 
 const pluginRoot = dirname(fileURLToPath(import.meta.url))
 
-/**
- * @type {import('@opencode-ai/plugin').Plugin}
- */
 export async function OpenVikingPlugin({ client, directory }) {
   const config = loadConfig(pluginRoot, directory)
   const dataDir = resolveDataDir(pluginRoot, config)
@@ -27,11 +25,17 @@ export async function OpenVikingPlugin({ client, directory }) {
   const repoContext = createRepoContext({ config })
   const sessionManager = createMemorySessionManager({ config, pluginRoot: dataDir })
   const recall = createMemoryRecall({ config })
+  const sessionInject = createSessionInject({ config, sessionManager })
   const vikingUriGuard = createVikingUriGuard()
-  const tools = createMemoryTools({ config, sessionManager, projectDirectory: directory })
-  const codeTools = createCodeTools({ config })
 
   await sessionManager.init()
+  const toast = makeToast(client)
+  if (config.legacyCredentialsUsed) {
+    log("WARN", "config", "Legacy OpenCode credential fields are still in use; run node scripts/setup.mjs to migrate to ovcli.conf", {
+      configPath: config.configPath,
+    })
+    await toast("OpenViking credentials in openviking-config.json are deprecated. Run node scripts/setup.mjs to migrate.", "warning")
+  }
 
   Promise.resolve().then(async () => {
     const ready = await initializeRuntime(config, client)
@@ -39,6 +43,11 @@ export async function OpenVikingPlugin({ client, directory }) {
   })
 
   return {
+    config: async (opencodeConfig) => {
+      const injected = injectOpenVikingMcpConfig(opencodeConfig, pluginRoot)
+      log(injected ? "INFO" : "WARN", "mcp", injected ? "Registered OpenViking MCP server" : "OpenViking MCP server was not registered")
+    },
+
     event: async ({ event }) => {
       await sessionManager.handleEvent(event)
       if (event?.type === "session.created") {
@@ -48,8 +57,6 @@ export async function OpenVikingPlugin({ client, directory }) {
 
     "tool.execute.before": vikingUriGuard,
 
-    tool: { ...tools, ...codeTools },
-
     "experimental.chat.system.transform": (_input, output) => {
       const prompt = repoContext.getRepoSystemPrompt()
       if (prompt) output.system.push(prompt)
@@ -57,6 +64,7 @@ export async function OpenVikingPlugin({ client, directory }) {
 
     "chat.message": async (input, output) => {
       try {
+        await sessionInject.injectSessionContext(input, output)
         if (!config.autoRecall?.enabled) return
         await recall.injectRelevantMemories(input, output)
       } catch (error) {
@@ -74,9 +82,9 @@ export async function OpenVikingPlugin({ client, directory }) {
       })
     },
 
-    stop: async () => {
+    dispose: async () => {
       await sessionManager.flushAll({ commit: true })
-      log("INFO", "plugin", "OpenViking plugin stopped")
+      log("INFO", "plugin", "OpenViking plugin disposed")
     },
   }
 }

package/lib/config.mjs

@@ -0,0 +1,272 @@
+import fs from "fs"
+import path from "path"
+import { homedir } from "os"
+import { resolveOpenVikingCredentials } from "./shared/credentials.mjs"
+
+const DEFAULT_CONFIG = {
+  endpoint: "http://127.0.0.1:1933",
+  apiKey: "",
+  account: "",
+  user: "",
+  peerId: "",
+  enabled: true,
+  timeoutMs: 30000,
+  runtime: {
+    dataDir: "",
+  },
+  repoContext: {
+    enabled: true,
+    cacheTtlMs: 60000,
+  },
+  autoRecall: {
+    enabled: true,
+    limit: 6,
+    scoreThreshold: 0.35,
+    maxContentChars: 500,
+    preferAbstract: true,
+    tokenBudget: 2000,
+    minQueryLength: 3,
+  },
+  autoCapture: true,
+  captureMode: "semantic",
+  captureMaxLength: 24000,
+  captureAssistantTurns: true,
+  captureToolMaxChars: 2000,
+  commitTokenThreshold: 20000,
+  commitKeepRecentCount: 10,
+  profileTokenBudget: 10000,
+  resumeContextBudget: 32000,
+  noAutoInject: false,
+  bypassSession: false,
+  bypassSessionPatterns: [],
+  debug: false,
+  debugLogPath: path.join(homedir(), ".openviking", "logs", "opencode-plugin.log"),
+}
+
+function cloneDefaultConfig() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG))
+}
+
+function normalizeNumber(value, fallback, min, max) {
+  const next = Number(value)
+  if (!Number.isFinite(next)) return fallback
+  return Math.max(min, Math.min(max, next))
+}
+
+function envBool(name) {
+  const value = process.env[name]
+  if (value == null || value === "") return undefined
+  const lower = String(value).trim().toLowerCase()
+  if (lower === "0" || lower === "false" || lower === "no" || lower === "off") return false
+  if (lower === "1" || lower === "true" || lower === "yes" || lower === "on") return true
+  return undefined
+}
+
+function str(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback
+}
+
+function expandHome(value) {
+  if (!value || typeof value !== "string") return value
+  if (value === "~") return homedir()
+  if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(homedir(), value.slice(2))
+  return value
+}
+
+function readConfigFile(pluginRoot, projectDirectory) {
+  for (const configPath of getConfigPaths(pluginRoot, projectDirectory)) {
+    try {
+      if (!fs.existsSync(configPath)) continue
+      return { path: configPath, data: JSON.parse(fs.readFileSync(configPath, "utf8")) }
+    } catch (error) {
+      console.warn(`Failed to load OpenViking config from ${configPath}:`, error)
+    }
+  }
+  return { path: "", data: {} }
+}
+
+function getConfigPaths(pluginRoot, projectDirectory) {
+  const paths = []
+  if (process.env.OPENVIKING_PLUGIN_CONFIG) paths.push(expandHome(process.env.OPENVIKING_PLUGIN_CONFIG))
+  if (projectDirectory) paths.push(path.join(projectDirectory, ".opencode", "openviking-config.json"))
+  paths.push(path.join(homedir(), ".config", "opencode", "openviking-config.json"))
+  paths.push(path.join(pluginRoot, "openviking-config.json"))
+  return paths
+}
+
+function applyLegacyConnection(config, fileConfig) {
+  const hasLegacyCredentials = ["endpoint", "apiKey", "account", "user", "peerId"]
+    .some((key) => fileConfig[key] !== undefined && fileConfig[key] !== "")
+  if (!hasLegacyCredentials) return false
+
+  if (fileConfig.endpoint !== undefined) config.endpoint = fileConfig.endpoint
+  if (fileConfig.apiKey !== undefined) config.apiKey = fileConfig.apiKey
+  if (fileConfig.account !== undefined) config.account = fileConfig.account
+  if (fileConfig.user !== undefined) config.user = fileConfig.user
+  if (fileConfig.peerId !== undefined) config.peerId = fileConfig.peerId
+  return true
+}
+
+function applyBehaviorConfig(config, fileConfig = {}) {
+  if (fileConfig.enabled !== undefined) config.enabled = fileConfig.enabled !== false
+  if (fileConfig.timeoutMs !== undefined) config.timeoutMs = fileConfig.timeoutMs
+  config.runtime = {
+    ...DEFAULT_CONFIG.runtime,
+    ...(fileConfig.runtime ?? {}),
+  }
+  config.repoContext = {
+    ...DEFAULT_CONFIG.repoContext,
+    ...(fileConfig.repoContext ?? {}),
+  }
+
+  const autoRecall = fileConfig.autoRecall ?? {}
+  config.autoRecall = {
+    ...DEFAULT_CONFIG.autoRecall,
+    ...autoRecall,
+    enabled: autoRecall.enabled !== false,
+    limit: autoRecall.limit ?? fileConfig.recallLimit ?? DEFAULT_CONFIG.autoRecall.limit,
+    scoreThreshold: autoRecall.scoreThreshold ?? fileConfig.scoreThreshold ?? DEFAULT_CONFIG.autoRecall.scoreThreshold,
+    maxContentChars: autoRecall.maxContentChars ?? fileConfig.recallMaxContentChars ?? DEFAULT_CONFIG.autoRecall.maxContentChars,
+    preferAbstract: autoRecall.preferAbstract ?? fileConfig.recallPreferAbstract ?? DEFAULT_CONFIG.autoRecall.preferAbstract,
+    tokenBudget: autoRecall.tokenBudget ?? fileConfig.recallTokenBudget ?? DEFAULT_CONFIG.autoRecall.tokenBudget,
+    minQueryLength: autoRecall.minQueryLength ?? fileConfig.minQueryLength ?? DEFAULT_CONFIG.autoRecall.minQueryLength,
+  }
+
+  for (const key of [
+    "autoCapture",
+    "captureMode",
+    "captureMaxLength",
+    "captureAssistantTurns",
+    "captureToolMaxChars",
+    "commitTokenThreshold",
+    "commitKeepRecentCount",
+    "profileTokenBudget",
+    "resumeContextBudget",
+    "noAutoInject",
+    "bypassSession",
+    "bypassSessionPatterns",
+    "debug",
+    "debugLogPath",
+  ]) {
+    if (fileConfig[key] !== undefined) config[key] = fileConfig[key]
+  }
+}
+
+function applyEnv(config) {
+  if (process.env.OPENVIKING_TIMEOUT_MS) config.timeoutMs = process.env.OPENVIKING_TIMEOUT_MS
+  if (process.env.OPENVIKING_AUTO_RECALL !== undefined) {
+    config.autoRecall.enabled = envBool("OPENVIKING_AUTO_RECALL") ?? config.autoRecall.enabled
+  }
+  if (process.env.OPENVIKING_RECALL_LIMIT) config.autoRecall.limit = process.env.OPENVIKING_RECALL_LIMIT
+  if (process.env.OPENVIKING_SCORE_THRESHOLD) config.autoRecall.scoreThreshold = process.env.OPENVIKING_SCORE_THRESHOLD
+  if (process.env.OPENVIKING_RECALL_MAX_CONTENT_CHARS) {
+    config.autoRecall.maxContentChars = process.env.OPENVIKING_RECALL_MAX_CONTENT_CHARS
+  }
+  if (process.env.OPENVIKING_RECALL_TOKEN_BUDGET) config.autoRecall.tokenBudget = process.env.OPENVIKING_RECALL_TOKEN_BUDGET
+  if (process.env.OPENVIKING_RECALL_PREFER_ABSTRACT !== undefined) {
+    config.autoRecall.preferAbstract = envBool("OPENVIKING_RECALL_PREFER_ABSTRACT") ?? config.autoRecall.preferAbstract
+  }
+  if (process.env.OPENVIKING_MIN_QUERY_LENGTH) config.autoRecall.minQueryLength = process.env.OPENVIKING_MIN_QUERY_LENGTH
+  if (process.env.OPENVIKING_AUTO_CAPTURE !== undefined) {
+    config.autoCapture = envBool("OPENVIKING_AUTO_CAPTURE") ?? config.autoCapture
+  }
+  if (process.env.OPENVIKING_CAPTURE_MODE) config.captureMode = process.env.OPENVIKING_CAPTURE_MODE
+  if (process.env.OPENVIKING_CAPTURE_MAX_LENGTH) config.captureMaxLength = process.env.OPENVIKING_CAPTURE_MAX_LENGTH
+  if (process.env.OPENVIKING_CAPTURE_ASSISTANT_TURNS !== undefined) {
+    config.captureAssistantTurns = envBool("OPENVIKING_CAPTURE_ASSISTANT_TURNS") ?? config.captureAssistantTurns
+  }
+  if (process.env.OPENVIKING_CAPTURE_TOOL_MAX_CHARS) {
+    config.captureToolMaxChars = process.env.OPENVIKING_CAPTURE_TOOL_MAX_CHARS
+  }
+  if (process.env.OPENVIKING_COMMIT_TOKEN_THRESHOLD) {
+    config.commitTokenThreshold = process.env.OPENVIKING_COMMIT_TOKEN_THRESHOLD
+  }
+  if (process.env.OPENVIKING_COMMIT_KEEP_RECENT_COUNT) {
+    config.commitKeepRecentCount = process.env.OPENVIKING_COMMIT_KEEP_RECENT_COUNT
+  }
+  if (process.env.OPENVIKING_PROFILE_TOKEN_BUDGET) config.profileTokenBudget = process.env.OPENVIKING_PROFILE_TOKEN_BUDGET
+  if (process.env.OPENVIKING_RESUME_CONTEXT_BUDGET) config.resumeContextBudget = process.env.OPENVIKING_RESUME_CONTEXT_BUDGET
+  if (process.env.OPENVIKING_NO_AUTO_INJECT !== undefined) {
+    config.noAutoInject = envBool("OPENVIKING_NO_AUTO_INJECT") ?? config.noAutoInject
+  }
+  if (process.env.OPENVIKING_BYPASS_SESSION !== undefined) {
+    config.bypassSession = envBool("OPENVIKING_BYPASS_SESSION") ?? config.bypassSession
+  }
+  if (process.env.OPENVIKING_BYPASS_SESSION_PATTERNS) {
+    config.bypassSessionPatterns = process.env.OPENVIKING_BYPASS_SESSION_PATTERNS
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+  if (process.env.OPENVIKING_DEBUG !== undefined) config.debug = envBool("OPENVIKING_DEBUG") ?? config.debug
+  if (process.env.OPENVIKING_DEBUG_LOG) config.debugLogPath = process.env.OPENVIKING_DEBUG_LOG
+}
+
+function normalizeConfig(config) {
+  config.endpoint = str(config.endpoint, DEFAULT_CONFIG.endpoint).replace(/\/+$/, "")
+  config.baseUrl = config.endpoint
+  config.accountId = config.account
+  config.userId = config.user
+  config.timeoutMs = normalizeNumber(config.timeoutMs, DEFAULT_CONFIG.timeoutMs, 1000, 300000)
+  config.repoContext.cacheTtlMs = normalizeNumber(
+    config.repoContext.cacheTtlMs,
+    DEFAULT_CONFIG.repoContext.cacheTtlMs,
+    1000,
+    60 * 60 * 1000,
+  )
+  config.autoRecall.limit = Math.max(1, Math.min(50, Math.round(Number(config.autoRecall.limit) || 6)))
+  config.autoRecall.scoreThreshold = Math.max(0, Math.min(1, Number(config.autoRecall.scoreThreshold) || 0))
+  config.autoRecall.maxContentChars = Math.max(100, Math.min(5000, Math.round(Number(config.autoRecall.maxContentChars) || 500)))
+  config.autoRecall.tokenBudget = Math.max(200, Math.min(50000, Math.round(Number(config.autoRecall.tokenBudget) || 2000)))
+  config.autoRecall.minQueryLength = Math.max(1, Math.min(64, Math.round(Number(config.autoRecall.minQueryLength) || 3)))
+  config.captureMode = config.captureMode === "keyword" ? "keyword" : "semantic"
+  config.captureMaxLength = Math.max(200, Math.min(100000, Math.round(Number(config.captureMaxLength) || 24000)))
+  config.captureToolMaxChars = Math.max(200, Math.min(20000, Math.round(Number(config.captureToolMaxChars) || 2000)))
+  config.commitTokenThreshold = Math.max(1000, Math.round(Number(config.commitTokenThreshold) || 20000))
+  config.commitKeepRecentCount = Math.max(0, Math.round(Number(config.commitKeepRecentCount) || 10))
+  config.profileTokenBudget = Math.max(500, Math.round(Number(config.profileTokenBudget) || 10000))
+  config.resumeContextBudget = Math.max(1024, Math.round(Number(config.resumeContextBudget) || 32000))
+  if (!Array.isArray(config.bypassSessionPatterns)) config.bypassSessionPatterns = []
+
+  config.recallLimit = config.autoRecall.limit
+  config.scoreThreshold = config.autoRecall.scoreThreshold
+  config.recallMaxContentChars = config.autoRecall.maxContentChars
+  config.recallPreferAbstract = config.autoRecall.preferAbstract !== false
+  config.recallTokenBudget = config.autoRecall.tokenBudget
+  config.minQueryLength = config.autoRecall.minQueryLength
+  return config
+}
+
+export function loadConfig(pluginRoot, projectDirectory) {
+  const config = cloneDefaultConfig()
+  const { path: configPath, data: fileConfig } = readConfigFile(pluginRoot, projectDirectory)
+  applyBehaviorConfig(config, fileConfig)
+
+  const creds = resolveOpenVikingCredentials()
+  config.endpoint = creds.baseUrl
+  config.apiKey = creds.apiKey
+  config.account = creds.account
+  config.user = creds.user
+  config.peerId = creds.peerId
+  config.mcpUrl = creds.mcpUrl
+  config.credentialSource = creds.credentialSource
+  config.credentialPath = creds.cliPath || creds.ovPath || ""
+
+  const mayUseLegacyCredentials = creds.credentialSource !== "env" &&
+    creds.credentialSource !== "ovcli" &&
+    !creds.apiKey &&
+    !creds.account &&
+    !creds.user &&
+    !creds.peerId
+  const legacyUsed = mayUseLegacyCredentials ? applyLegacyConnection(config, fileConfig) : false
+  applyEnv(config)
+  config.configPath = configPath
+  config.legacyCredentialsUsed = legacyUsed && creds.credentialSource !== "env"
+  return normalizeConfig(config)
+}
+
+export function resolveDataDir(pluginRoot, config) {
+  const configured = config.runtime?.dataDir
+  if (configured) return expandHome(configured)
+  return path.join(homedir(), ".config", "opencode", "openviking")
+}

package/lib/mcp-config.mjs

@@ -0,0 +1,21 @@
+import { resolve as resolvePath } from "node:path"
+
+export const OPENCODE_MCP_NAME = "openviking"
+
+export function createOpenVikingMcpConfig(pluginRoot) {
+  return {
+    type: "local",
+    command: ["node", resolvePath(pluginRoot, "servers", "mcp-proxy.mjs")],
+    enabled: true,
+    timeout: 15000,
+  }
+}
+
+export function injectOpenVikingMcpConfig(config, pluginRoot) {
+  if (!config || typeof config !== "object") return false
+  config.mcp = config.mcp && typeof config.mcp === "object" ? config.mcp : {}
+  const current = config.mcp[OPENCODE_MCP_NAME]
+  if (current?.enabled === false) return false
+  config.mcp[OPENCODE_MCP_NAME] = createOpenVikingMcpConfig(pluginRoot)
+  return true
+}

package/lib/memory-recall.mjs

@@ -1,59 +1,34 @@
-import { effectivePeerId, log, makeRequest, unwrapResponse } from "./utils.mjs"
-
-const AUTO_RECALL_TIMEOUT_MS = 5000
-const RECALL_STOPWORDS = new Set([
-  "what", "when", "where", "which", "who", "whom", "whose", "why", "how",
-  "did", "does", "is", "are", "was", "were", "the", "and", "for", "with",
-  "from", "that", "this", "your", "you",
-])
-const RECALL_TOKEN_RE = /[a-z0-9]{2,}/gi
-const PREFERENCE_QUERY_RE = /prefer|preference|favorite|favourite|like|偏好|喜欢|爱好|更倾向/i
-const TEMPORAL_QUERY_RE = /when|what time|date|day|month|year|yesterday|today|tomorrow|last|next|什么时候|何时|哪天|几月|几年|昨天|今天|明天|上周|下周|上个月|下个月|去年|明年/i
+import { buildRecallBlock } from "./shared/recall-core.mjs"
+import { isBypassed } from "./shared/session-model.mjs"
+import { effectivePeerId, fetchJSON, log } from "./utils.mjs"
 
 export function createMemoryRecall({ config }) {
   async function injectRelevantMemories(input, output) {
     if (!config.autoRecall?.enabled) return
     const query = extractCurrentUserText(output.parts ?? [])
     if (!query) return
-
-    const rawResults = await performRecallSearch(query)
-    if (rawResults.length === 0) return
-
-    const ranked = pickMemoriesForInjection(
-      rawResults,
-      config.autoRecall.limit,
+    if (query.length < config.minQueryLength) return
+    if (isBypassed(config, {
+      sessionId: input.sessionID ?? output.message?.sessionID,
+      cwd: input.directory ?? input.cwd,
+    })) return
+
+    const health = await fetchJSON(config, "/health", {}, { timeoutMs: 5000 })
+    if (!health.ok) return
+
+    const block = await buildRecallBlock(
+      (path, init = {}, options = {}) => fetchJSON(config, path, init, { ...options, timeoutMs: 5000 }),
+      config,
       query,
-      config.autoRecall.scoreThreshold,
-    )
-    if (ranked.length === 0) return
-
-    const processed = postProcessMemories(
-      ranked,
-      config.autoRecall.maxContentChars,
-      config.autoRecall.preferAbstract,
+      {
+        actorPeerId: effectivePeerId(config),
+        log: (stage, data) => log("DEBUG", "recall", stage, data),
+      },
     )
-    const block = formatMemoryBlock(processed, config.autoRecall.tokenBudget)
     if (!block) return
 
     if (prependSyntheticRecallPart(input, output, block)) {
-      log("INFO", "recall", `Injected ${processed.length} memories`)
-    }
-  }
-
-  async function performRecallSearch(query) {
-    try {
-      const body = { query: query.slice(0, 4000), limit: 20 }
-      const response = await makeRequest(config, {
-        method: "POST",
-        endpoint: "/api/v1/search/find",
-        body,
-        timeoutMs: AUTO_RECALL_TIMEOUT_MS,
-        actorPeerId: effectivePeerId(config),
-      })
-      const result = unwrapResponse(response)
-      return result?.memories ?? result?.results ?? []
-    } catch {
-      return []
+      log("INFO", "recall", "Injected OpenViking context")
     }
   }
 
@@ -64,139 +39,13 @@ function extractCurrentUserText(parts) {
   const texts = []
   for (const part of parts) {
     if (part.type !== "text" || typeof part.text !== "string") continue
-    if (part.text.includes("<relevant-memories>")) return null
+    if (part.text.includes("<openviking-context")) return null
     if (!part.synthetic && !part.ignored) texts.push(part.text)
   }
   const joined = texts.join(" ").trim()
   return joined || null
 }
 
-function buildRecallQueryProfile(query) {
-  const text = query.trim()
-  const allTokens = text.toLowerCase().match(RECALL_TOKEN_RE) ?? []
-  return {
-    tokens: allTokens.filter((token) => !RECALL_STOPWORDS.has(token)),
-    wantsPreference: PREFERENCE_QUERY_RE.test(text),
-    wantsTemporal: TEMPORAL_QUERY_RE.test(text),
-  }
-}
-
-function recallClampScore(value) {
-  if (typeof value !== "number" || Number.isNaN(value)) return 0
-  return Math.max(0, Math.min(1, value))
-}
-
-function lexicalOverlapBoost(tokens, text) {
-  if (tokens.length === 0 || !text) return 0
-  const haystack = ` ${text.toLowerCase()} `
-  let matched = 0
-  for (const token of tokens.slice(0, 8)) {
-    if (haystack.includes(` ${token} `) || haystack.includes(token)) matched += 1
-  }
-  return Math.min(0.2, (matched / Math.min(tokens.length, 4)) * 0.2)
-}
-
-function isEventMemory(item) {
-  const category = (item.category ?? "").toLowerCase()
-  return category === "events" || item.uri?.includes("/events/")
-}
-
-function isPreferencesMemory(item) {
-  return item.category === "preferences" || item.uri?.includes("/preferences/") || item.uri?.endsWith("/preferences")
-}
-
-function isLeafLikeMemory(item) {
-  return item.level === 2 || item.is_leaf === true
-}
-
-function rankForInjection(item, query) {
-  const baseScore = recallClampScore(item.score)
-  const abstract = (item.abstract ?? item.overview ?? "").trim()
-  const leafBoost = isLeafLikeMemory(item) ? 0.12 : 0
-  const eventBoost = query.wantsTemporal && isEventMemory(item) ? 0.1 : 0
-  const preferenceBoost = query.wantsPreference && isPreferencesMemory(item) ? 0.08 : 0
-  const overlapBoost = lexicalOverlapBoost(query.tokens, `${item.uri} ${abstract}`)
-  return baseScore + leafBoost + eventBoost + preferenceBoost + overlapBoost
-}
-
-function normalizeDedupeText(text) {
-  return text.toLowerCase().replace(/\s+/g, " ").trim()
-}
-
-function isEventOrCaseMemory(item) {
-  const category = (item.category ?? "").toLowerCase()
-  const uri = (item.uri ?? "").toLowerCase()
-  return category === "events" || category === "cases" || uri.includes("/events/") || uri.includes("/cases/")
-}
-
-function getMemoryDedupeKey(item) {
-  const abstract = normalizeDedupeText(item.abstract ?? item.overview ?? "")
-  const category = (item.category ?? "").toLowerCase() || "unknown"
-  if (abstract && !isEventOrCaseMemory(item)) return `abstract:${category}:${abstract}`
-  return `uri:${item.uri}`
-}
-
-function pickMemoriesForInjection(items, limit, queryText, scoreThreshold = 0) {
-  const query = buildRecallQueryProfile(queryText)
-  const sorted = [...items].sort((a, b) => rankForInjection(b, query) - rankForInjection(a, query))
-  const deduped = []
-  const seen = new Set()
-
-  for (const item of sorted) {
-    const key = getMemoryDedupeKey(item)
-    if (seen.has(key)) continue
-    seen.add(key)
-    deduped.push(item)
-  }
-
-  const leaves = deduped.filter((item) => isLeafLikeMemory(item))
-  if (leaves.length >= limit) return leaves.slice(0, limit)
-
-  const picked = [...leaves]
-  const used = new Set(leaves.map((item) => item.uri))
-  for (const item of deduped) {
-    if (picked.length >= limit) break
-    if (used.has(item.uri)) continue
-    if (recallClampScore(item.score) < scoreThreshold) continue
-    picked.push(item)
-  }
-  return picked
-}
-
-function postProcessMemories(items, maxContentChars, preferAbstract) {
-  return items.map((item) => {
-    const abstract = (item.abstract ?? "").trim()
-    const content = (item.content ?? "").trim()
-    let displayContent = ""
-    if (preferAbstract && abstract) displayContent = abstract
-    else if (content) displayContent = content
-    else if (abstract) displayContent = abstract
-    if (displayContent.length > maxContentChars) displayContent = `${displayContent.slice(0, maxContentChars)}...`
-    return { ...item, content: displayContent, abstract: abstract || undefined }
-  })
-}
-
-function formatMemoryBlock(items, tokenBudget) {
-  if (items.length === 0) return ""
-  const maxBlockChars = tokenBudget * 4
-  let usedChars = 0
-  const lines = ["<relevant-memories>"]
-
-  for (const item of items) {
-    const title = item.title ? `${item.title}\n` : ""
-    const content = item.content ?? ""
-    const entry = `<memory uri="${item.uri}">\n${title}${content}\n</memory>`
-    if (usedChars + entry.length + 1 > maxBlockChars) break
-    lines.push(entry)
-    usedChars += entry.length + 1
-  }
-
-  if (usedChars === 0) return ""
-  lines.push("</relevant-memories>")
-  lines.push('Use `memread` with a memory URI and level="overview" or level="read" for more details.')
-  return lines.join("\n")
-}
-
 function prependSyntheticRecallPart(input, output, injection) {
   const sessionID = input.sessionID ?? output.message?.sessionID
   const messageID = input.messageID ?? output.message?.id