@openviking/dsh-memory-plugin 0.2.0 → 0.3.0

package/README.md

@@ -2,6 +2,10 @@
 
 An installable DeepSeek Harness bundle that adds OpenViking auto-recall, session capture, `viking://` URI protection, and the OpenViking MCP tool surface.
 
+> **Requires an OpenViking server with `viking://~` home-alias support.** Recall targets the
+> caller's own context space through `viking://~/memories` and `viking://~/skills`; the uid-less
+> `viking://user/memories` shorthand is rejected by newer servers.
+
 Published as [`@openviking/dsh-memory-plugin`](https://www.npmjs.com/package/@openviking/dsh-memory-plugin).
 
 ## Install
@@ -28,19 +32,19 @@ tree's realpath rather than from the profile.
 
 ## Requirements
 
-- `@deepseek-ai/dsh` `0.1.0-rc.6`
+- `@deepseek-ai/dsh` `0.1.0-rc.6` or newer in the `0.1.x` release line
 - Node.js `^22.19.0` or `>=24`
 - A reachable OpenViking server
 
 The bundle has no runtime npm dependencies. Its message structures come from
 `createUserMessage` (`@deepseek-ai/dsh-llm`), its tool surface from
 `@deepseek-ai/dsh-mcp-client`, and its skill provider from
-`@deepseek-ai/dsh-skill-filesystem` — exact-pinned peerDependencies that DSH
-itself already installs, so there is nothing extra to add to a profile.
-It is tested against `0.1.0-rc.6`; install that exact DSH release because
-prerelease package dist-tags are not synchronized across the package family.
-`overrides` holds the whole transitive `@deepseek-ai/dsh-*` family at the same
-release so a fresh `npm install` cannot float a subpackage forward.
+`@deepseek-ai/dsh-skill-filesystem` — peerDependencies that DSH itself already
+installs, so there is nothing extra to add to a profile. The supported peer
+range starts at `0.1.0-rc.6` and stops before `0.2.0`, allowing current DSH
+releases whose core packages resolve to newer release candidates. The local
+devDependencies and `overrides` stay pinned to rc.6 so CI continues to exercise
+the minimum supported contract.
 
 Everything under `shared/` and `skills/` is generated by
 `node examples/memory-plugin-shared/sync.mjs` — edit
@@ -137,6 +141,7 @@ The patch can also carry plugin config:
             recallTokenBudget: 2000
             scoreThreshold: 0.35
             captureToolResults: false
+            skipSubagentSessions: true
             commitTokenThreshold: 20000
             mcpToolCallTimeoutMs: 60000
 ```
@@ -147,6 +152,7 @@ The patch can also carry plugin config:
 - `agent/pre-step` retrieves with the current step input and appends a durable plugin message to that same step.
 - `session/event` captures user, assistant, and optionally tool-result messages without scraping a transcript.
 - `turn/end` checks the OpenViking pending-token threshold and commits when required.
+- `skipSubagentSessions: true` excludes sessions marked with `header.origin: subagent` from automatic profile, recall, capture, and commit; it defaults to `false`.
 - Failed writes enter the shared OpenViking pending queue for replay at the next session start.
 - `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.
 

package/config.mjs

@@ -1,7 +1,7 @@
 import { buildUserAgent, resolveOpenVikingCredentials } from "./shared/credentials.mjs";
 import { resolveEffectivePeerId } from "./shared/workspace-peer.mjs";
 
-export const PLUGIN_VERSION = "0.2.0";
+export const PLUGIN_VERSION = "0.3.0";
 
 /**
  * Namespace for the bridged OpenViking MCP tools. DSH publishes every MCP tool
@@ -37,6 +37,7 @@ const DEFAULT_CONFIG = Object.freeze({
   captureMaxLength: 24000,
   captureToolMaxChars: 1000000,
   captureAssistantTurns: true,
+  skipSubagentSessions: false,
   requestTimeoutMs: 10000,
   mcpToolCallTimeoutMs: 60000,
 });
@@ -152,6 +153,7 @@ export function resolveConfig(input = {}, env = process.env, cwd = process.cwd()
   config.syncTurns = config.syncTurns !== false;
   config.captureAssistantTurns = config.captureAssistantTurns !== false;
   config.captureToolResults = config.captureToolResults === true;
+  config.skipSubagentSessions = config.skipSubagentSessions === true;
   return config;
 }
 

package/index.mjs

@@ -13,6 +13,9 @@ export function apply(ctx, input = {}) {
   const config = resolveConfig(input);
   const client = new OpenVikingClient(config);
   const runtime = new OpenVikingRuntime(client, config, ctx.logger);
+  const skipMemory = session => (
+    config.skipSubagentSessions && session?.header?.origin === "subagent"
+  );
   ctx.provide("openvikingMemory", runtime);
   ctx.effect(
     () => () => runtime.disposeAll(),
@@ -20,6 +23,7 @@ export function apply(ctx, input = {}) {
   );
 
   ctx.on("agent/session-start", ({ agent }) => {
+    if (skipMemory(agent.session)) return false;
     agent.ctx.effect(
       () => () => runtime.dispose(agent.session),
       "openvikingMemory.disposeSession()",
@@ -31,6 +35,7 @@ export function apply(ctx, input = {}) {
   // the final claimed batch and appends after every other contributor.
   ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
     const decision = await next();
+    if (skipMemory(agent.session)) return decision;
     if (decision.kind !== "enter" || signal.aborted) return decision;
     const profile = await runtime.profileMessage(agent);
     if (signal.aborted) return decision;
@@ -43,11 +48,13 @@ export function apply(ctx, input = {}) {
   }, { prepend: true });
 
   ctx.on("session/event", (session, event) => {
+    if (skipMemory(session)) return;
     runtime.capture(session, event);
     runtime.maybeCommit(session, event);
   });
 
   ctx.on("session/flush", async session => {
+    if (skipMemory(session)) return;
     await runtime.flush(session);
   });
 

package/mcp.mjs

@@ -16,7 +16,10 @@ export const PROXY_PATH = fileURLToPath(new URL("./servers/mcp-proxy.mjs", impor
  * already resolved have to be passed explicitly.
  */
 export function buildMcpConfig(config) {
-  const env = {};
+  // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/dsh-memory-plugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "OpenViking memory and context bundle for DeepSeek Harness",
   "type": "module",
   "main": "index.mjs",
@@ -35,9 +35,9 @@
     "prepublishOnly": "npm run check && npm test"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-mcp-client": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-skill-filesystem": "0.1.0-rc.6"
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.6 <0.2.0",
+    "@deepseek-ai/dsh-mcp-client": ">=0.1.0-rc.6 <0.2.0",
+    "@deepseek-ai/dsh-skill-filesystem": ">=0.1.0-rc.6 <0.2.0"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-llm": "0.1.0-rc.6",

package/runtime.mjs

@@ -109,6 +109,10 @@ export class OpenVikingRuntime {
   async profileMessage(agent) {
     const state = await this.initialize(agent);
     if (!state.ready || !state.profileBlock || state.profileDelivered) return null;
+    if (hasStartupProfile(agent)) {
+      state.profileDelivered = true;
+      return null;
+    }
     state.profileDelivered = true;
     return pluginMessage(state.profileBlock, "instructions");
   }
@@ -314,3 +318,21 @@ function pluginMessage(content, form) {
     },
   });
 }
