@memorax/memorax-code 0.1.9 → 0.1.10

package/lib/memorax-code-backend/dist/trace/config.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { loadMemoraxCodeConfig } from "../config/memorax-code.js";
 import { isTraceClient } from "./context.js";
 export const TRACE_CLIENTS = ["codex", "claude", "dsh", "opencode"];
+export const TRACE_RUNTIME_CLIENTS = [...TRACE_CLIENTS, "codebuddy"];
 export const CODEX_TRACE_DEFAULT_CONFIG = {
     enabled: true,
     captureContent: true,
@@ -32,17 +33,22 @@ export const OPENCODE_TRACE_DEFAULT_CONFIG = {
     maxEventChars: 20_000,
     maxFileBytes: 52_428_800,
 };
+export const CODEBUDDY_TRACE_DEFAULT_CONFIG = {
+    ...OPENCODE_TRACE_DEFAULT_CONFIG,
+};
 const TRACE_DEFAULT_CONFIGS = {
     codex: CODEX_TRACE_DEFAULT_CONFIG,
     claude: CLAUDE_TRACE_DEFAULT_CONFIG,
     dsh: DSH_TRACE_DEFAULT_CONFIG,
     opencode: OPENCODE_TRACE_DEFAULT_CONFIG,
+    codebuddy: CODEBUDDY_TRACE_DEFAULT_CONFIG,
 };
 const TRACE_ENV_PREFIXES = {
     codex: "MEMORAX_CODE_CODEX_TRACE",
     claude: "MEMORAX_CODE_CLAUDE_TRACE",
     dsh: "MEMORAX_CODE_DSH_TRACE",
     opencode: "MEMORAX_CODE_OPENCODE_TRACE",
+    codebuddy: "MEMORAX_CODE_CODEBUDDY_TRACE",
 };
 export const TRACE_CLEANUP_DEBOUNCE_MS = 60 * 60 * 1000;
 export const TRACE_CURRENT_TURN_TTL_MS = 30 * 60 * 1000;
@@ -62,6 +68,9 @@ export function dshTraceConfigFromEnv(env = process.env, fileConfig) {
 export function openCodeTraceConfigFromEnv(env = process.env, fileConfig) {
     return clientTraceConfigFromEnv("opencode", env, fileConfig);
 }
+export function codeBuddyTraceConfigFromEnv(env = process.env, fileConfig) {
+    return clientTraceConfigFromEnv("codebuddy", env, fileConfig);
+}
 export function clientTraceConfigFromEnv(client, env = process.env, fileConfig) {
     assertTraceClient(client);
     const config = fileConfig ?? loadMemoraxCodeConfig(memoraxCodeHomeForTrace(env), { warn: () => undefined });
@@ -91,6 +100,9 @@ export function dshTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.
 export function openCodeTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     return clientTracePaths("opencode", memoraxCodeHome);
 }
+export function codeBuddyTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
+    return clientTracePaths("codebuddy", memoraxCodeHome);
+}
 export function clientTracePaths(client, memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     assertTraceClient(client);
     const root = join(memoraxCodeHome, "debug", "traces", client);

package/lib/memorax-code-backend/dist/trace/context.js

@@ -62,6 +62,26 @@ export function traceContextFromOpenCodeHookBody(body, capturedAt = new Date().t
         capturedAt,
     });
 }
+export function traceContextFromCodeBuddyHookBody(body, capturedAt = new Date().toISOString()) {
+    if (!isRecord(body))
+        return undefined;
+    const sessionId = stringField(body, "session_id") ?? stringField(body, "sessionId");
+    if (!sessionId)
+        return undefined;
+    const cwd = stringField(body, "cwd");
+    return pruneTraceContext({
+        schemaVersion: "1",
+        client: "codebuddy",
+        sessionId,
+        turnId: stringField(body, "turn_id") ?? stringField(body, "turnId"),
+        transcriptPath: stringField(body, "transcript_path") ?? stringField(body, "transcriptPath"),
+        cwd,
+        memoryProject: resolveMemoryProject(cwd),
+        workspaceKind: stringField(body, "workspace_kind") ?? stringField(body, "workspaceKind"),
+        contextOrigin: "codebuddy-hook-body",
+        capturedAt,
+    });
+}
 export function traceContextFromDshTurnStart(body, capturedAt = new Date().toISOString()) {
     return traceContextFromDshBody(body, "dsh-cordis-turn-start", capturedAt);
 }
