@openviking/opencode-plugin 2026.9.24-3 → 2026.9.24-5

package/index.mjs

@@ -56,9 +56,18 @@ function v1Hooks(runtime) {
 
     "chat.message": async (input, output) => {
       try {
-        await sessionInject.injectSessionContext(input, output)
-        if (!isRecallEnabled(config)) return
-        await recall.injectRelevantMemories(input, output)
+        // opencode awaits this hook before persisting/broadcasting the user
+        // message, so serial awaits here stack remote latency onto message
+        // display (#5148). Session inject and recall are independent after
+        // entry; overlap them the way the dsh plugin does (#4643).
+        if (!isRecallEnabled(config)) {
+          await sessionInject.injectSessionContext(input, output)
+          return
+        }
+        await Promise.all([
+          sessionInject.injectSessionContext(input, output),
+          recall.injectRelevantMemories(input, output),
+        ])
       } catch (error) {
         log("WARN", "recall", "Auto recall failed", { error: error?.message ?? String(error) })
       }

package/lib/memory-session.mjs

@@ -1,10 +1,9 @@
 import fs from "fs"
 import path from "path"
 import {
-  extractPartsFromPayload,
   extractTextFromPayload,
   isCaptureEnabled,
-  shouldCaptureText,
+  shapeCapturePayload,
 } from "./shared/capture-utils.mjs"
 import {
   deriveHarnessSessionId,
@@ -383,18 +382,17 @@ export function createMemorySessionManager({ config, pluginRoot }) {
     if (!role) return null
     if (role === "assistant" && !config.captureAssistantTurns) return null
 
-    const rawText = partsRaw
-      .map((part) => extractTextFromPayload(part, { toolMaxChars: config.captureToolMaxChars }))
-      .filter(Boolean)
-      .join("\n\n")
-    const captureParts = partsRaw.flatMap((part) => extractPartsFromPayload(part, {
-      toolMaxChars: config.captureToolMaxChars,
-    }))
-    const decision = shouldCaptureText(rawText, role, config)
-    if (!decision.shouldCapture && captureParts.length === 0) return null
-    const body = captureParts.length > 0
-      ? { role, parts: captureParts }
-      : { role, content: decision.text }
+    const shaped = shapeCapturePayload({ role, content: partsRaw }, role, config)
+    const toolParts = shaped.parts.filter((part) => part.type !== "text")
+    if (shaped.dropped || (!shaped.text && toolParts.length === 0)) return null
+    const body = toolParts.length > 0
+      ? { role, parts: [
+        ...(shaped.text && shaped.parts.some((part) => part.type === "text")
+          ? [{ type: "text", text: shaped.text }]
+          : []),
+        ...toolParts,
+      ] }
+      : { role, content: shaped.text }
     const peerId = effectivePeerId(config)
     if (peerId) body.peer_id = peerId
     return body

package/lib/shared/capture-utils.mjs

@@ -409,6 +409,61 @@ export function filterCaptureParts(parts, role, cfg = {}) {
   return { parts: out, dropped: out.length === 0 };
 }
 
+/** Sanitize already-extracted message parts before applying capture rules. */
+export function shapeCaptureParts(parts, role, cfg = {}) {
+  const sanitized = (parts || []).map((part) => part?.type === "text"
+    ? { ...part, text: sanitizeCapturedText(part.text) }
+    : part);
+  return filterCaptureParts(sanitized, role, cfg);
+}
+
+function faithfulCaptureDecision(text, cfg) {
+  const sanitized = sanitizeCapturedText(text);
+  if (!sanitized) return { shouldCapture: false, text: "" };
+  const capped = truncateCaptureText(sanitized, cfg.captureMaxLength || 24000);
+  const compact = oneLine(capped);
+  if (/^\[openviking-memory\]/i.test(compact) || SLASH_COMMAND_RE.test(compact)) {
+    return { shouldCapture: false, text: "" };
+  }
+  return { shouldCapture: true, text: capped };
+}
+
+/**
+ * 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.
+ */
+export function shapeCapturePayload(payload, role, cfg = {}, { toolNameById = {}, faithful = false } = {}) {
+  const options = { toolMaxChars: cfg.captureToolMaxChars, toolNameById };
+  const rawText = extractTextFromPayload(payload, options);
+  const sourceParts = extractPartsFromPayload(payload, options);
+  const hasTextPart = sourceParts.some((part) => part?.type === "text");
+  const sanitizedText = sanitizeCapturedText(rawText);
+  // Some hosts supply an array of plain strings. It has text but no structured
+  // parts, so use a temporary part for the same filter verdict.
+  const fallback = sourceParts.length === 0 && sanitizedText
+    ? [{ type: "text", text: rawText }]
+    : [];
+  const shaped = shapeCaptureParts(sourceParts.length ? sourceParts : fallback, role, cfg);
+  if (shaped.dropped) return { parts: [], text: "", signalText: "", dropped: true };
+
+  const parts = sourceParts.length ? shaped.parts : [];
+  const decisionText = hasTextPart || fallback.length
+    ? shaped.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n\n")
+    : sanitizedText;
+  const decision = faithful
+    ? faithfulCaptureDecision(decisionText, cfg)
+    : shouldCaptureText(decisionText, role, cfg, { filters: false });
+  // Codex scans turn.text for explicit-memory keywords; keep that scan based
+  // on the user's original words while the filtered parts go on the wire.
+  const signalText = decision.shouldCapture && parts.length
+    ? (faithful
+      ? faithfulCaptureDecision(sanitizedText, cfg)
+      : shouldCaptureText(sanitizedText, role, cfg, { filters: false })).text
+    : decision.text;
+  return { parts, text: decision.shouldCapture ? decision.text : "", signalText: signalText || "", dropped: false };
+}
+
 export function extractCaptureTurns(rolloutEntries, cfg = {}) {
   const toolNameById = collectToolNamesByIdFromEntries(rolloutEntries);
   const turns = [];
@@ -421,20 +476,9 @@ export function extractCaptureTurns(rolloutEntries, cfg = {}) {
     if (!role) continue;
     if (isAssistantSideCaptureRole(rawRole) && !cfg.captureAssistantTurns) continue;
 
-    const rawText = extractTextFromPayload(payload, { toolMaxChars: cfg.captureToolMaxChars });
-    const parts = extractPartsFromPayload(payload, {
-      toolMaxChars: cfg.captureToolMaxChars,
-      toolNameById,
-    });
-    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: shaped.parts });
+    const shaped = shapeCapturePayload(payload, role, cfg, { toolNameById });
+    if (shaped.dropped || (!shaped.text && shaped.parts.length === 0)) continue;
+    turns.push({ role, text: shaped.parts.length ? shaped.signalText : shaped.text, parts: shaped.parts });
   }
   return turns;
 }
@@ -555,7 +599,7 @@ export function sanitizeCapturedText(text) {
     .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, "")
+    .replace(/^[ \t]*\[\d{4}-\d{2}-\d{2}[T ][-+0-9:.Z]{5,35}\][ \t]*/gm, "")
     .replace(/^\s*\d{10,13}\s+/gm, "");
   value = stripMetadataFences(value);
   value = stripInjectedDigestBlocks(value);
@@ -598,16 +642,18 @@ export function shouldCaptureText(text, role, cfg = {}, { filters = true } = {})
   const sanitized = sanitizeCapturedText(text);
   if (!sanitized) return { shouldCapture: false, reason: "empty", text: "" };
 
-  let capped = truncateCaptureText(sanitized, maxLength);
+  // Rules judge the full sanitized turn; the wire cap applies afterward.
+  let filtered = sanitized;
   if (filters) {
     const compiled = compileInputFilters(cfg?.captureFilters);
     if (compiled.rules.length) {
-      const verdict = applyInputFilters(capped, compiled.rules, { role });
+      const verdict = applyInputFilters(filtered, compiled.rules, { role });
       if (verdict.dropped) return { shouldCapture: false, reason: "filtered", text: "" };
-      capped = verdict.text;
-      if (!capped) return { shouldCapture: false, reason: "empty", text: "" };
+      filtered = verdict.text;
+      if (!filtered) return { shouldCapture: false, reason: "empty", text: "" };
     }
   }
+  const capped = truncateCaptureText(filtered, maxLength);
   const compact = oneLine(capped);
   const isToolSummary = /^\[tool-(?:call|result)\b/i.test(compact);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/opencode-plugin",
-  "version": "2026.9.24-3",
+  "version": "2026.9.24-5",
   "author": "@openviking",
   "description": "Unified OpenCode plugin for OpenViking repository retrieval and long-term memory",
   "type": "module",
@@ -45,5 +45,5 @@
     "code-search"
   ],
   "license": "Apache-2.0",
-  "openvikingSourceCommit": "37390e6d71fb2f2ac62bd2c736be7a7ceab9043e"
+  "openvikingSourceCommit": "4edc30b068934893bc94a4e1b8e87bab2100bce5"
 }