@openviking/opencode-plugin 2026.9.9 → 2026.9.21-1

package/lib/config.mjs

@@ -1,84 +1,20 @@
-import fs from "fs"
 import path from "path"
 import { homedir } from "os"
-import { buildUserAgent, readManifestVersion, resolveOpenVikingCredentials } from "./shared/credentials.mjs"
-import { resolveEffectivePeerId } from "./shared/workspace-peer.mjs"
-
-const USER_AGENT = buildUserAgent(
-  "opencode",
-  readManifestVersion(new URL("../package.json", import.meta.url)),
-)
-
-const DEFAULT_CONFIG = {
-  endpoint: "http://127.0.0.1:1933",
-  apiKey: "",
-  account: "",
-  user: "",
-  peerId: "",
-  workspacePeer: true,
-  recallPeerScope: "all",
-  // Server-side query expansion costs a model call before retrieval starts, so
-  // it has to be switchable from the client that pays the latency.
-  recallQueryExpansion: "auto",
-  enabled: true,
-  mcp: {
-    enabled: true,
-  },
-  timeoutMs: 30000,
-  runtime: {
-    dataDir: "",
-  },
-  repoContext: {
-    enabled: true,
-    cacheTtlMs: 60000,
-  },
-  autoRecall: {
-    enabled: true,
-    limit: 10,
-    scoreThreshold: 0.35,
-    maxContentChars: 500,
-    preferAbstract: true,
-    tokenBudget: 2000,
-    minQueryLength: 3,
-  },
-  autoCapture: true,
-  captureMode: "semantic",
-  captureMaxLength: 24000,
-  captureAssistantTurns: true,
-  captureToolMaxChars: 1000000,
-  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
-}
+import { buildPluginConfig } from "./shared/plugin-config.mjs"
+
+/**
+ * Configuration for the opencode plugin.
+ *
+ * This plugin used to keep its own `openviking-config.json`, looked up along
+ * four candidate paths. Every knob now comes from the same place as every other
+ * harness — `ovcli.conf`'s `plugin` section, overridden by `plugin.opencode`,
+ * by the workspace file, and by the environment — so `ov config switch` moves
+ * behaviour along with credentials instead of only half of it.
+ *
+ * What stays here is the three knobs this plugin's own code reads as sections
+ * rather than as flat keys.
+ */
+const MANIFEST_URL = new URL("../package.json", import.meta.url)
 
 function expandHome(value) {
   if (!value || typeof value !== "string") return value
@@ -87,236 +23,23 @@ function expandHome(value) {
   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
-  const mcp = fileConfig.mcp && typeof fileConfig.mcp === "object" ? fileConfig.mcp : {}
-  config.mcp = {
-    ...DEFAULT_CONFIG.mcp,
-    ...mcp,
-    enabled: mcp.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.recallLimitConfigured = autoRecall.limit !== undefined ||
-    fileConfig.recallLimit !== undefined
-  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,
-  }
+export function loadConfig(pluginRoot, projectDirectory, { env = process.env } = {}) {
+  const config = buildPluginConfig("opencode", {
+    cwd: projectDirectory,
+    env,
+    manifestUrl: MANIFEST_URL,
+    logFile: "opencode-plugin.log",
+    deriveEffectivePeer: true,
+  })
 
-  for (const key of [
-    "autoCapture",
-    "captureMode",
-    "captureMaxLength",
-    "captureAssistantTurns",
-    "captureToolMaxChars",
-    "commitTokenThreshold",
-    "commitKeepRecentCount",
-    "profileTokenBudget",
-    "resumeContextBudget",
-    "noAutoInject",
-    "bypassSession",
-    "bypassSessionPatterns",
-    "debug",
-    "debugLogPath",
-    "workspacePeer",
-    "recallPeerScope",
-    "recallQueryExpansion",
-  ]) {
-    if (fileConfig[key] !== undefined) config[key] = fileConfig[key]
+  return {
+    ...config,
+    // The MCP registration, the runtime data directory, and the repo context
+    // cache.
+    mcp: { enabled: config.mcpEnabled },
+    runtime: { dataDir: config.dataDir },
+    repoContext: { enabled: config.repoContext, cacheTtlMs: config.repoContextCacheTtlMs },
   }
-  config.recallQueryExpansionConfigured = fileConfig.recallQueryExpansion !== undefined
-}
-
-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
-    config.recallLimitConfigured = true
-  }
-  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_RECALL_PEER_SCOPE) config.recallPeerScope = process.env.OPENVIKING_RECALL_PEER_SCOPE
-  if (process.env.OPENVIKING_RECALL_QUERY_EXPANSION) {
-    config.recallQueryExpansion = process.env.OPENVIKING_RECALL_QUERY_EXPANSION
-    config.recallQueryExpansionConfigured = true
-  }
-  if (process.env.OPENVIKING_WORKSPACE_PEER !== undefined) {
-    config.workspacePeer = envBool("OPENVIKING_WORKSPACE_PEER") ?? config.workspacePeer
-  }
-  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.userAgent = USER_AGENT
-  config.harness = "opencode"
-  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) || 10)))
-  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.recallPeerScope = config.recallPeerScope === "actor" ? "actor" : "all"
-  config.recallQueryExpansion = config.recallQueryExpansion === "off" ? "off" : "auto"
-  config.captureMaxLength = Math.max(200, Math.min(100000, Math.round(Number(config.captureMaxLength) || 24000)))
-  config.captureToolMaxChars = Math.max(200, Math.min(1000000, Math.round(Number(config.captureToolMaxChars) || 1000000)))
-  config.commitTokenThreshold = Math.max(1000, Math.round(Number(config.commitTokenThreshold) || 20000))
-  const rawCommitKeepRecentCount = config.commitKeepRecentCount
-  const commitKeepRecentCount = rawCommitKeepRecentCount == null ||
-    (typeof rawCommitKeepRecentCount === "string" && rawCommitKeepRecentCount.trim() === "")
-    ? Number.NaN
-    : Number(rawCommitKeepRecentCount)
-  config.commitKeepRecentCount = Number.isFinite(commitKeepRecentCount)
-    ? Math.max(0, Math.round(commitKeepRecentCount))
-    : DEFAULT_CONFIG.commitKeepRecentCount
-  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
-  // Shared credentials only carry a peer when ovcli.conf sets actor_peer_id
-  // (or OPENVIKING_PEER_ID is exported); without one the project config's
-  // peerId still applies so authenticated setups keep writing peer-scoped
-  // data instead of silently dropping into the shared user tree (#4487).
-  config.peerId = creds.peerId || str(fileConfig.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"
-  const normalized = normalizeConfig(config)
-  normalized.effectivePeer = resolveEffectivePeerId({ cfg: normalized, cwd: projectDirectory })
-  return normalized
 }
 
 export function resolveDataDir(pluginRoot, config) {

package/lib/memory-recall.mjs

@@ -1,10 +1,10 @@
-import { buildRecallBlock } from "./shared/recall-core.mjs"
+import { buildRecallBlock, isRecallEnabled } from "./shared/recall-core.mjs"
 import { isBypassed } from "./shared/session-model.mjs"
 import { effectivePeerId, fetchJSON, log } from "./utils.mjs"
 
 export function createMemoryRecall({ config, sessionManager }) {
   async function injectRelevantMemories(input, output) {
-    if (!config.autoRecall?.enabled) return
+    if (!isRecallEnabled(config)) return
     const query = extractCurrentUserText(output.parts ?? [])
     if (!query) return
     if (query.length < config.minQueryLength) return

package/lib/memory-session.mjs

@@ -3,6 +3,7 @@ import path from "path"
 import {
   extractPartsFromPayload,
   extractTextFromPayload,
+  isCaptureEnabled,
   shouldCaptureText,
 } from "./shared/capture-utils.mjs"
 import {
@@ -46,7 +47,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
   }
 
   async function init() {
-    if (config.autoCapture) await migrateLegacySessionMap()
+    if (isCaptureEnabled(config)) await migrateLegacySessionMap()
     await loadState()
     const health = await fetchJSON(config, "/health", {}, { timeoutMs: 5000 })
     if (health.ok) {
@@ -157,9 +158,9 @@ export function createMemorySessionManager({ config, pluginRoot }) {
       await handleSessionCompacted(event)
     } else if (event.type === "session.idle") {
       await handleSessionIdle(event)
-    } else if (event.type === "message.updated" && config.autoCapture) {
+    } else if (event.type === "message.updated" && isCaptureEnabled(config)) {
       await handleMessageUpdated(event)
-    } else if (event.type === "message.part.updated" && config.autoCapture) {
+    } else if (event.type === "message.part.updated" && isCaptureEnabled(config)) {
       await handleMessagePartUpdated(event)
     }
   }
@@ -286,7 +287,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     if (!state) return false
 
     const added = await flushPendingMessages(opencodeSessionId, state)
-    if (commit && config.autoCapture) {
+    if (commit && isCaptureEnabled(config)) {
       await commitOvSession(state.ovSessionId, { force: true, reason })
     } else if (added > 0) {
       await maybeCommitByThreshold(state)
@@ -388,7 +389,7 @@ export function createMemorySessionManager({ config, pluginRoot }) {
   }
 
   async function flushPendingMessages(opencodeSessionId, state) {
-    if (!config.autoCapture) return 0
+    if (!isCaptureEnabled(config)) return 0
     const toSend = []
     for (const [messageId, message] of state.messages.entries()) {
       if (message.captured) continue

package/lib/repo-context.mjs

@@ -1,4 +1,4 @@
-import { effectivePeerId, log, makeRequest, unwrapResponse } from "./utils.mjs"
+import { effectivePeerId, log, makeRequest } from "./utils.mjs"
 
 export function createRepoContext({ config }) {
   let cachedRepos = null
@@ -14,13 +14,12 @@ export function createRepoContext({ config }) {
     }
 
     try {
-      const response = await makeRequest(config, {
+      const result = await makeRequest(config, {
         method: "GET",
         endpoint: `/api/v1/fs/ls?uri=${encodeURIComponent("viking://resources/")}&recursive=false&simple=false`,
         timeoutMs: 8000,
         actorPeerId: effectivePeerId(config),
       })
-      const result = unwrapResponse(response)
       const items = Array.isArray(result) ? result : []
       const repos = items
         .filter((item) => item?.uri?.startsWith("viking://resources/") && item.uri !== "viking://resources/")

package/lib/runtime.mjs

@@ -1,24 +1,17 @@
-import { log, makeToast, normalizeEndpoint } from "./utils.mjs"
+import { fetchJSON, getResponseErrorMessage, log, makeToast } from "./utils.mjs"
 
+// The probe used to send a User-Agent and nothing else, so a server that wants
+// a key reported itself as down and the plugin disabled itself on startup.
 export async function checkServiceHealth(config, timeoutMs = 3000) {
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), timeoutMs)
-  try {
-    const response = await fetch(`${normalizeEndpoint(config.endpoint)}/health`, {
-      method: "GET",
-      headers: config.userAgent ? { "User-Agent": config.userAgent } : undefined,
-      signal: controller.signal,
-    })
-    return response.ok
-  } catch (error) {
-    log("WARN", "health", "OpenViking health check failed", {
-      endpoint: config.endpoint,
-      error: error?.message,
-    })
-    return false
-  } finally {
-    clearTimeout(timeout)
-  }
+  const res = await fetchJSON(config, "/health", { method: "GET" }, { timeoutMs })
+  if (res.ok) return true
+
+  log("WARN", "health", "OpenViking health check failed", {
+    endpoint: config.endpoint,
+    status: res.status,
+    error: getResponseErrorMessage(res.error),
+  })
+  return false
 }
 
 export async function initializeRuntime(config, client) {

package/lib/shared/capture-utils.mjs

@@ -1,4 +1,6 @@
 // GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+import { applyInputFilters, compileInputFilters } from "./input-filters.mjs";
+
 const TEXT_BLOCK_TYPES = new Set(["text", "input_text", "output_text"]);
 const TOOL_CALL_TYPES = new Set([
   "tool_call",
@@ -264,7 +266,13 @@ export function extractTextFromPayload(payload, options = {}) {
   return chunks.join("\n\n");
 }
 
-function collectToolNamesByIdFromEntries(entries) {
+/**
+ * Map every tool call id in a transcript to the name of the tool it invoked.
+ *
+ * A result block names the call by id only, so the name has to come from the
+ * call that preceded it. Pass the map as `toolNameById` to the extractors.
+ */
+export function collectToolNamesByIdFromEntries(entries) {
   const map = {};
   for (const entry of entries || []) {
     const payload = entry?.payload && typeof entry.payload === "object" ? entry.payload : entry;
@@ -354,6 +362,53 @@ export function extractPartsFromPayload(payload, options = {}) {
   return parts;
 }
 
+/**
+ * Prune blank text parts and run `cfg.captureFilters` over the ones that remain.
+ *
+ * One drop verdict is taken per turn, on the aggregate of its text parts; the
+ * individual parts are then rewritten with the substitutions only, so a rule can
+ * never both keep and drop the same turn. Tool call/result parts are carried
+ * through untouched — filters match conversation text, not tool payloads — but a
+ * turn dropped on its text takes its tool parts with it.
+ */
+export function filterCaptureParts(parts, role, cfg = {}) {
+  const kept = [];
+  for (const part of parts || []) {
+    if (!part) continue;
+    if (part.type !== "text") {
+      kept.push(part);
+      continue;
+    }
+    const text = typeof part.text === "string" ? part.text.trim() : "";
+    if (!text) continue;
+    kept.push(text === part.text ? part : { ...part, text });
+  }
+
+  const blank = { parts: kept, dropped: false };
+  const compiled = compileInputFilters(cfg?.captureFilters);
+  if (!compiled.rules.length || kept.length === 0) return blank;
+
+  const textParts = kept.filter((part) => part.type === "text");
+  if (textParts.length === 0) return blank;
+
+  const verdict = applyInputFilters(textParts.map((part) => part.text).join("\n\n"), compiled.rules, {
+    role,
+  });
+  if (verdict.dropped) return { parts: [], dropped: true };
+
+  const out = [];
+  for (const part of kept) {
+    if (part.type !== "text") {
+      out.push(part);
+      continue;
+    }
+    const shaped = applyInputFilters(part.text, compiled.rules, { role, substituteOnly: true });
+    if (!shaped.text) continue;
+    out.push(shaped.text === part.text ? part : { ...part, text: shaped.text });
+  }
+  return { parts: out, dropped: out.length === 0 };
+}
+
 export function extractCaptureTurns(rolloutEntries, cfg = {}) {
   const toolNameById = collectToolNamesByIdFromEntries(rolloutEntries);
   const turns = [];
@@ -371,14 +426,37 @@ export function extractCaptureTurns(rolloutEntries, cfg = {}) {
       toolMaxChars: cfg.captureToolMaxChars,
       toolNameById,
     });
-    const decision = shouldCaptureText(rawText, role, cfg);
-    if (!decision.shouldCapture && parts.length === 0) continue;
+    const shaped = filterCaptureParts(parts, role, cfg);
+    if (shaped.dropped) continue;
+    // With parts on the wire the drop decision was already taken above, so the
+    // text path only runs the filters for the `content` fallback. That also
+    // keeps `turn.text` faithful for callers that scan it for trigger words.
+    const decision = shouldCaptureText(rawText, role, cfg, { filters: shaped.parts.length === 0 });
+    if (!decision.shouldCapture && shaped.parts.length === 0) continue;
     const text = decision.shouldCapture ? decision.text : "";
-    turns.push({ role, text, parts });
+    turns.push({ role, text, parts: shaped.parts });
   }
   return turns;
 }
 
+/**
+ * Index of the last turn that came from a human prompt, or -1.
+ *
+ * `role === "user"` alone is not enough: normalizeCaptureRole() maps tool
+ * results onto the user role too, and those carry `tool` parts rather than
+ * `text` parts. Used by the post-compact shrink path to find where the current
+ * interaction starts.
+ */
+export function findLastHumanTurnIndex(turns) {
+  const list = Array.isArray(turns) ? turns : [];
+  for (let i = list.length - 1; i >= 0; i -= 1) {
+    const turn = list[i];
+    if (turn?.role !== "user") continue;
+    if (turn.parts?.some((part) => part?.type === "text")) return i;
+  }
+  return -1;
+}
+
 export function normalizeCaptureRole(role) {
   const value = normalizeType(role);
   if (value === "user") return "user";
@@ -457,12 +535,24 @@ function stripInjectedDigestBlocks(text) {
   return out.join("\n");
 }
 
+/**
+ * Drop everything in a turn that the conversation did not put there.
+ *
+ * Recall injects a context block into the prompt, and the host adds notes of
+ * its own; captured back unchanged, this turn's injection becomes next turn's
+ * memory and the loop feeds on itself. Formatting the conversation did author
+ * — newlines, code fences — survives.
+ */
 export function sanitizeCapturedText(text) {
   let value = String(text || "");
   value = value
     .replace(/\u0000/g, "")
     .replace(/<openviking-context\b[^>]*>[\s\S]*?<\/openviking-context>/gi, " ")
     .replace(/<relevant-memor(?:y|ies)\b[^>]*>[\s\S]*?<\/relevant-memor(?:y|ies)>/gi, " ")
+    // Claude Code wraps its own out-of-band notes to the model in these two
+    // shapes. They are the host talking to itself, not the conversation.
+    .replace(/<system-reminder\b[^>]*>[\s\S]*?<\/system-reminder>/gi, " ")
+    .replace(/^[ \t]*\[Subagent Context\][^\n]*$/gim, " ")
     .replace(/^\s*Sender\s*\([^)]+\)\s*```[\s\S]*?```\s*/gim, " ")
     .replace(/^\s*Conversation (?:metadata|info):\s*```[\s\S]*?```\s*/gim, " ")
     .replace(/^\s*\[?\d{4}-\d{2}-\d{2}[T ][^\]\n]{3,80}\]?\s*/gm, "")
@@ -486,12 +576,38 @@ function isPunctuationOnly(text) {
   return !/[a-z0-9\u3400-\u9fff]/i.test(text);
 }
 
-export function shouldCaptureText(text, role, cfg = {}) {
+/**
+ * Is capture on for this config?
+ *
+ * The switch has four spellings in the wild: a boolean `autoCapture`, opencode's
+ * `{ enabled }` object, dsh and pi's `syncTurns`, and the global `enabled`
+ * that turns the whole plugin off. Reading it here rather than in each loader
+ * is what keeps it from drifting a fifth time — and any spelling that says off
+ * wins, so a config that disables capture under an older name still disables it.
+ */
+export function isCaptureEnabled(cfg = {}) {
+  for (const value of [cfg.enabled, cfg.autoCapture, cfg.capture, cfg.syncTurns]) {
+    if (value === false) return false;
+    if (value && typeof value === "object" && !Array.isArray(value) && value.enabled === false) return false;
+  }
+  return true;
+}
+
+export function shouldCaptureText(text, role, cfg = {}, { filters = true } = {}) {
   const maxLength = cfg.captureMaxLength || 24000;
   const sanitized = sanitizeCapturedText(text);
   if (!sanitized) return { shouldCapture: false, reason: "empty", text: "" };
 
-  const capped = truncateCaptureText(sanitized, maxLength);
+  let capped = truncateCaptureText(sanitized, maxLength);
+  if (filters) {
+    const compiled = compileInputFilters(cfg?.captureFilters);
+    if (compiled.rules.length) {
+      const verdict = applyInputFilters(capped, compiled.rules, { role });
+      if (verdict.dropped) return { shouldCapture: false, reason: "filtered", text: "" };
+      capped = verdict.text;
+      if (!capped) return { shouldCapture: false, reason: "empty", text: "" };
+    }
+  }
   const compact = oneLine(capped);
   const isToolSummary = /^\[tool-(?:call|result)\b/i.test(compact);
 
@@ -513,3 +629,26 @@ export function shouldCaptureText(text, role, cfg = {}) {
 
   return { shouldCapture: true, reason: "ok", text: capped };
 }
+
+/**
+ * Apply the capture filter to a list of `{ role, content }` turns.
+ *
+ * The harnesses that compose `agent-hook-runtime` used to send whatever their
+ * transcript parser produced: an acknowledgement, a slash command, a stray
+ * `ok`, or a turn far past `captureMaxLength` all reached the extractor
+ * verbatim. This is the same decision every other harness makes, in one place,
+ * so a thin harness gets it by calling rather than by reimplementing it.
+ *
+ * Returns the surviving turns with `content` replaced by the sanitized and
+ * capped text, and the dropped ones with the reason, for the debug log.
+ */
+export function filterCaptureTurns(turns, cfg = {}) {
+  const kept = [];
+  const dropped = [];
+  for (const turn of Array.isArray(turns) ? turns : []) {
+    const decision = shouldCaptureText(turn?.content, turn?.role, cfg);
+    if (decision.shouldCapture) kept.push({ ...turn, content: decision.text });
+    else dropped.push({ role: turn?.role, reason: decision.reason });
+  }
+  return { kept, dropped };
+}