@@ -129,7 +149,7 @@ function pruneRecord(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
 }
 export function isTraceClient(value) {
-    return value === "codex" || value === "claude" || value === "dsh" || value === "opencode";
+    return value === "codex" || value === "claude" || value === "dsh" || value === "opencode" || value === "codebuddy";
 }
 function traceContextFromDshBody(body, contextOrigin, capturedAt) {
     if (!isRecord(body))

package/lib/memorax-code-backend/dist/trace/store.js

@@ -60,6 +60,9 @@ export async function recordCodexTraceEvent(input) {
 export async function recordClaudeTraceEvent(input) {
     return recordTraceEventForClient("claude", input);
 }
+export async function recordCodeBuddyTraceEvent(input) {
+    return recordTraceEventForClient("codebuddy", input);
+}
 export function traceTurnEventId(traceContext, type) {
     if (!traceContext?.sessionId || !traceContext.turnId)
         return undefined;
@@ -168,6 +171,12 @@ export async function markCurrentCodexTurnOutcome(traceContext, outcome, options
 export async function markCurrentClaudeTurnOutcome(traceContext, outcome, options = {}) {
     return markCurrentTraceTurnOutcome(traceContext, outcome, { ...options, client: "claude" });
 }
+export async function writeCurrentCodeBuddyTurn(traceContext, options = {}) {
+    return writeCurrentTraceTurn(traceContext, { ...options, client: "codebuddy" });
+}
+export async function markCurrentCodeBuddyTurnOutcome(traceContext, outcome, options = {}) {
+    return markCurrentTraceTurnOutcome(traceContext, outcome, { ...options, client: "codebuddy" });
+}
 async function readCurrentTraceTurnRecord(options) {
     const client = options.client;
     if (!isTraceClient(client))
@@ -303,7 +312,9 @@ function buildTraceEvent(input, config, now, eventId) {
         ok: input.ok,
         outcome: input.outcome,
         related_turns: input.relatedTurns?.map(relatedTurnJson),
-        activities: input.activities,
+        activities: input.activities === undefined
+            ? undefined
+            : sanitizeTraceValue(input.activities, config, captureContent),
         usage: input.usage,
         session_turn_index: input.sessionTurnIndex,
         request: input.request === undefined ? undefined : sanitizeTraceValue(input.request, config, captureContent),

package/lib/memorax-code-backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/backend",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "description": "Local memory integration, lifecycle, trace, and diagnostics for MemoraX Code.",

package/lib/memorax-code-claude-adapter/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorax-code-claude-adapter",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Memory skill and local hooks for MemoraX Code in Claude Code.",
   "author": {
     "name": "MemoraX Code Maintainers"

package/lib/memorax-code-claude-adapter/hooks/runtime-shell.json

@@ -1,5 +1,5 @@
 {
   "version": 1,
-  "shellVersion": "0.1.9",
+  "shellVersion": "0.1.10",
   "runtimeAbi": 1
 }

package/lib/memorax-code-claude-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/claude-adapter",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "description": "Claude Code Hook adapter for MemoraX Code memory services.",

package/lib/memorax-code-claude-adapter/runtime-hooks/ensure-backend.mjs

@@ -2,6 +2,7 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readClientHookPluginRoot } from "../../memorax-code-adapter-common/src/config-utils.mjs";
 import {
   runEnsureBackendHook,
   stringValue,
@@ -31,6 +32,7 @@ process.exit(0);
 function pluginRoot() {
   return stringValue(process.env.CLAUDE_PLUGIN_ROOT)
     ?? stringValue(process.env.PLUGIN_ROOT)
+    ?? readClientHookPluginRoot()
     ?? dirname(dirname(fileURLToPath(import.meta.url)));
 }
 

package/lib/memorax-code-claude-adapter/src/plugin-install.mjs

@@ -32,6 +32,7 @@ const STABLE_SHELL_REQUIRED_FILES = Object.freeze([
   "memorax-code-adapter-common/src/hooks/capture-cwd-hook.mjs",
   "memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs",
   "memorax-code-adapter-common/src/config-utils.mjs",
+  "memorax-code-adapter-common/src/setup-completion.mjs",
   "memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs",
   "memorax-code-adapter-common/src/hooks/hook-runtime-generation.mjs",
   "memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs",
@@ -226,10 +227,12 @@ export function ensureClaudePluginInstalled(options = {}) {
 }
 
 function writeInstalledPluginMetadata(installPath, claudeCommand) {
+  const npmExecPath = stringOption(process.env.MEMORAX_CODE_NPM_EXEC_PATH);
   atomicWriteJson(join(installPath, ".memorax-code-package.json"), {
     version: 1,
     memoraxCodeCommand: process.argv[1],
     claudeCommand,
+    ...(npmExecPath ? { npmExecPath } : {}),
     writtenAt: new Date().toISOString(),
   });
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorax-code-claude-adapter",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Memory skill and local hooks for MemoraX Code in Claude Code.",
   "author": {
     "name": "MemoraX Code Maintainers"

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/hooks/runtime-shell.json

@@ -1,5 +1,5 @@
 {
   "version": 1,
-  "shellVersion": "0.1.9",
+  "shellVersion": "0.1.10",
   "runtimeAbi": 1
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/automatic-update-state.d.mts

@@ -0,0 +1,24 @@
+export type AutomaticUpdateRecord = Readonly<{
+  version: 1;
+  installedVersion: string;
+  nextCheckAt: string;
+}>;
+
+export type AutomaticUpdateState =
+  | Readonly<{ status: "absent" }>
+  | Readonly<{ status: "valid"; record: AutomaticUpdateRecord }>
+  | Readonly<{ status: "invalid"; reason: string }>
+  | Readonly<{ status: "unsupported"; version: number }>;
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION: 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS: number;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS: number;
+
+export function automaticUpdateStatePath(memoraxCodeHome: string): string;
+export function readAutomaticUpdateState(memoraxCodeHome: string): AutomaticUpdateState;
+export function writeAutomaticUpdateState(options: {
+  memoraxCodeHome: string;
+  nowMs: number;
+  installedVersion: string;
+  retry: boolean;
+}): AutomaticUpdateRecord;

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/automatic-update-state.mjs

@@ -0,0 +1,73 @@
+import { join, resolve } from "node:path";
+import {
+  readJsonRuntimeRecord,
+  writePrivateJsonRecord,
+} from "./runtime-record.mjs";
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION = 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS = 8 * 60 * 60 * 1_000;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS = 15 * 60 * 1_000;
+
+const RECORD_KEYS = new Set(["version", "installedVersion", "nextCheckAt"]);
+
+export function automaticUpdateStatePath(memoraxCodeHome) {
+  return join(resolve(memoraxCodeHome), "runtime", "install", "automatic-update.json");
+}
+
+export function readAutomaticUpdateState(memoraxCodeHome) {
+  const state = readJsonRuntimeRecord(automaticUpdateStatePath(memoraxCodeHome));
+  if (state.status !== "present") return state;
+  const value = state.value;
+  if (value.version !== AUTOMATIC_UPDATE_RECORD_VERSION) {
+    return Number.isSafeInteger(value.version) && value.version > 0
+      ? { status: "unsupported", version: value.version }
+      : { status: "invalid", reason: "invalid_version" };
+  }
+  if (Object.keys(value).length !== RECORD_KEYS.size
+    || Object.keys(value).some((key) => !RECORD_KEYS.has(key))) {
+    return { status: "invalid", reason: "unknown_or_missing_fields" };
+  }
+  const installedVersion = nonEmptyString(value.installedVersion);
+  const nextCheckAt = timestamp(value.nextCheckAt);
+  if (!installedVersion || !nextCheckAt) {
+    return { status: "invalid", reason: "invalid_fields" };
+  }
+  return {
+    status: "valid",
+    record: {
+      version: AUTOMATIC_UPDATE_RECORD_VERSION,
+      installedVersion,
+      nextCheckAt,
+    },
+  };
+}
+
+export function writeAutomaticUpdateState({ memoraxCodeHome, nowMs, installedVersion, retry }) {
+  const timestampMs = Number(nowMs);
+  const version = nonEmptyString(installedVersion);
+  if (!Number.isFinite(timestampMs) || !version) {
+    throw new TypeError("automatic update state requires a timestamp and installed version");
+  }
+  const record = {
+    version: AUTOMATIC_UPDATE_RECORD_VERSION,
+    installedVersion: version,
+    nextCheckAt: new Date(
+      timestampMs + (retry ? AUTOMATIC_UPDATE_RETRY_INTERVAL_MS : AUTOMATIC_UPDATE_CHECK_INTERVAL_MS),
+    ).toISOString(),
+  };
+  writePrivateJsonRecord(automaticUpdateStatePath(memoraxCodeHome), record, {
+    durableBoundary: memoraxCodeHome,
+  });
+  return record;
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function timestamp(value) {
+  const candidate = nonEmptyString(value);
+  return candidate && Number.isFinite(Date.parse(candidate))
+    ? new Date(Date.parse(candidate)).toISOString()
+    : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/clients/codebuddy-command.mjs

@@ -0,0 +1,82 @@
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, win32 } from "node:path";
+
+const APP_NAMES = ["WorkBuddy.app", "CodeBuddy.app"];
+const BUNDLED_SEGMENTS = ["Contents", "Resources", "app.asar.unpacked", "cli", "bin", "codebuddy"];
+const WINDOWS_SEGMENTS = [
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy"],
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy.exe"],
+];
+
+/**
+ * Resolve the CodeBuddy executable from the environment, installed adapter
+ * metadata, or the WorkBuddy/CodeBuddy application bundle.  Hooks are often
+ * launched by a GUI process and therefore cannot rely on the user's shell
+ * PATH or on npm's environment setup.
+ */
+export function resolveHookCodeBuddyCommand({
+  env = process.env,
+  pluginRoot,
+  homeDir = homedir(),
+  platform = process.platform,
+  pathExists = commandPathExists,
+} = {}) {
+  const configured = stringValue(env.MEMORAX_CODE_CODEBUDDY_COMMAND)
+    ?? stringValue(env.CODEBUDDY_CLI_PATH)
+    ?? stringValue(env.WORKBUDDY_CODEBUDDY_PATH);
+  if (configured) return configured;
+
+  const metadataCommand = readMetadataCommand(stringValue(pluginRoot) ?? stringValue(env.CODEBUDDY_PLUGIN_ROOT));
+  if (metadataCommand && pathExists(metadataCommand, platform)) return metadataCommand;
+
+  if (platform === "darwin") {
+    for (const root of [join(homeDir, "Applications"), "/Applications"]) {
+      for (const appName of APP_NAMES) {
+        const command = join(root, appName, ...BUNDLED_SEGMENTS);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  if (platform === "win32") {
+    for (const root of [
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "CodeBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "CodeBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "WorkBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "CodeBuddy"),
+    ].filter(Boolean)) {
+      for (const segments of WINDOWS_SEGMENTS) {
+        const command = win32.join(root, ...segments);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  return "codebuddy";
+}
+
+function readMetadataCommand(pluginRoot) {
+  if (!pluginRoot) return undefined;
+  try {
+    const metadata = JSON.parse(readFileSync(join(pluginRoot, ".memorax-code-package.json"), "utf8"));
+    return stringValue(metadata?.codeBuddyCommand);
+  } catch {
+    return undefined;
+  }
+}
+
+function commandPathExists(command, platform) {
+  if (!command.includes("/") && !command.includes("\\")) return true;
+  if (!existsSync(command)) return false;
+  try {
+    accessSync(command, platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/config-utils.d.mts

@@ -13,6 +13,8 @@ export function readJsonFile(path: string): any;
 export function readJsonValue(path: string): any;
 export function readStdinJson(): Promise<any>;
 export function injectClientHookInput(input: Record<string, unknown>): void;
+export function injectClientHookPluginRoot(pluginRoot: string): void;
+export function readClientHookPluginRoot(): string | undefined;
 export function sha256(value: string | NodeJS.ArrayBufferView): string;
 export function stringOption(value: unknown): string | undefined;
 export function atomicWriteJson(path: string, value: unknown): void;

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/config-utils.mjs

@@ -24,6 +24,7 @@ const JSON_FILE_LOCK_RETRY_MS = 10;
 const PROCESS_START_TOLERANCE_MS = 5000;
 const LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 const HOOK_INPUT_SYMBOL = Symbol.for("memorax-code.client-hook.input.v1");
+const HOOK_PLUGIN_ROOT_SYMBOL = Symbol.for("memorax-code.client-hook.plugin-root.v1");
 
 export function readAdapterState(path) {
   const state = readJsonFile(path);
@@ -64,6 +65,16 @@ export function injectClientHookInput(input) {
   globalThis[HOOK_INPUT_SYMBOL] = input;
 }
 
+export function injectClientHookPluginRoot(pluginRoot) {
+  const root = stringOption(pluginRoot);
+  if (!root) throw new TypeError("client Hook plugin root must be a non-empty string");
+  globalThis[HOOK_PLUGIN_ROOT_SYMBOL] = root;
+}
+
+export function readClientHookPluginRoot() {
+  return stringOption(globalThis[HOOK_PLUGIN_ROOT_SYMBOL]);
+}
+
 export function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs

@@ -5,6 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   injectClientHookInput,
+  injectClientHookPluginRoot,
   readStdinJson,
   stringOption,
   withJsonFileLock,
@@ -47,6 +48,8 @@ export async function runClientHookLauncher({
     });
     if (!selection) return;
     injectClientHookInput(input);
+    const originalPluginRoot = stringOption(pluginRoot);
+    if (originalPluginRoot) injectClientHookPluginRoot(originalPluginRoot);
     await import(pathToFileURL(selection.modulePath).href);
   } catch (error) {
     if (process.env[debugEnv] === "1") {

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, delimiter, join } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, delimiter, isAbsolute, join } from "node:path";
 import {
   localBackendRecoveryArguments,
   resolveBackendConnection,
@@ -16,8 +16,17 @@ export async function runEnsureBackendHook(options) {
 }
 
 export async function ensureBackendAvailable(options, input = {}) {
-  if (isRepoMemoryJobWorker() || ensureDisabled(options.ensureBackendValue)) return;
+  if (isRepoMemoryJobWorker()) return;
   const homes = options.resolveHomes(input);
+  const metadata = packageMetadata(options.pluginRoot);
+  const command = memoraxCodeCommandInfo(
+    options.memoraxCodeCommand,
+    metadata,
+    options.platform,
+  );
+  if (ensureDisabled(options.ensureBackendValue)) {
+    return;
+  }
   let connection;
   try {
     connection = options.backendConnection
@@ -34,19 +43,19 @@ export async function ensureBackendAvailable(options, input = {}) {
 
   const recoveryArguments = localBackendRecoveryArguments(connection);
   if (recoveryArguments === undefined) return;
-  const command = memoraxCodeCommandInfo(options.memoraxCodeCommand, options.pluginRoot);
   if (!command.value || command.removed === true || !memoraxCodeCommandAvailable(command.value)) return;
   const result = await runMemoraxCode(
     command.value,
     options.buildStartArgs(homes, recoveryArguments),
     parsePositiveInt(options.startTimeoutValue, DEFAULT_ENSURE_BACKEND_START_TIMEOUT_MS),
     options.nodePath,
-    options.recoveryEnv,
+    recoveryEnvironment(options.recoveryEnv, metadata),
   );
   if (result.code !== 0) {
     options.debug?.(
       `MemoraX Code backend start failed with code ${result.code}${result.stderr ? `: ${result.stderr}` : ""}`,
     );
+    return;
   }
 }
 
@@ -79,22 +88,48 @@ async function backendHealthy(connection, timeoutMs) {
   }
 }
 
-function memoraxCodeCommandInfo(explicitCommand, pluginRoot) {
+function memoraxCodeCommandInfo(explicitCommand, metadata, platform = process.platform) {
   const explicit = stringValue(explicitCommand);
   if (explicit) return { value: explicit, removed: pathLooksRemoved(explicit) };
-  const metadata = metadataCommand(pluginRoot);
-  if (metadata) return { value: metadata, removed: pathLooksRemoved(metadata) };
+  const command = stringValue(metadata?.memoraxCodeCommand);
+  if (command) return { value: command, removed: pathLooksRemoved(command) };
+  if (platform === "win32") return { value: undefined, removed: false };
   return { value: "memorax-code", removed: false };
 }
 
-function metadataCommand(pluginRoot) {
+function packageMetadata(pluginRoot) {
   const root = stringValue(pluginRoot);
   if (!root) return undefined;
   const path = join(root, ".memorax-code-package.json");
   if (!existsSync(path)) return undefined;
   try {
     const metadata = JSON.parse(readFileSync(path, "utf8"));
-    return stringValue(metadata.memoraxCodeCommand);
+    return metadata && typeof metadata === "object" && !Array.isArray(metadata)
+      ? metadata
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function recoveryEnvironment(recoveryEnv, metadata) {
+  if (stringValue(recoveryEnv?.MEMORAX_CODE_NPM_EXEC_PATH)
+    || stringValue(process.env.MEMORAX_CODE_NPM_EXEC_PATH)) {
+    return recoveryEnv;
+  }
+  const npmExecPath = metadataNpmExecPath(metadata);
+  return npmExecPath
+    ? { ...(recoveryEnv ?? {}), MEMORAX_CODE_NPM_EXEC_PATH: npmExecPath }
+    : recoveryEnv;
+}
+
+function metadataNpmExecPath(metadata) {
+  const npmExecPath = stringValue(metadata?.npmExecPath);
+  if (!npmExecPath || !isAbsolute(npmExecPath) || !/\.(?:cjs|js|mjs)$/i.test(npmExecPath)) {
+    return undefined;
+  }
+  try {
+    return statSync(npmExecPath).isFile() ? npmExecPath : undefined;
   } catch {
     return undefined;
   }