@openviking/opencode-plugin 2026.10.14 → 2026.10.15-2

package/lib/memory-session.mjs

@@ -25,6 +25,8 @@ import {
   safeStringify,
 } from "./utils.mjs"
 
+const STALE_SESSION_STATE_MS = 7 * 24 * 60 * 60 * 1000
+
 export function createMemorySessionManager({ config, pluginRoot }) {
   const sessions = new Map()
   const statePath = path.join(pluginRoot, "openviking-session-state.json")
@@ -77,10 +79,17 @@ export function createMemorySessionManager({ config, pluginRoot }) {
         log("ERROR", "persistence", "Unsupported session map version", { version: data.version })
         return
       }
+      const staleBefore = Date.now() - STALE_SESSION_STATE_MS
+      let pruned = 0
       for (const [opencodeSessionId, persisted] of Object.entries(data.sessions ?? {})) {
+        if (isPrunable(persisted, staleBefore)) {
+          pruned += 1
+          continue
+        }
         sessions.set(opencodeSessionId, deserializeSessionState(persisted))
       }
-      log("INFO", "persistence", "Session state loaded", { count: sessions.size })
+      log("INFO", "persistence", "Session state loaded", { count: sessions.size, pruned })
+      if (pruned > 0) await enqueueSave()
     } catch (error) {
       log("ERROR", "persistence", "Failed to load session state", { error: error?.message })
       if (fs.existsSync(statePath)) {
@@ -133,6 +142,12 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     }
   }
 
+  // A stale session whose messages are all captured holds nothing left to send.
+  function isPrunable(persisted, staleBefore) {
+    if ((persisted.lastActivityAt ?? 0) >= staleBefore) return false
+    return (persisted.messages ?? []).every(([, message]) => message.captured)
+  }
+
   function deserializeSessionState(persisted) {
     return {
       ovSessionId: persisted.ovSessionId,
@@ -301,7 +316,11 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     const run = (state.flushChain ?? Promise.resolve()).then(async () => {
       const added = await flushPendingMessages(opencodeSessionId, state)
       if (commit && isCaptureEnabled(config)) {
-        await commitOvSession(state.ovSessionId, { force: true, reason })
+        const result = await commitOvSession(state.ovSessionId, { force: true, reason })
+        // Server lost the session (reset/reinstall); drop the stale mapping.
+        if (result.status === "not_found" && sessions.get(opencodeSessionId) === state) {
+          sessions.delete(opencodeSessionId)
+        }
       } else if (added > 0) {
         await maybeCommitByThreshold(state)
       }
@@ -500,6 +519,14 @@ export function createMemorySessionManager({ config, pluginRoot }) {
       })
       return { status: "queued" }
     }
+    if (res.status === 404) {
+      log("WARN", "session", "OpenViking session not found", {
+        openviking_session: ovSessionId,
+        reason,
+        trace_id: res.traceId,
+      })
+      return { status: "not_found" }
+    }
     log("ERROR", "session", "Failed to commit OpenViking session", {
       openviking_session: ovSessionId,
       reason,

package/lib/shared/capture-utils.mjs

@@ -362,14 +362,41 @@ export function extractPartsFromPayload(payload, options = {}) {
   return parts;
 }
 
+function substituteValue(value, rules, role) {
+  if (typeof value === "string") {
+    let current = value;
+    for (const rule of rules) {
+      if (rule.op !== "s" || (rule.scope && rule.scope !== role)) continue;
+      current = current.replace(rule.re, rule.replacement);
+    }
+    return current;
+  }
+  if (Array.isArray(value)) return value.map((item) => substituteValue(item, rules, role));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, substituteValue(item, rules, role)]),
+    );
+  }
+  return value;
+}
+
+function substituteToolPart(part, rules, role) {
+  if (part.type !== "tool") return part;
+  const out = { ...part };
+  if (part.tool_input !== undefined) out.tool_input = substituteValue(part.tool_input, rules, role);
+  if (part.tool_output !== undefined) out.tool_output = substituteValue(part.tool_output, rules, role);
+  return out;
+}
+
 /**
  * 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.
+ * never both keep and drop the same turn. Tool call/result parts get the
+ * substitutions too, on their input values and output, so a redaction rule also
+ * covers a secret that reached a command or its output; only text parts decide
+ * the drop verdict, and a turn dropped on its text takes its tool parts with it.
  */
 export function filterCaptureParts(parts, role, cfg = {}) {
   const kept = [];
@@ -389,7 +416,9 @@ export function filterCaptureParts(parts, role, cfg = {}) {
   if (!compiled.rules.length || kept.length === 0) return blank;
 
   const textParts = kept.filter((part) => part.type === "text");
-  if (textParts.length === 0) return blank;
+  if (textParts.length === 0) {
+    return { parts: kept.map((part) => substituteToolPart(part, compiled.rules, role)), dropped: false };
+  }
 
   const verdict = applyInputFilters(textParts.map((part) => part.text).join("\n\n"), compiled.rules, {
     role,
@@ -399,7 +428,7 @@ export function filterCaptureParts(parts, role, cfg = {}) {
   const out = [];
   for (const part of kept) {
     if (part.type !== "text") {
-      out.push(part);
+      out.push(substituteToolPart(part, compiled.rules, role));
       continue;
     }
     const shaped = applyInputFilters(part.text, compiled.rules, { role, substituteOnly: true });
@@ -431,7 +460,7 @@ function faithfulCaptureDecision(text, cfg) {
 /**
  * Shape one host message before an adapter builds its session payload.
  * Sanitize injected context before evaluating keep/drop rules, so text that
- * will not be sent cannot satisfy a keep rule. Tool parts are never filtered.
+ * will not be sent cannot satisfy a keep rule. Tool parts never decide keep or drop.
  */
 export function shapeCapturePayload(payload, role, cfg = {}, { toolNameById = {}, faithful = false } = {}) {
   const options = { toolMaxChars: cfg.captureToolMaxChars, toolNameById };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "2026.10.14",
+  "version": "2026.10.15-2",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -46,5 +46,5 @@
     "code-search"
   ],
   "license": "Apache-2.0",
-  "openvikingSourceCommit": "e05460914532ba0a61d7bf859fc16b95e88d2194"
+  "openvikingSourceCommit": "621b1ddd9945c362464d18482adb1a48df5ee554"
 }