@openviking/dsh-memory-plugin 0.5.2 → 0.5.4

package/capture.mjs

@@ -1,8 +1,7 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import {
-  extractPartsFromPayload,
   extractTextFromPayload,
-  shouldCaptureText,
+  shapeCapturePayload,
 } from "./shared/capture-utils.mjs";
 
 export const OPENVIKING_PLUGIN_SOURCE = "openviking-memory";
@@ -74,27 +73,23 @@ function captureMessage(event, message, config, toolNames) {
 
   const role = message.role === "assistant" ? "assistant" : "user";
   const toolNameById = Object.fromEntries(toolNames);
-  const rawText = extractTextFromPayload(message, {
-    toolMaxChars: config.captureToolMaxChars,
-  });
-  const parts = extractPartsFromPayload(message, {
-    toolMaxChars: config.captureToolMaxChars,
+  const shaped = shapeCapturePayload(message, role, config, {
     toolNameById,
   });
-  const decision = shouldCaptureText(rawText, role, config);
-  const structuredParts = parts.filter(part => part?.type !== "text");
-  if (!decision.shouldCapture && structuredParts.length === 0) return null;
+  if (shaped.dropped) return null;
+  const structuredParts = shaped.parts.filter(part => part?.type !== "text");
+  if (!shaped.text && structuredParts.length === 0) return null;
 
-  const hasTextPart = parts.some(part => part?.type === "text");
+  const hasTextPart = shaped.parts.some(part => part?.type === "text");
   const bodyParts = [
-    ...(hasTextPart && decision.shouldCapture && decision.text
-      ? [{ type: "text", text: decision.text }]
+    ...(hasTextPart && shaped.text
+      ? [{ type: "text", text: shaped.text }]
       : []),
     ...structuredParts,
   ];
   const payload = bodyParts.length > 0
     ? { role, parts: bodyParts }
-    : { role, content: decision.text };
+    : { role, content: shaped.text };
   const createdAt = eventCreatedAt(event);
   if (createdAt) payload.created_at = createdAt;
   if (config.peerId) payload.peer_id = config.peerId;

package/config.mjs

@@ -1,7 +1,7 @@
 import { buildPluginConfig } from "./shared/plugin-config.mjs";
 import { loadCredentialFiles } from "./shared/credentials.mjs";
 
-export const PLUGIN_VERSION = "0.5.2";
+export const PLUGIN_VERSION = "0.5.4";
 
 /**
  * Namespace for the bridged OpenViking MCP tools. DSH publishes every MCP tool

package/mcp-env.mjs

@@ -21,6 +21,7 @@ export function buildMcpConfig(config) {
   // standalone Node binary. This tells Electron to run the proxy script as
   // Node instead of attempting to launch a second Desktop instance.
   const env = { ELECTRON_RUN_AS_NODE: "1", ...forwardConnectionEnv(config) };
+  if (config.recallPeerScope) env.OPENVIKING_RECALL_PEER_SCOPE = config.recallPeerScope;
   if (config.timeoutMs) env.OPENVIKING_TIMEOUT_MS = String(config.timeoutMs);
   return {
     transport: "stdio",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/dsh-memory-plugin",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "OpenViking memory and context bundle for DeepSeek Harness",
   "type": "module",
   "main": "index.mjs",

package/runtime.mjs

@@ -139,6 +139,7 @@ export class OpenVikingRuntime {
         actorPeerId: state.config.peerId,
         legacyPeerId: state.config.legacyPeerId,
         sessionId: state.ovSessionId,
+        excludeUris: state.config.recallExcludeUris,
         log: (stage, data) => this.log(stage, data),
       },
     );

package/servers/mcp-proxy.mjs

@@ -21,11 +21,10 @@ export function readProxyConfig(env = process.env, cwd = process.cwd()) {
   const cfg = resolveConfig({}, env, cwd);
   return toMcpProxyConfig(cfg, {
     env,
-    // Not gated through `resolveMcpActorPeerId` like the other proxies: DSH's
-    // parent process resolves the peer per session and hands it over in the
-    // child env. Empty means it has none, and deriving one from wherever DSH
-    // launched this process would send a peer the runtime does not.
-    peerId: String(env.OPENVIKING_PEER_ID || "").trim(),
+    // The child env carries the runtime's resolved peer, but the shared mapper
+    // still decides whether the proxy may send it. In broad recall mode the
+    // actor header must stay unset; otherwise a process launched in workspace A
+    // narrows MCP searches for a session whose runtime is serving workspace B.
     debug: Boolean(env.OV_DEBUG_LOG),
     debugLogPath: env.OV_DEBUG_LOG || "",
   });

package/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);

package/shared/config-schema.mjs

@@ -93,6 +93,17 @@ export const KNOBS = [
   { name: "logRankingDetails", type: "bool", default: false, env: "OPENVIKING_LOG_RANKING_DETAILS", capability: "recall" },
   { name: "recallLedger", type: "bool", default: true, env: "OPENVIKING_RECALL_LEDGER", capability: "recall" },
   { name: "recallQueryFilters", type: "list", default: [], env: "OPENVIKING_RECALL_QUERY_FILTERS", capability: "recall" },
+  // Subtree URIs the recall search must never return. Without this there is no
+  // way to keep generated directory files (viking://user/<space>/skills,
+  // viking://user/<space>/resources, viking://agent/skills) out of the hits:
+  // they match like ordinary content and carry only boilerplate text.
+  {
+    name: "recallExcludeUris",
+    type: "list",
+    default: [],
+    env: "OPENVIKING_RECALL_EXCLUDE_URIS",
+    capability: "recall",
+  },
 
   // Digest compression. Claude Code reads this as the tri-state
   // off/client/server/auto through `normalizeRewriteMode`; Codex reads the same