@openviking/dsh-memory-plugin 0.3.2 → 0.4.4

package/README.md

@@ -29,6 +29,8 @@ be a real package. Linking a source checkout (`dsh plugin --profile web add
 ./examples/dsh-memory-plugin`) only works when that checkout has its own
 `node_modules`, because Node resolves the bundle's dsh peers from the source
 tree's realpath rather than from the profile.
+It also needs `node examples/memory-plugin-shared/sync.mjs` run first: the
+`shared/` modules the bundle imports are generated, not committed.
 
 ## Requirements
 
@@ -122,11 +124,13 @@ SDK client opens that standalone stream it stops resolving POST responses, so
 `tools/list` never returns. The proxy owns the transport itself and is
 unaffected.
 
-The bundle's resolved credentials travel to the proxy through the child
-environment, because DSH scrubs credential-shaped names out of the inherited env
-and a subprocess cannot see the Cordis patch; the proxy then applies the usual
-`OPENVIKING_*` → `ovcli.conf` → `ov.conf` chain and reloads when those files
-change.
+The bundle's resolved connection — url, MCP url, key, account, user and auth
+mode — travels to the proxy through the child environment, because DSH scrubs
+credential-shaped names out of the inherited env and a subprocess cannot see the
+Cordis patch. It goes with `OPENVIKING_CREDENTIAL_SOURCE=env`, so the proxy reads
+no config file and reaches the server exactly as the runtime does, including
+with no key when the runtime has none. A changed `ovcli.conf` therefore takes
+effect for the tools when DSH restarts the bundle, as it does for the runtime.
 
 Two consequences follow from the proxy being one process per profile:
 
@@ -199,7 +203,8 @@ The patch can also carry plugin config:
 - `skipSubagentSessions: true` excludes sessions marked with `header.origin: subagent` from automatic profile, recall, capture, and commit; it defaults to `false`.
 - `syncTurns: false` stops every new write: no captured messages, no threshold or shutdown commit. Writes queued while the toggle was on are still replayed by the background drainer once the server recovers — they were captured with the toggle on. Profile injection and recall are unaffected; it defaults to `true`.
 - Failed writes enter the shared OpenViking pending queue. A background drainer (default every 60s, `OPENVIKING_PENDING_DRAIN_INTERVAL_MS`) probes the server health and replays the queue in-process, so a transient write failure recovers without restarting dsh; it does not consume the session-start retry budget. Session-start replays keep consuming retries as before.
-- `tools/pre-execute` blocks DSH filesystem and shell tools from treating `viking://` URIs as local paths, pointing the model at the bridged `mcp__openviking__*` tools instead.
+- `tools/pre-execute` denies a DSH filesystem tool (`read`, `glob`, `grep`, `edit`, `write`, `str_replace_editor`) whose path argument is a `viking://` URI, pointing the model at the bridged `mcp__openviking__*` tools instead. A `grep` whose pattern is `viking://` text still runs.
+- `tools/post-execute` lets a `bash` command that carries a `viking://` URI run unchanged and attaches a notice for the model: use the bridged tools if it meant OpenViking content, or ignore the notice when the URI is intentional data such as an `ov` argument or an HTTP payload.
 
 Each DSH session maps to `dsh-<session-id>` in OpenViking. Workspace-derived actor peers are resolved per session and sent on every session-specific request: the peer is the git identity of the session's workspace — the normalized `origin` URL (`git@github.com:volcengine/OpenViking.git` becomes `github.com-volcengine-openviking`), else the repository root path, that fallback keeping the older rule where every non-letter-or-digit character becomes `-`. Outside a git repository no peer is sent at all, and what is remembered there goes to the user-level space `viking://user/<you>/memories`. One repository therefore keeps one peer across subdirectories, worktrees, clones and machines, while a fork's different origin keeps it separate. DSH does not read workspace `.openviking/config.json` files, so a `peer.id` written there has no effect; pin a peer with `OPENVIKING_PEER_ID` instead. Memories written under the older path-derived peer stay reachable: the default `recallPeerScope: all` sweeps every peer under the user.
 

package/capture.mjs