+
+function hasStartupProfile(agent) {
+  const session = agent.session;
+  const ownEvents = (session?.events || []).slice(session?.header?.seedLength ?? 0);
+  const inHistory = ownEvents.some(event => (
+    event?.type === "user/message" && isStartupProfile(event.data)
+  ));
+  if (inHistory) return true;
+  return [agent.inbox?.nextTurn, agent.inbox?.nextStep].some(messages => (
+    (messages || []).some(isStartupProfile)
+  ));
+}
+
+function isStartupProfile(message) {
+  return message?.source?.kind === "plugin"
+    && message.source.plugin === OPENVIKING_PLUGIN_SOURCE
+    && message.source.form === "instructions";
+}

package/shared/credentials.mjs

@@ -192,9 +192,20 @@ export function resolveOpenVikingCredentials(env = process.env) {
   const explicitMcpUrl = str(env.OPENVIKING_MCP_URL, "");
   const mcpUrl = (mode !== "cli" && explicitMcpUrl) ? explicitMcpUrl : `${baseUrl.replace(/\/+$/, "")}/mcp`;
 
+  // The file that actually supplied the api_key, following the same chain —
+  // empty when the key came from the environment or was never found.
+  let credentialPath = "";
+  if (apiKey) {
+    if (useCli) credentialPath = files.cliPath;
+    else if (str(env.OPENVIKING_BEARER_TOKEN, str(env.OPENVIKING_API_KEY, ""))) credentialPath = "";
+    else if (str(files.cliFile.api_key, "")) credentialPath = files.cliPath;
+    else credentialPath = files.ovPath;
+  }
+
   return {
     ...files,
     credentialSource: useCli ? "ovcli" : ((mode === "env" || envHasCredentials) ? "env" : "auto"),
+    credentialPath,
     baseUrl,
     mcpUrl,
     apiKey,

package/shared/mcp-proxy-config.mjs

@@ -41,6 +41,30 @@ export function defaultCredentialPaths(env = process.env) {
   ].filter(Boolean);
 }
 
+/**
+ * Resolve the actor peer header for a long-lived MCP proxy process.
+ *
+ * MCP servers may start in the plugin directory rather than the active
+ * workspace, so their process cwd is not a reliable peer identity. Broad
+ * recall intentionally spans the authenticated user's peer workspaces and
+ * therefore leaves the actor header unset. Actor-scoped recall requires an
+ * explicit peer so isolation never depends on the proxy launch directory.
+ */
+export function resolveMcpActorPeerId({
+  peerId = "",
+  recallPeerScope = "all",
+} = {}) {
+  if (recallPeerScope !== "actor") return "";
+
+  const explicitPeerId = String(peerId || "").trim();
+  if (explicitPeerId) return explicitPeerId;
+
+  throw new Error(
+    "OpenViking MCP actor-scoped recall requires an explicit peer ID. "
+    + "Set actor_peer_id in ovcli.conf or OPENVIKING_PEER_ID in the MCP environment.",
+  );
+}
+
 function uniq(values) {
   return [...new Set(values.filter(Boolean))];
 }

package/shared/mcp-proxy-core.mjs

@@ -295,7 +295,7 @@ export function createOpenVikingMcpProxy({
     return errorResponse(
       id,
       -32001,
-      `OpenViking MCP request failed. Check the configured URL (${proxyConfig.mcpUrl}) and that 'ov serve' is running.`,
+      `OpenViking MCP request failed. Check the configured URL (${proxyConfig.mcpUrl}) and that the OpenViking server (\`openviking-server\`) is reachable.`,
       { cause: msg },
     );
   }

package/shared/recall-core.mjs

@@ -14,8 +14,8 @@ const STOPWORDS = new Set([
 ]);
 const USER_RESERVED_DIRS = new Set(["memories", "skills"]);
 const SOURCES = [
-  { type: "memory", uri: "viking://user/memories", bucket: "memories" },
-  { type: "skill", uri: "viking://user/skills", bucket: "skills" },
+  { type: "memory", uri: "viking://~/memories", bucket: "memories" },
+  { type: "skill", uri: "viking://~/skills", bucket: "skills" },
 ];
 const DEFAULT_CONTEXT_LIMIT = 10;
 const DEFAULT_CONTEXT_MAX_TOKENS = 1600;
@@ -164,10 +164,9 @@ export function contextRequestTimeoutMs(cfg = {}, body = {}) {
   // `query_expansion` defaults to "auto" server-side, so only an explicit "off"
   // takes the expansion fuse back out of the budget.
   const wantsExpansion = Boolean(body.session_id) && body.query_expansion !== "off";
-  if (!wantsRewrite && !wantsExpansion) return undefined;
-
   const configured = Number(cfg.recallContextTimeoutMs);
   if (Number.isFinite(configured) && configured > 0) return Math.max(1000, Math.floor(configured));
+  if (!wantsRewrite && !wantsExpansion) return undefined;
   const floor = wantsRewrite ? SERVER_REWRITE_REQUEST_TIMEOUT_MS : EXPANSION_REQUEST_TIMEOUT_MS;
   return Math.max(Number(cfg.timeoutMs) || 0, floor);
 }
@@ -272,6 +271,11 @@ async function resolveUserSpace(fetchJSON, actorPeerId = "") {
 
 async function resolveTargetUri(fetchJSON, targetUri, actorPeerId = "") {
   const trimmed = targetUri.trim().replace(/\/+$/, "");
+  // viking://~ is the home alias: the server expands it to the caller's own user
+  // space, so it needs no client-side rewrite.
+  if (trimmed === "viking://~" || trimmed.startsWith("viking://~/")) return trimmed;
+  // Legacy compat: uid-less viking://user/<reserved> URIs may still sit in plugin
+  // configs. Newer servers reject them, so rewrite to an explicit-uid URI here.
   const m = trimmed.match(/^viking:\/\/user(?:\/(.*))?$/);
   if (!m) return trimmed;
   const rawRest = (m[1] ?? "").trim();

package/shared/setup-wizard.mjs

@@ -39,14 +39,17 @@ export async function runSetupWizard({
   output = process.stdout,
   env = process.env,
 } = {}) {
-  const { cliPath } = loadCredentialFiles(env);
-  const current = readJsonSafe(cliPath);
+  // cliPath is empty until the file exists; first-run writes go to the candidate
+  // path (OPENVIKING_CLI_CONFIG_FILE, else ~/.openviking/ovcli.conf).
+  const { cliPath, cliPathCandidate } = loadCredentialFiles(env);
+  const targetPath = cliPath || cliPathCandidate;
+  const current = readJsonSafe(targetPath);
   const rl = createInterface({ input, output });
   const say = (line = "") => output.write(`${line}\n`);
 
   try {
     say("OpenViking memory plugin setup");
-    say(`Config file: ${cliPath}`);
+    say(`Config file: ${targetPath}`);
     say("");
     say("Current values:");
     say(`  url:     ${current.url || "(not set)"}`);
@@ -89,22 +92,22 @@ export async function runSetupWizard({
     const confirm = (await rl.question("Write config? [Y/n] ")).trim().toLowerCase();
     if (confirm === "n" || confirm === "no") {
       say("Aborted; nothing written.");
-      return { written: false, path: cliPath };
+      return { written: false, path: targetPath };
     }
 
-    mkdirSync(dirname(cliPath), { recursive: true });
-    if (existsSync(cliPath)) {
-      copyFileSync(cliPath, `${cliPath}.bak.${Date.now()}`);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    if (existsSync(targetPath)) {
+      copyFileSync(targetPath, `${targetPath}.bak.${Date.now()}`);
     }
-    writeFileSync(cliPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(targetPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
     try {
-      chmodSync(cliPath, 0o600);
+      chmodSync(targetPath, 0o600);
     } catch {
       /* best effort on platforms without chmod semantics */
     }
-    say(`Written: ${cliPath}`);
+    say(`Written: ${targetPath}`);
     say("The stdio MCP proxy and hooks pick this up on the next harness start.");
-    return { written: true, path: cliPath };
+    return { written: true, path: targetPath };
   } finally {
     rl.close();
   }

package/shared/uri-guard.mjs

@@ -14,30 +14,52 @@ export function normalizeToolName(value) {
   return String(value || "").trim().toLowerCase();
 }
 
-export function findVikingUri(args = {}, keys = DEFAULT_URI_KEYS) {
+// Arguments that carry file CONTENT rather than a location. The sweep below
+// looks past the known path keys so an unusual one (`paths`, a nested target)
+// is still caught, but text a tool is asked to WRITE is not a path: a local
+// `write` whose body merely mentions viking://user/default/ was denied, and no
+// file was created. Skipped by name at any depth.
+const DEFAULT_CONTENT_KEYS = [
+  "content",
+  "contents",
+  "text",
+  "body",
+  "old_string",
+  "oldString",
+  "new_string",
+  "newString",
+  "old_str",
+  "new_str",
+  "file_text",
+  "insert_line",
+  "replacement",
+];
+
+export function findVikingUri(args = {}, keys = DEFAULT_URI_KEYS, contentKeys = DEFAULT_CONTENT_KEYS) {
   if (!args || typeof args !== "object") return null;
   for (const key of keys) {
     const uri = findVikingUriInValue(args[key]);
     if (uri) return uri;
   }
-  return findVikingUriInValue(args);
+  return findVikingUriInValue(args, new Set(contentKeys));
 }
 
-export function findVikingUriInValue(value) {
+export function findVikingUriInValue(value, skipKeys) {
   if (typeof value === "string") {
     const match = value.match(/\bviking:\/\/[^\s"'`<>)]*/i);
     return match?.[0] || null;
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      const uri = findVikingUriInValue(item);
+      const uri = findVikingUriInValue(item, skipKeys);
       if (uri) return uri;
     }
     return null;
   }
   if (value && typeof value === "object") {
-    for (const item of Object.values(value)) {
-      const uri = findVikingUriInValue(item);
+    for (const [key, item] of Object.entries(value)) {
+      if (skipKeys?.has(key)) continue;
+      const uri = findVikingUriInValue(item, skipKeys);
       if (uri) return uri;
     }
   }