@openviking/dsh-memory-plugin 0.5.8 → 0.5.10

package/README.md

@@ -216,7 +216,7 @@ The older size settings apply to fallback recall, not the primary context reques
 
 ## Behavior
 
-- `agent/session-start` injects the OpenViking profile, the available-memory index, and the `<available-skills>` catalog through `agent.inject()`.
+- Agent startup injects the OpenViking profile, the available-memory index, and the `<available-skills>` catalog through `agent.inject()`, and registers the per-session disposal commit. On DSH `0.1.7` and later this runs from the serial `agent/created` event (`{ agent, source, signal? }`), which holds queued input until it settles; DSH `0.1.0-rc.6` and `0.1.5` emit `agent/created` without `source` and start the session through `agent/session-start` instead. Startup runs once per agent, and `agent/pre-step` delivers the profile only if startup did not.
 - `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.

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.8";
+export const PLUGIN_VERSION = "0.5.10";
 
 /**
  * Namespace for the bridged OpenViking MCP tools. DSH publishes every MCP tool

package/index.mjs

@@ -34,14 +34,42 @@ export function apply(ctx, input = {}) {
     "openvikingMemory.stopDrainer()",
   );
 
-  ctx.on("agent/session-start", ({ agent }) => {
-    if (skipMemory(agent.session)) return false;
+  // Per-agent startup: register the session's disposal commit, initialize the
+  // OpenViking session, and inject the profile while the agent is still idle.
+  // Runs at most once per agent, whichever DSH event reaches it.
+  const started = new WeakSet();
+  const startAgent = async (agent, signal) => {
+    if (skipMemory(agent.session) || started.has(agent)) return false;
+    started.add(agent);
     agent.ctx.effect(
       () => () => runtime.dispose(agent.session),
       "openvikingMemory.disposeSession()",
     );
-    return injectStartupProfile(agent, runtime);
+    try {
+      return await injectStartupProfile(agent, runtime, signal);
+    } catch (error) {
+      // A throw from a serial `agent/created` listener fails agent creation;
+      // memory startup must never do that. pre-step retries profile delivery.
+      runtime.log("startup_error", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+  };
+
+  // DSH 0.1.7+ has no `agent/session-start`; startup is the serial
+  // `agent/created` event with `{ agent, source, signal? }`, and AgentLoop holds
+  // queued input until its listeners settle. DSH 0.1.0-rc.6 and 0.1.5 still
+  // emit a composition-only `agent/created` with `{ agent }` only, followed by
+  // `agent/session-start`, so a missing `source` leaves startup to that event.
+  // The listener must resolve to undefined: any other value bails the serial
+  // dispatch and skips the listeners registered after this one.
+  ctx.on("agent/created", async ({ agent, source, signal }) => {
+    if (source === undefined) return undefined;
+    await untilAborted(startAgent(agent, signal), signal);
+    return undefined;
   });
+  ctx.on("agent/session-start", ({ agent }) => startAgent(agent));
 
   // prepend: downstream waterfall listeners run first, so this plugin sees
   // the final claimed batch and appends after every other contributor.
@@ -83,3 +111,18 @@ export function apply(ctx, input = {}) {
   mountOpenVikingMcp(ctx, config);
   mountOpenVikingSkills(ctx);
 }
+
+// Resolve when `promise` settles or `signal` aborts, whichever comes first. An
+// abandoned initialization keeps running and is reused by the pre-step path.
+function untilAborted(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.resolve();
+  return new Promise(resolve => {
+    const onAbort = () => resolve();
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.finally(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    });
+  });
+}

package/lifecycle.mjs

@@ -1,6 +1,6 @@
-export async function injectStartupProfile(agent, runtime) {
+export async function injectStartupProfile(agent, runtime, signal) {
   await runtime.initialize(agent);
-  if (agent.status !== "idle") return false;
+  if (signal?.aborted || agent.status !== "idle") return false;
   const profile = await runtime.profileMessage(agent);
   if (!profile) return false;
   agent.inject(profile);

package/mcp-env.mjs

@@ -12,15 +12,20 @@ export const PROXY_PATH = fileURLToPath(new URL("./servers/mcp-proxy.mjs", impor
  * 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.
+ * the resolved connection, diagnostics, and this session's peer, forwarded
+ * with the forced `env` source so the child reads no file and lands on exactly
+ * these values — 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) };
+  const env = {
+    ELECTRON_RUN_AS_NODE: "1",
+    ...forwardConnectionEnv(config),
+    OPENVIKING_DEBUG: config.debug ? "1" : "0",
+    OPENVIKING_DEBUG_LOG: config.debugLogPath || "",
+  };
   if (config.recallPeerScope) env.OPENVIKING_RECALL_PEER_SCOPE = config.recallPeerScope;
   if (config.timeoutMs) env.OPENVIKING_TIMEOUT_MS = String(config.timeoutMs);
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/dsh-memory-plugin",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "OpenViking memory and context bundle for DeepSeek Harness",
   "icon": "./icon.svg",
   "type": "module",

package/servers/mcp-proxy.mjs

@@ -4,12 +4,13 @@
  * stdio -> streamable-HTTP MCP proxy for the OpenViking DSH bundle.
  *
  * DSH's MCP bridge starts this process as a local stdio MCP server. The proxy
- * resolves its connection through the same `resolveConfig()` as the in-process
- * runtime, from the child environment the bundle builds in `mcp.mjs`: DSH
+ * resolves its connection and diagnostics through the same `resolveConfig()`
+ * as the in-process runtime, from the child environment built in `mcp-env.mjs`: DSH
  * scrubs credential-shaped names out of what it inherits, and values that came
  * from the Cordis patch are invisible to a subprocess otherwise.
  */
 
+import { realpathSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveConfig } from "../config.mjs";
@@ -25,11 +26,20 @@ export function readProxyConfig(env = process.env, cwd = process.cwd()) {
     // 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 || "",
+    debug: env.OV_DEBUG_LOG ? true : cfg.debug,
+    debugLogPath: env.OV_DEBUG_LOG || cfg.debugLogPath,
   });
 }
 
-if (process.argv[1] && fileURLToPath(import.meta.url) === resolvePath(process.argv[1])) {
+function isDirectRun() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return resolvePath(process.argv[1]) === fileURLToPath(import.meta.url);
+  }
+}
+
+if (isDirectRun()) {
   createOpenVikingMcpProxy({ readConfig: readProxyConfig, loggerFactory: createLogger }).start();
 }