@@ -1,3 +1,4 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import {
   extractPartsFromPayload,
   extractTextFromPayload,
@@ -6,6 +7,19 @@ import {
 
 export const OPENVIKING_PLUGIN_SOURCE = "openviking-memory";
 
+export function pluginMessage(content, source) {
+  // dsh's own constructor: identity, normalization, and any future Message
+  // invariants come from the pinned peer instead of a hand-built object.
+  return createUserMessage({
+    content: [{ type: "text", text: content }],
+    source: {
+      kind: "plugin",
+      plugin: OPENVIKING_PLUGIN_SOURCE,
+      ...source,
+    },
+  });
+}
+
 export function captureEvent(event, config, toolNames = new Map()) {
   if (!event || typeof event !== "object") return null;
   if (event.type === "tool/call") {

package/client.mjs

@@ -1,67 +1,13 @@
+import { createOvHttp } from "./shared/ov-http.mjs";
+
 export class OpenVikingClient {
   constructor(config) {
     this.config = config;
     this.connected = false;
-  }
-
-  headers(options = {}) {
-    const headers = { "Content-Type": "application/json" };
-    if (this.config.apiKey) headers.Authorization = `Bearer ${this.config.apiKey}`;
-    if (this.config.account) headers["X-OpenViking-Account"] = this.config.account;
-    if (this.config.user) headers["X-OpenViking-User"] = this.config.user;
-    const actorPeerId = options.actorPeerId ?? this.config.peerId;
-    if (actorPeerId) headers["X-OpenViking-Actor-Peer"] = actorPeerId;
-    if (this.config.userAgent) headers["User-Agent"] = this.config.userAgent;
-    return headers;
-  }
-
-  async fetchJSON(path, init = {}, options = {}) {
-    const timeoutMs = options.timeoutMs ?? this.config.requestTimeoutMs;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(`${this.config.endpoint}${path}`, {
-        ...init,
-        headers: {
-          ...this.headers(options),
-          ...(init.headers || {}),
-        },
-        signal: controller.signal,
-      });
-      const body = await response.json().catch(() => ({}));
-      const traceId = body?.result?.trace_id
-        || body?.error?.trace_id
-        || body?.trace_id
-        || undefined;
-      if (!response.ok || body?.status === "error") {
-        return {
-          ok: false,
-          result: null,
-          status: response.status,
-          error: body?.error || { message: `HTTP ${response.status}` },
-          traceId,
-        };
-      }
-      return {
-        ok: true,
-        result: body?.result ?? body,
-        status: response.status,
-        traceId,
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        result: null,
-        status: 0,
-        error: { message: error instanceof Error ? error.message : String(error) },
-      };
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  async health() {
-    return (await this.healthResult()).ok;
+    this.fetchJSON = createOvHttp(config, {
+      defaultTimeoutMs: config.requestTimeoutMs,
+      resolveActorPeerId: () => this.config.peerId,
+    });
   }
 
   async healthResult() {
@@ -70,12 +16,6 @@ export class OpenVikingClient {
     return response;
   }
 
-  async ensureSession(sessionId, actorPeerId) {
-    const response = await this.ensureSessionResult(sessionId, actorPeerId);
-    return response.ok
-      || (response.status === 409 && response.error?.code === "ALREADY_EXISTS");
-  }
-
   async ensureSessionResult(sessionId, actorPeerId) {
     const response = await this.fetchJSON("/api/v1/sessions", {
       method: "POST",
@@ -93,15 +33,6 @@ export class OpenVikingClient {
     return response.ok ? response.result : null;
   }
 
-  async getSessionArchive(sessionId, archiveId, actorPeerId) {
-    const response = await this.fetchJSON(
-      `/api/v1/sessions/${encodeURIComponent(sessionId)}/archives/${encodeURIComponent(archiveId)}`,
-      {},
-      { actorPeerId },
-    );
-    return response.ok ? response.result : null;
-  }
-
   async addMessage(sessionId, payload, actorPeerId) {
     return this.fetchJSON(
       `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`,
@@ -123,84 +54,4 @@ export class OpenVikingClient {
       { timeoutMs: options.timeoutMs ?? 30000, actorPeerId },
     );
   }
-
-  async find(query, options = {}) {
-    const body = { query };
-    if (options.targetUri) body.target_uri = options.targetUri;
-    if (options.limit) body.limit = options.limit;
-    if (options.scoreThreshold !== undefined) body.score_threshold = options.scoreThreshold;
-    const response = await this.fetchJSON("/api/v1/search/find", {
-      method: "POST",
-      body: JSON.stringify(body),
-    }, { actorPeerId: options.actorPeerId });
-    if (!response.ok || !response.result) return [];
-
-    const results = [];
-    for (const bucket of ["memories", "resources", "skills"]) {
-      const entries = response.result[bucket];
-      if (!Array.isArray(entries)) continue;
-      for (const entry of entries) {
-        results.push({
-          uri: entry?.uri || "",
-          contextType: entry?.context_type
-            || (bucket === "memories" ? "memory" : bucket === "skills" ? "skill" : "resource"),
-          score: Number(entry?.score || 0),
-          abstract: entry?.abstract || "",
-          overview: entry?.overview || null,
-        });
-      }
-    }
-    return results;
-  }
-
-  async read(uri, level, actorPeerId) {
-    const endpoint = level === "abstract"
-      ? "abstract"
-      : level === "overview"
-        ? "overview"
-        : "read";
-    const response = await this.fetchJSON(
-      `/api/v1/content/${endpoint}?uri=${encodeURIComponent(uri)}`,
-      {},
-      { actorPeerId },
-    );
-    return response.ok ? response.result : null;
-  }
-
-  async list(uri, actorPeerId) {
-    const response = await this.fetchJSON(
-      `/api/v1/fs/ls?uri=${encodeURIComponent(uri)}&output=original`,
-      {},
-      { actorPeerId },
-    );
-    return response.ok && Array.isArray(response.result) ? response.result : [];
-  }
-
-  async stat(uri, actorPeerId) {
-    const response = await this.fetchJSON(
-      `/api/v1/fs/stat?uri=${encodeURIComponent(uri)}`,
-      {},
-      { actorPeerId },
-    );
-    return response.ok ? response.result : null;
-  }
-
-  async forget(uri, recursive = false, actorPeerId) {
-    const response = await this.fetchJSON(
-      `/api/v1/fs?uri=${encodeURIComponent(uri)}&recursive=${recursive}`,
-      { method: "DELETE" },
-      { actorPeerId },
-    );
-    return response.ok;
-  }
-
-  async addResource(path, reason, actorPeerId) {
-    const body = { path };
-    if (reason) body.reason = reason;
-    const response = await this.fetchJSON("/api/v1/resources", {
-      method: "POST",
-      body: JSON.stringify(body),
-    }, { timeoutMs: 30000, actorPeerId });
-    return response.ok ? response.result : null;
-  }
 }

package/config.mjs

@@ -1,7 +1,7 @@
-import { buildUserAgent, resolveOpenVikingCredentials } from "./shared/credentials.mjs";
-import { resolveEffectivePeerId } from "./shared/workspace-peer.mjs";
+import { buildPluginConfig } from "./shared/plugin-config.mjs";
+import { loadCredentialFiles } from "./shared/credentials.mjs";
 
-export const PLUGIN_VERSION = "0.3.2";
+export const PLUGIN_VERSION = "0.4.4";
 
 /**
  * Namespace for the bridged OpenViking MCP tools. DSH publishes every MCP tool
@@ -10,172 +10,38 @@ export const PLUGIN_VERSION = "0.3.2";
  */
 export const MCP_SERVER_NAME = "openviking";
 
-const DEFAULT_CONFIG = Object.freeze({
-  endpoint: "http://127.0.0.1:1933",
-  apiKey: "",
-  account: "",
-  user: "",
-  peerId: "",
-  userAgent: "",
-  workspacePeer: true,
-  peerSource: "",
-  recallPeerScope: "all",
-  recallQueryExpansion: "auto",
-  recallQueryExpansionConfigured: false,
-  syncTurns: true,
-  recallTokenBudget: 2000,
-  recallMaxContentChars: 500,
-  recallPreferAbstract: true,
-  recallLimit: 10,
-  recallLimitConfigured: false,
-  scoreThreshold: 0.35,
-  minQueryLength: 3,
-  profileTokenBudget: 10000,
-  commitTokenThreshold: 20000,
-  commitKeepRecentCount: 10,
-  captureToolResults: false,
-  captureMode: "semantic",
-  captureMaxLength: 24000,
-  captureToolMaxChars: 1000000,
-  captureAssistantTurns: true,
-  skipSubagentSessions: false,
-  requestTimeoutMs: 10000,
-  mcpToolCallTimeoutMs: 60000,
-});
-
+/**
+ * Resolve the plugin's configuration.
+ *
+ * `input` is what the cordis host hands the plugin — this harness has no config
+ * file of its own. Every knob is declared in `shared/config-schema.mjs`, and
+ * `ovcli.conf`'s `plugin` section outranks the host's input so one file
+ * configures every harness and `ov config switch` moves them together.
+ * Connection fields are the exception: an endpoint, key, identity or auth mode
+ * named by the host is the more specific answer and stays ahead of the
+ * credential chain.
+ */
 export function resolveConfig(input = {}, env = process.env, cwd = process.cwd()) {
-  const credentials = resolveOpenVikingCredentials(env);
-  const explicitPeerId = input.peerId || credentials.peerId;
-  const config = {
-    ...DEFAULT_CONFIG,
-    ...input,
-    endpoint: input.endpoint || credentials.baseUrl || DEFAULT_CONFIG.endpoint,
-    apiKey: input.apiKey || credentials.apiKey,
-    account: input.account || credentials.account,
-    user: input.user || credentials.user,
-    peerId: explicitPeerId,
-    explicitPeerId,
-    userAgent: buildUserAgent("dsh", PLUGIN_VERSION),
-    harness: "dsh",
-    recallLimitConfigured: Object.prototype.hasOwnProperty.call(input, "recallLimit"),
-    recallQueryExpansionConfigured: Object.prototype.hasOwnProperty.call(input, "recallQueryExpansion"),
-  };
-
-  if (env.OPENVIKING_WORKSPACE_PEER !== undefined) {
-    config.workspacePeer = environmentBoolean(
-      env.OPENVIKING_WORKSPACE_PEER,
-      config.workspacePeer,
-    );
-  }
-  if (env.OPENVIKING_RECALL_PEER_SCOPE) {
-    config.recallPeerScope = env.OPENVIKING_RECALL_PEER_SCOPE;
-  }
-  if (env.OPENVIKING_RECALL_QUERY_EXPANSION) {
-    config.recallQueryExpansion = env.OPENVIKING_RECALL_QUERY_EXPANSION;
-    config.recallQueryExpansionConfigured = true;
-  }
-  if (env.OPENVIKING_RECALL_LIMIT) {
-    config.recallLimit = env.OPENVIKING_RECALL_LIMIT;
-    config.recallLimitConfigured = true;
-  }
-
-  config.endpoint = String(config.endpoint || DEFAULT_CONFIG.endpoint).replace(/\/+$/, "");
-  config.workspacePeer = config.workspacePeer !== false;
-  const effectivePeer = resolveEffectivePeerId({ cfg: config, cwd });
-  config.peerId = effectivePeer.peerId;
-  config.legacyPeerId = effectivePeer.legacyPeerId;
-  config.recallPeerScope = config.recallPeerScope === "actor" ? "actor" : "all";
-  config.recallQueryExpansion = config.recallQueryExpansion === "off" ? "off" : "auto";
-  config.recallLimit = clampInteger(config.recallLimit, 1, 50, DEFAULT_CONFIG.recallLimit);
-  config.recallMaxContentChars = clampInteger(
-    config.recallMaxContentChars,
-    100,
-    5000,
-    DEFAULT_CONFIG.recallMaxContentChars,
-  );
-  config.recallTokenBudget = clampInteger(
-    config.recallTokenBudget,
-    200,
-    50000,
-    DEFAULT_CONFIG.recallTokenBudget,
-  );
-  config.scoreThreshold = clampNumber(
-    config.scoreThreshold,
-    0,
-    1,
-    DEFAULT_CONFIG.scoreThreshold,
-  );
-  config.minQueryLength = clampInteger(
-    config.minQueryLength,
-    1,
-    64,
-    DEFAULT_CONFIG.minQueryLength,
-  );
-  config.profileTokenBudget = clampInteger(
-    config.profileTokenBudget,
-    500,
-    50000,
-    DEFAULT_CONFIG.profileTokenBudget,
-  );
-  config.commitTokenThreshold = clampInteger(
-    config.commitTokenThreshold,
-    1000,
-    1000000,
-    DEFAULT_CONFIG.commitTokenThreshold,
-  );
-  config.commitKeepRecentCount = clampInteger(
-    config.commitKeepRecentCount,
-    0,
-    1000,
-    DEFAULT_CONFIG.commitKeepRecentCount,
-  );
-  config.captureMaxLength = clampInteger(
-    config.captureMaxLength,
-    200,
-    100000,
-    DEFAULT_CONFIG.captureMaxLength,
-  );
-  config.captureToolMaxChars = clampInteger(
-    config.captureToolMaxChars,
-    200,
-    1000000,
-    DEFAULT_CONFIG.captureToolMaxChars,
-  );
-  config.requestTimeoutMs = clampInteger(
-    config.requestTimeoutMs,
-    1000,
-    120000,
-    DEFAULT_CONFIG.requestTimeoutMs,
-  );
-  config.mcpToolCallTimeoutMs = clampInteger(
-    config.mcpToolCallTimeoutMs,
-    1000,
-    600000,
-    DEFAULT_CONFIG.mcpToolCallTimeoutMs,
-  );
-  config.captureMode = config.captureMode === "keyword" ? "keyword" : "semantic";
-  config.syncTurns = config.syncTurns !== false;
-  config.captureAssistantTurns = config.captureAssistantTurns !== false;
-  config.captureToolResults = config.captureToolResults === true;
-  config.skipSubagentSessions = config.skipSubagentSessions === true;
-  return config;
-}
-
-function environmentBoolean(value, fallback) {
-  const normalized = String(value || "").trim().toLowerCase();
-  if (["0", "false", "no", "off"].includes(normalized)) return false;
-  if (["1", "true", "yes", "on"].includes(normalized)) return true;
-  return fallback;
-}
-
-function clampInteger(value, minimum, maximum, fallback) {
-  const number = Math.round(Number(value));
-  if (!Number.isFinite(number)) return fallback;
-  return Math.max(minimum, Math.min(maximum, number));
-}
-
-function clampNumber(value, minimum, maximum, fallback) {
-  const number = Number(value);
-  if (!Number.isFinite(number)) return fallback;
-  return Math.max(minimum, Math.min(maximum, number));
+  // ov.conf's `dsh` section is the legacy layer here as everywhere else, but
+  // the cordis patch shares that slot; the host named this process's settings,
+  // so it wins the overlap.
+  const ovSection = loadCredentialFiles(env).ovFile.dsh;
+  const config = buildPluginConfig("dsh", {
+    env,
+    cwd,
+    legacy: { ...(ovSection && typeof ovSection === "object" ? ovSection : {}), ...input },
+    version: PLUGIN_VERSION,
+    hostInput: {
+      peerId: input.peerId,
+      account: input.account,
+      user: input.user,
+      apiKey: input.apiKey,
+      baseUrl: input.endpoint,
+      // The legacy knob layer this used to ride accepted both spellings.
+      authMode: input.authMode || input.auth_mode,
+    },
+    deriveEffectivePeer: true,
+  });
+
+  return { ...config, peerId: config.effectivePeer.peerId };
 }

package/index.mjs

@@ -4,7 +4,7 @@ import { injectStartupProfile } from "./lifecycle.mjs";
 import { mountOpenVikingMcp } from "./mcp.mjs";
 import { OpenVikingRuntime } from "./runtime.mjs";
 import { mountOpenVikingSkills } from "./skills.mjs";
-import { guardVikingUri } from "./uri-guard.mjs";
+import { guardVikingUri, noticeVikingUri } from "./uri-guard.mjs";
 
 export const name = "openviking-memory";
 export const inject = ["agents", "sessions", "tools"];
@@ -71,6 +71,7 @@ export function apply(ctx, input = {}) {
   });
 
   ctx.on("tools/pre-execute", guardVikingUri);
+  ctx.on("tools/post-execute", noticeVikingUri);
 
   // Mounted last, and deliberately not awaited: the bridge's apply blocks on
   // its first tools/list, so a server that accepts the connection but never

package/mcp-env.mjs

@@ -0,0 +1,33 @@
+import { fileURLToPath } from "node:url";
+
+import { MCP_SERVER_NAME } from "./config.mjs";
+import { forwardConnectionEnv } from "./shared/mcp-proxy-config.mjs";
+
+/** The same stdio proxy every other OpenViking memory integration starts. */
+export const PROXY_PATH = fileURLToPath(new URL("./servers/mcp-proxy.mjs", import.meta.url));
+
+/**
+ * Build the dsh-mcp-client config for the OpenViking stdio proxy.
+ *
+ * DSH scrubs credential-shaped names out of the environment a subprocess
+ * inherits, and the Cordis patch is invisible to one, so the proxy cannot
+ * resolve the connection the way this process did. It gets the answer instead:
+ * the resolved connection and this session's peer, forwarded with the forced
+ * `env` source so the child reads no file and lands on exactly this url, key,
+ * identity, auth mode and peer — the empty ones included.
+ */
+export function buildMcpConfig(config) {
+  // In DSH Desktop, process.execPath is Electron's executable rather than a
+  // 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.timeoutMs) env.OPENVIKING_TIMEOUT_MS = String(config.timeoutMs);
+  return {
+    transport: "stdio",
+    serverName: MCP_SERVER_NAME,
+    command: process.execPath,
+    args: [PROXY_PATH],
+    env,
+    toolCallTimeoutMs: config.mcpToolCallTimeoutMs,
+  };
+}

package/mcp.mjs

@@ -1,39 +1,8 @@
-import { fileURLToPath } from "node:url";
 import * as mcpClient from "@deepseek-ai/dsh-mcp-client";
 
-import { MCP_SERVER_NAME } from "./config.mjs";
+import { buildMcpConfig } from "./mcp-env.mjs";
 
-/** The same stdio proxy every other OpenViking memory integration starts. */
-export const PROXY_PATH = fileURLToPath(new URL("./servers/mcp-proxy.mjs", import.meta.url));
-
-/**
- * Build the dsh-mcp-client config for the OpenViking stdio proxy.
- *
- * The bundle's own credential resolution (`OPENVIKING_*` → `ovcli.conf` →
- * `ov.conf`, plus anything set in the Cordis patch) is forwarded through the
- * child environment: DSH scrubs credential-shaped names out of the inherited
- * env, and the patch is invisible to a subprocess, so values the runtime
- * already resolved have to be passed explicitly.
- */
-export function buildMcpConfig(config) {
-  // In DSH Desktop, process.execPath is Electron's executable rather than a
-  // 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" };
-  if (config.endpoint) env.OPENVIKING_URL = config.endpoint;
-  if (config.apiKey) env.OPENVIKING_API_KEY = config.apiKey;
-  if (config.account) env.OPENVIKING_ACCOUNT = config.account;
-  if (config.user) env.OPENVIKING_USER = config.user;
-  if (config.peerId) env.OPENVIKING_PEER_ID = config.peerId;
-  return {
-    transport: "stdio",
-    serverName: MCP_SERVER_NAME,
-    command: process.execPath,
-    args: [PROXY_PATH],
-    env,
-    toolCallTimeoutMs: config.mcpToolCallTimeoutMs,
-  };
-}
+export { buildMcpConfig, PROXY_PATH } from "./mcp-env.mjs";
 
 /**
  * Mount the tool surface. The bridge ships with dsh itself, so it resolves

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/dsh-memory-plugin",
-  "version": "0.3.2",
+  "version": "0.4.4",
   "description": "OpenViking memory and context bundle for DeepSeek Harness",
   "type": "module",
   "main": "index.mjs",
@@ -14,6 +14,7 @@
     "capture.mjs",
     "lifecycle.mjs",
     "mcp.mjs",
+    "mcp-env.mjs",
     "runtime.mjs",
     "skills.mjs",
     "uri-guard.mjs",
@@ -29,10 +30,11 @@
     }
   },
   "scripts": {
+    "prepack": "node ../memory-plugin-shared/sync.mjs",
     "check": "for f in *.mjs shared/*.mjs; do node --check \"$f\" || exit 1; done && npm run check:version",
     "check:version": "node --input-type=module -e \"import {readFileSync} from 'node:fs'; const {PLUGIN_VERSION} = await import('./config.mjs'); const v = JSON.parse(readFileSync('package.json','utf8')).version; if (PLUGIN_VERSION !== v) throw new Error('PLUGIN_VERSION ' + PLUGIN_VERSION + ' does not match package.json version ' + v);\"",
     "test": "node --test *.test.mjs",
-    "prepublishOnly": "npm run check && npm test"
+    "prepublishOnly": "npm run prepack && npm run check && npm test"
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-llm": ">=0.1.0-rc.6 <0.2.0 || ^0.1.5-rc.1",