@memorax/memorax-code 0.1.2 → 0.1.4

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

@@ -5,19 +5,23 @@ import {
   localBackendRecoveryArguments,
   resolveBackendConnection,
 } from "../backend-connection.mjs";
-import { readStdinJson } from "../config-utils.mjs";
 import { isRepoMemoryJobWorker } from "../repo-memory/repo-memory-job-context.mjs";
 
 export const DEFAULT_ENSURE_BACKEND_START_TIMEOUT_MS = 90000;
+const HOOK_INPUT_SYMBOL = Symbol.for("memorax-code.client-hook.input.v1");
 
 export async function runEnsureBackendHook(options) {
-  if (isRepoMemoryJobWorker() || ensureDisabled(options.ensureBackendValue)) return;
-
   const input = await readStdinJson();
+  await ensureBackendAvailable(options, input);
+}
+
+export async function ensureBackendAvailable(options, input = {}) {
+  if (isRepoMemoryJobWorker() || ensureDisabled(options.ensureBackendValue)) return;
   const homes = options.resolveHomes(input);
   let connection;
   try {
-    connection = resolveBackendConnection({ memoraxCodeHome: homes.memoraxCodeHome });
+    connection = options.backendConnection
+      ?? resolveBackendConnection({ memoraxCodeHome: homes.memoraxCodeHome });
   } catch (error) {
     options.debug?.(error instanceof Error ? error.message : String(error));
     return;
@@ -36,6 +40,8 @@ export async function runEnsureBackendHook(options) {
     command.value,
     options.buildStartArgs(homes, recoveryArguments),
     parsePositiveInt(options.startTimeoutValue, DEFAULT_ENSURE_BACKEND_START_TIMEOUT_MS),
+    options.nodePath,
+    options.recoveryEnv,
   );
   if (result.code !== 0) {
     options.debug?.(
@@ -105,14 +111,14 @@ function memoraxCodeCommandAvailable(command) {
   return path.split(delimiter).some((dir) => dir && existsSync(join(dir, command)));
 }
 
-function runMemoraxCode(command, args, timeoutMs) {
+function runMemoraxCode(command, args, timeoutMs, nodePath, recoveryEnv) {
   return new Promise((resolve) => {
     const childArgs = nodeEntrypoint(command) ? [command, ...args] : args;
-    const childCommand = nodeEntrypoint(command) ? process.execPath : command;
+    const childCommand = nodeEntrypoint(command) ? (stringValue(nodePath) ?? process.execPath) : command;
     let stderr = "";
     let settled = false;
     const child = spawn(childCommand, childArgs, {
-      env: process.env,
+      env: recoveryEnv === undefined ? process.env : { ...process.env, ...recoveryEnv },
       stdio: ["ignore", "ignore", "pipe"],
     });
     const finish = (result) => {
@@ -140,3 +146,16 @@ function parsePositiveInt(value, fallback) {
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
+
+async function readStdinJson() {
+  const injected = globalThis[HOOK_INPUT_SYMBOL];
+  if (injected && typeof injected === "object" && !Array.isArray(injected)) return injected;
+  let text = "";
+  for await (const chunk of process.stdin) text += chunk;
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs

@@ -7,31 +7,43 @@ import {
   stringOption,
   withJsonFileLock,
 } from "../config-utils.mjs";
+import {
+  isMemorySkillReminderDue,
+  memorySkillReminderContext,
+  personalMemoryReminderContext,
+  resolveMemorySkillReminderIntervalTurns,
+} from "./memory-skill-reminder-policy.mjs";
 
-const DEFAULT_REMINDER_INTERVAL_TURNS = 5;
-const DEFAULT_MEMORY_SKILL_INVOCATION = "$memorax-code";
 export const PERSONAL_MEMORY_REMINDER_CONTEXT = personalMemoryReminderContext();
-
-export function personalMemoryReminderContext(memorySkillInvocation) {
-  const invocation = stringOption(memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
-  return [
-    `MemoraX Code personal-memory reminder: Use ${invocation} when the user states a durable current-repo identity or interaction preference, asks to list or recall stored personal memory, or explicitly asks to save, update, forget, or delete it.`,
-    "Route reusable action sequences and work rules to procedure memory; do not store repository facts, one-off task details, or secrets.",
-  ].join(" ");
-}
+export { personalMemoryReminderContext } from "./memory-skill-reminder-policy.mjs";
 
 export async function runMemorySkillReminderHook(options, hookInput) {
   try {
     const input = hookInput ?? await readStdinJson();
+    const result = await evaluateMemorySkillReminder(options, input);
+    if (!result) return;
+    process.stdout.write(`${JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: result.additionalContext,
+      },
+    })}\n`);
+    if (result.reminder) await notifyReminder(options, result.reminder);
+  } catch (error) {
+    debugError(options, error);
+  }
+}
+
+export async function evaluateMemorySkillReminder(options, input) {
+  try {
     const sessionId = stringOption(input.session_id) ?? stringOption(input.sessionId);
-    if (!sessionId) return;
+    if (!sessionId) return undefined;
     const transcriptPath = stringOption(input.transcript_path) ?? stringOption(input.transcriptPath);
-    if (options.requireTranscriptPath && !transcriptPath) return;
+    if (options.requireTranscriptPath && !transcriptPath) return undefined;
     const hookEventName = stringOption(input.hook_event_name) ?? stringOption(input.hookEventName) ?? "UserPromptSubmit";
+    if (hookEventName !== "UserPromptSubmit") return undefined;
 
-    const memoraxCodeHome = process.env.MEMORAX_CODE_HOME || defaultMemoraxCodeHome();
-    if (hookEventName !== "UserPromptSubmit") return;
-
+    const memoraxCodeHome = resolveMemoraxCodeHome(options);
     const statePath = join(memoraxCodeHome, "adapters", options.adapterDir, "memory-skill-reminders.json");
     const turnId = stringOption(input.turn_id)
       ?? stringOption(input.turnId)
@@ -48,7 +60,7 @@ export async function runMemorySkillReminderHook(options, hookInput) {
       );
       if (next.duplicate) return next;
       const sessionState = next.state.sessions[sessionId];
-      const memoryReminderDue = shouldRemind(
+      const memoryReminderDue = isMemorySkillReminderDue(
         sessionState?.turnCount,
         intervalTurns,
         options.remindOnFirstTurn !== false,
@@ -64,34 +76,30 @@ export async function runMemorySkillReminderHook(options, hookInput) {
         turnCount: sessionState?.turnCount,
       };
     });
-    if (update.duplicate) return;
+    if (update.duplicate) return undefined;
     const { memoryReminderDue, supplementalReminderDue } = update;
 
     const baseAdditionalContext = stringOption(options.baseAdditionalContext);
-    if (baseAdditionalContext || memoryReminderDue || supplementalReminderDue) {
-      const cadenceReminderContext = memoryReminderDue
-        ? await buildCadenceReminderContext(options, input)
-        : undefined;
-      const personalMemoryContext = supplementalReminderDue || (memoryReminderDue && update.turnCount === 1)
-        ? await buildPersonalMemoryContext(options, input)
-        : undefined;
-      const reminderContext = stringOption(combinedReminderContext(options, {
-        memoryReminderDue,
-        supplementalReminderDue,
-      }, cadenceReminderContext, personalMemoryContext));
-      const additionalContext = [baseAdditionalContext, reminderContext].filter(Boolean).join("\n\n");
-      const triggers = [
-        ...(memoryReminderDue ? ["cadence"] : []),
-        ...(supplementalReminderDue ? ["post_compaction"] : []),
-      ];
-      process.stdout.write(`${JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
-          additionalContext,
-        },
-      })}\n`);
-      if (reminderContext) {
-        await notifyReminder(options, {
+    if (!baseAdditionalContext && !memoryReminderDue && !supplementalReminderDue) return undefined;
+    const cadenceReminderContext = memoryReminderDue
+      ? await buildCadenceReminderContext(options, input)
+      : undefined;
+    const personalMemoryContext = supplementalReminderDue || (memoryReminderDue && update.turnCount === 1)
+      ? await buildPersonalMemoryContext(options, input)
+      : undefined;
+    const reminderContext = stringOption(combinedReminderContext(options, {
+      memoryReminderDue,
+      supplementalReminderDue,
+    }, cadenceReminderContext, personalMemoryContext));
+    const additionalContext = [baseAdditionalContext, reminderContext].filter(Boolean).join("\n\n");
+    const triggers = [
+      ...(memoryReminderDue ? ["cadence"] : []),
+      ...(supplementalReminderDue ? ["post_compaction"] : []),
+    ];
+    return {
+      additionalContext,
+      ...(reminderContext ? {
+        reminder: {
           sessionId,
           turnId,
           transcriptPath,
@@ -99,13 +107,12 @@ export async function runMemorySkillReminderHook(options, hookInput) {
           workspaceKind: stringOption(input.workspace_kind) ?? stringOption(input.workspaceKind),
           content: reminderContext,
           triggers,
-        });
-      }
-    }
+        },
+      } : {}),
+    };
   } catch (error) {
-    if (process.env[options.debugEnv] === "1") {
-      console.error(error instanceof Error ? error.message : String(error));
-    }
+    debugError(options, error);
+    return undefined;
   }
 }
 
@@ -125,21 +132,28 @@ export function markSupplementalReminderAfterCompact(options, input) {
     const hookEventName = stringOption(input.hook_event_name) ?? stringOption(input.hookEventName);
     if (hookEventName !== "SessionStart" || stringOption(input.source) !== "compact") return;
     const sessionId = stringOption(input.session_id) ?? stringOption(input.sessionId);
-    if (!sessionId) return;
-    const memoraxCodeHome = process.env.MEMORAX_CODE_HOME || defaultMemoraxCodeHome();
+    markSupplementalReminderForSession(options, sessionId);
+  } catch (error) {
+    debugError(options, error);
+  }
+}
+
+export function markSupplementalReminderForSession(options, sessionId) {
+  try {
+    const normalizedSessionId = stringOption(sessionId);
+    if (!normalizedSessionId) return;
+    const memoraxCodeHome = resolveMemoraxCodeHome(options);
     const statePath = join(memoraxCodeHome, "adapters", options.adapterDir, "memory-skill-reminders.json");
     withJsonFileLock(statePath, () => {
       const existing = readJsonFile(statePath);
       atomicWriteJson(statePath, markSupplementalReminderPending(
         existing?.unreadable ? undefined : existing?.value,
         options.runtime,
-        sessionId,
+        normalizedSessionId,
       ));
     });
   } catch (error) {
-    if (process.env[options.debugEnv] === "1") {
-      console.error(error instanceof Error ? error.message : String(error));
-    }
+    debugError(options, error);
   }
 }
 
@@ -169,7 +183,7 @@ async function buildPersonalMemoryContext(options, input) {
 
 function combinedReminderContext(options, due, cadenceReminderContext, personalMemoryContext) {
   const contexts = [];
-  if (due.memoryReminderDue) contexts.push(memoryReminderContext(options));
+  if (due.memoryReminderDue) contexts.push(memorySkillReminderContext(options.memorySkillInvocation));
   if (due.supplementalReminderDue || personalMemoryContext) {
     const additionalReminderContext = stringOption(options.additionalReminderContext);
     if (additionalReminderContext) contexts.push(additionalReminderContext);
@@ -180,15 +194,22 @@ function combinedReminderContext(options, due, cadenceReminderContext, personalM
   return contexts.join("\n\n");
 }
 
-function memoryReminderContext(options) {
-  const invocation = stringOption(options.memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
-  return `MemoraX Code reminder: proactively invoke ${invocation} whenever coding memory might help, even when uncertain; follow the skill's router to decide whether any memory operation is needed. Also use ${invocation} for repository-scoped personal memory, and classify the authority before reading or writing.`;
-}
-
 function defaultMemoraxCodeHome() {
   return process.env.HOME ? join(process.env.HOME, ".memorax-code") : ".memorax-code";
 }
 
+function resolveMemoraxCodeHome(options) {
+  return stringOption(options.memoraxCodeHome)
+    ?? process.env.MEMORAX_CODE_HOME
+    ?? defaultMemoraxCodeHome();
+}
+
+function debugError(options, error) {
+  if (process.env[options.debugEnv] === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+
 function nextReminderState(existing, runtime, sessionId, turnId) {
   const state = reminderState(existing, runtime);
   const current = state.sessions[sessionId] && typeof state.sessions[sessionId] === "object" && !Array.isArray(state.sessions[sessionId])
@@ -231,47 +252,17 @@ function reminderState(existing, runtime) {
   return state;
 }
 
-function shouldRemind(turnCount, intervalTurns, remindOnFirstTurn) {
-  if (!Number.isInteger(turnCount) || turnCount <= 0) return false;
-  if (remindOnFirstTurn) return (turnCount - 1) % intervalTurns === 0;
-  return turnCount > intervalTurns && (turnCount - 1) % intervalTurns === 0;
-}
-
 function reminderIntervalTurns(memoraxCodeHome) {
-  return positiveInteger(process.env.MEMORAX_CODE_MEMORY_SKILL_REMINDER_INTERVAL_TURNS)
-    ?? configReminderIntervalTurns(join(memoraxCodeHome, "config.toml"))
-    ?? DEFAULT_REMINDER_INTERVAL_TURNS;
+  return resolveMemorySkillReminderIntervalTurns({
+    environmentValue: process.env.MEMORAX_CODE_MEMORY_SKILL_REMINDER_INTERVAL_TURNS,
+    configText: configReminderText(join(memoraxCodeHome, "config.toml")),
+  });
 }
 
-function configReminderIntervalTurns(path) {
+function configReminderText(path) {
   try {
-    return parseReminderIntervalTurns(readFileSync(path, "utf8"));
+    return readFileSync(path, "utf8");
   } catch {
     return undefined;
   }
 }
-
-function parseReminderIntervalTurns(text) {
-  let section = "";
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.split("#", 1)[0].trim();
-    if (!line) continue;
-    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
-    if (sectionMatch) {
-      section = sectionMatch[1].trim();
-      continue;
-    }
-    if (section !== "memory.skill_reminder") continue;
-    const fieldMatch = line.match(/^interval_turns\s*=\s*(.+)$/);
-    if (fieldMatch) return positiveInteger(fieldMatch[1]);
-  }
-  return undefined;
-}
-
-function positiveInteger(value) {
-  if (typeof value !== "string") return undefined;
-  const normalized = value.trim().replaceAll("_", "");
-  if (!/^[1-9]\d*$/.test(normalized)) return undefined;
-  const parsed = Number(normalized);
-  return Number.isSafeInteger(parsed) ? parsed : undefined;
-}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/hooks/memory-skill-reminder-policy.mjs

@@ -0,0 +1,58 @@
+export const DEFAULT_MEMORY_SKILL_REMINDER_INTERVAL_TURNS = 5;
+const DEFAULT_MEMORY_SKILL_INVOCATION = "$memorax-code";
+
+export function memorySkillReminderContext(memorySkillInvocation) {
+  const invocation = nonEmptyString(memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
+  return `MemoraX Code reminder: proactively invoke ${invocation} whenever coding memory might help, even when uncertain; follow the skill's router to decide whether any memory operation is needed. Also use ${invocation} for repository-scoped personal memory, and classify the authority before reading or writing.`;
+}
+
+export function personalMemoryReminderContext(memorySkillInvocation) {
+  const invocation = nonEmptyString(memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
+  return [
+    `MemoraX Code personal-memory reminder: Use ${invocation} when the user states a durable current-repo identity or interaction preference, asks to list or recall stored personal memory, or explicitly asks to save, update, forget, or delete it.`,
+    "Route reusable action sequences and work rules to procedure memory; do not store repository facts, one-off task details, or secrets.",
+  ].join(" ");
+}
+
+export function resolveMemorySkillReminderIntervalTurns(input = {}) {
+  return positiveInteger(input.environmentValue)
+    ?? parseMemorySkillReminderIntervalTurns(input.configText)
+    ?? DEFAULT_MEMORY_SKILL_REMINDER_INTERVAL_TURNS;
+}
+
+export function isMemorySkillReminderDue(turnCount, intervalTurns, remindOnFirstTurn = true) {
+  if (!Number.isInteger(turnCount) || turnCount <= 0) return false;
+  if (!Number.isInteger(intervalTurns) || intervalTurns <= 0) return false;
+  if (remindOnFirstTurn) return (turnCount - 1) % intervalTurns === 0;
+  return turnCount > intervalTurns && (turnCount - 1) % intervalTurns === 0;
+}
+
+export function parseMemorySkillReminderIntervalTurns(text) {
+  if (typeof text !== "string") return undefined;
+  let section = "";
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.split("#", 1)[0].trim();
+    if (!line) continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim();
+      continue;
+    }
+    if (section !== "memory.skill_reminder") continue;
+    const fieldMatch = line.match(/^interval_turns\s*=\s*(.+)$/);
+    if (fieldMatch) return positiveInteger(fieldMatch[1]);
+  }
+  return undefined;
+}
+
+function positiveInteger(value) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().replaceAll("_", "");
+  if (!/^[1-9]\d*$/.test(normalized)) return undefined;
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+
+function nonEmptyString(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/repo-memory/repo-memory-auto-build.mjs

@@ -11,10 +11,10 @@ export function scheduleMissingRepoMemoryBuild(repo, options = {}) {
 
     const jobHookPath = join(pluginRoot, "hooks", "repo-memory-job.mjs");
     if (!existsSync(jobHookPath)) return false;
-    const child = spawn(process.execPath, [jobHookPath, "maintain", "--repo", repoPath], {
+    const child = spawn(options.nodePath ?? process.execPath, [jobHookPath, "maintain", "--repo", repoPath], {
       cwd: repoPath,
       detached: true,
-      env: process.env,
+      env: options.env ?? process.env,
       stdio: "ignore",
       windowsHide: true,
     });

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/repo-memory/repo-memory-job-supervisor.mjs

@@ -517,7 +517,7 @@ function buildPrompt(repo, snapshotHead, memorySkillInvocation) {
 }
 
 function updatePrompt(repo, snapshotHead, memorySkillInvocation) {
-  return `This invocation is the authorized background repo-memory worker. Complete the requested operation yourself; do not inspect, launch, or defer to another repo-memory job.\n\nUse ${memorySkillInvocation} and select the Repo Memory repo-update operation to incrementally update this repository's existing .repo_memory.\n\nRepository: ${repo}\nSnapshot HEAD: ${snapshotHead}\n\nDefault behavior:\n- Treat existing .repo_memory as the baseline.\n- Detect local commit delta from the stored baseline to the exact snapshot SHA above.\n- Also try GitHub/GitLab PR, MR, and issue evidence when provider CLIs and authentication are available.\n- If provider evidence is unavailable, continue with local git evidence and preserve existing provider resources.\n- Do not rebuild unless updater reports the baseline is unusable; if a full rebuild is required, stop and report that.\n- Keep file writes scoped to ${repo}/.repo_memory and necessary repo-memory ignore/config entries.\n- Do not modify source code, dependency files, global config, or files outside the target repo unless explicitly required by repo-memory tooling.\n- Ensure PROFILE.md local_head resolves to the snapshot SHA above.\n- Run the packaged repo-memory validator before finishing.\n- Write a concise final summary with changed files, provider evidence status, and any follow-up needed.\n`;
+  return `This invocation is the authorized background repo-memory worker. Complete the requested operation yourself; do not inspect, launch, or defer to another repo-memory job.\n\nUse ${memorySkillInvocation} and select the Repo Memory repo-update operation to incrementally update this repository's existing .repo_memory.\n\nRepository: ${repo}\nSnapshot HEAD: ${snapshotHead}\n\nDefault behavior:\n- Treat existing .repo_memory as the baseline.\n- Run and follow the packaged repo-update detector's effective history policy.\n- Do not re-enable commit or provider evidence channels disabled by repoHistory.mode.\n- If provider evidence is unavailable when provider history is enabled, preserve existing provider resources.\n- Do not rebuild unless updater reports the baseline is unusable; if a full rebuild is required, stop and report that.\n- Keep file writes scoped to ${repo}/.repo_memory and necessary repo-memory ignore/config entries.\n- Do not modify source code, dependency files, global config, or files outside the target repo unless explicitly required by repo-memory tooling.\n- Ensure PROFILE.md local_head resolves to the snapshot SHA above.\n- Run the packaged repo-memory validator before finishing.\n- Write a concise final summary with changed files, provider evidence status, and any follow-up needed.\n`;
 }
 
 function gitSnapshot(repo) {

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/windows-cli-invocation.mjs

@@ -37,7 +37,11 @@ export function resolveWindowsCliInvocation(command, args, options = {}) {
     .filter(isNodeEntrypoint)
     .find((candidate) => fileExists(candidate));
   if (!cli) {
-    const override = name === "claude" ? "MEMORAX_CODE_CLAUDE_CLI_JS" : "MEMORAX_CODE_CODEX_CLI_JS";
+    const override = name === "claude"
+      ? "MEMORAX_CODE_CLAUDE_CLI_JS"
+      : name === "dsh"
+        ? "MEMORAX_CODE_DSH_CLI_JS"
+        : "MEMORAX_CODE_CODEX_CLI_JS";
     throw new Error(
       `refusing to execute ${pathApi.basename(resolvedCommand)} through a command shell; `
       + `set ${override} to its Node entrypoint`,
@@ -75,6 +79,14 @@ function cliEntrypointCandidates(name, command, env, pathApi) {
       pathApi.join(root, "..", "@anthropic-ai", "claude-code", "cli.js"),
     ];
   }
+  if (name === "dsh") {
+    return [
+      env.MEMORAX_CODE_DSH_CLI_JS,
+      env.DSH_CLI_JS,
+      pathApi.join(root, "node_modules", "@deepseek-ai", "dsh", "lib", "bin.js"),
+      pathApi.join(root, "..", "@deepseek-ai", "dsh", "lib", "bin.js"),
+    ];
+  }
   return [];
 }
 

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

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

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/skills/memorax-code/SKILL.md

@@ -21,6 +21,11 @@ description: >-
 
 Classify the requested memory authority first, then its operation. Load only the matching reference unless the request genuinely spans authorities or operations.
 
+After selecting an operation reference, read it completely in a standalone
+tool call and wait for the full result before constructing or executing that
+operation. Never combine reading a required reference with the command or
+action it governs in the same shell command or tool call.
+
 ## Authority Router
 
 ### MemoraX Code Coding Memory
@@ -51,8 +56,11 @@ Use personal memory for user-owned repository procedures and durable profile or
 - Route ordered actions, checklists, prerequisites, gates, exceptions, and validation rules to personal procedure memory, even when phrased as "I prefer", "I like", "我的习惯", or "我喜欢".
 - Route preferred name, answer language, tone, verbosity, explanation style, and result presentation to personal profile memory.
 - Route task-learned repairs, coding pitfalls, project engineering conventions, and reusable design lessons to MemoraX Code coding memory.
+- Route prior project discussions, experiment conclusions, saved engineering findings, earlier fixes, and reusable project lessons to MemoraX Code coding memory. Do not route them to repo memory merely because they concern a project. Use repo memory for repository identity, architecture, module maps, commits, PRs, MRs, and issues.
 - Route repository architecture, module maps, commit history, PRs, MRs, and issues to repo memory. Verify claims about current behavior against live code.
+- Use both repo memory and MemoraX Code coding memory only when a request genuinely needs distinct repository evidence and reusable engineering lessons. This can apply to implementation, debugging, refactoring, migration planning, or validation when the answer may depend on repository module maps, commit/PR/issue evidence, and prior fixes, pitfalls, conventions, validation patterns, or design rationale. Do not use both authorities just because a request mentions a repository, file, module, or "previous".
 - Route current-task instructions and temporary plans to the current task only; do not persist them.
+- Current-task-only applies only when completing the request does not depend on prior project state. Do not select it merely because the requested action happens in the current turn. When implementation, debugging, review, experiment continuation, or validation depends on earlier project decisions, results, fixes, constraints, or plans that the user has not explicitly and completely supplied, route to MemoraX Code coding memory.
 - Do not infer an authority from verbs such as "remember", "recall", "refresh", or "update" alone. Ask one focused question when the target remains ambiguous.
 
 Examples:
@@ -72,11 +80,12 @@ Repo memory and personal memory remain local `.repo_memory` authorities. Resolve
 
 Apply instructions in this order: system and developer instructions, `AGENTS.md`, the current user request, then stored memory. Memory is guidance or historical context, not proof of current repository behavior.
 
-For MemoraX Code coding memory, use `memorax-cli` exactly as described by the selected reference. Invoke this skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code; neither invocation is a shell command. `memorax-code` is the lifecycle CLI and must not be used for memory search or add. Do not call MemoraX HTTP endpoints directly.
+For MemoraX Code coding memory, use `memorax-cli` exactly as described by the selected reference. Invoke this skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code. In OpenCode, ask the agent to use the `memorax-code` skill by name. These invocation forms are not shell commands. `memorax-code` is the lifecycle CLI and must not be used for memory search or add. Do not call MemoraX HTTP endpoints directly.
 
 When explaining Memory Viewer, describe only `/memory-viewer`. It is a
 content-free local summary and must not expose conversation or memory text,
 session or turn identifiers, paths, or trace details. The page never queries
-MemoraX directly; client Hooks are the trace ingress authority.
+MemoraX directly; it projects client-qualified local activity and keeps each
+supported harness isolated.
 
 Never store secrets, credentials, `.env` content, sensitive personal data, raw transcripts, hidden tests, exact patches, temporary target commits, or unsafe destructive commands. Do not announce internal routing or reference loading.

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

@@ -1,9 +1,12 @@
 {
-  "schema": "repo_memory_builder_defaults.v1",
-  "limits": {
-    "commits": 30,
-    "prs": 30,
-    "issues": 30
+  "schema": "repo_memory_builder_defaults.v2",
+  "repoHistory": {
+    "mode": "provider",
+    "limits": {
+      "commits": 30,
+      "prs": 30,
+      "issues": 30
+    }
   },
   "summaryChars": 4000
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/skills/memorax-code/references/memorax-add.md

@@ -1,6 +1,6 @@
 # MemoraX Code Coding Memory Add
 
-Use these instructions only to add reusable coding knowledge through `memorax-cli`. Invoke the skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code; do not route memory operations through the lifecycle-only `memorax-code` CLI. Do not use this authority for personal procedures, interaction preferences, generated repository facts, or one-off task details.
+Use these instructions only to add reusable coding knowledge through `memorax-cli`. Invoke the skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code. In OpenCode, ask the agent to use the `memorax-code` skill by name. Do not route memory operations through the lifecycle-only `memorax-code` CLI. Do not use this authority for personal procedures, interaction preferences, generated repository facts, or one-off task details.
 
 ## Eligible Knowledge
 

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/skills/memorax-code/references/memorax-search.md

@@ -1,6 +1,6 @@
 # MemoraX Code Coding Memory Search
 
-Use these instructions only to search reusable coding memory through `memorax-cli`. Invoke the skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code; do not route memory operations through the lifecycle-only `memorax-code` CLI. Do not call MemoraX HTTP endpoints directly, print credentials, or edit memory storage by hand.
+Use these instructions only to search reusable coding memory through `memorax-cli`. Invoke the skill as `$memorax-code` in Codex or `/memorax-code` in Claude Code. In OpenCode, ask the agent to use the `memorax-code` skill by name. Do not route memory operations through the lifecycle-only `memorax-code` CLI. Do not call MemoraX HTTP endpoints directly, print credentials, or edit memory storage by hand.
 
 ## Scope
 
@@ -21,8 +21,12 @@ Search when prior coding memory may change localization, implementation, review,
 - a request for a previous fix, failed approach, coding convention, design decision, or reusable lesson;
 - implementation, review, planning, API, schema, parser, workflow-contract, or migration work where prior project guidance may matter;
 - explicit instructions to follow previous agreements or remembered engineering conventions.
+- a request to recover, verify, or apply prior project discussions, experiment results, saved memory, earlier decisions, previous changes, or historical constraints, unless the needed facts are fully present in the current visible context.
+- a requested action that depends on prior project state, results, fixes, constraints, or plans when the exact evidence needed is not explicitly present in the current user-provided material.
 
-Skip search for simple current-code facts, tiny edits, typo fixes, one-shot commands, or behavior directly established by a clear live source.
+Skip search for simple current-code facts, tiny edits, typo fixes, one-shot commands, or behavior directly established by a clear live source. Do not skip merely by saying the current conversation is sufficient or a relevant result was already retrieved; skip only when the current user message, selected text, or nearby visible context fully contains the facts needed for the answer. A nearby summary is sufficient for explaining that summary, but not automatically sufficient for diagnosing a regression, continuing an experiment, reviewing consistency with prior behavior, or claiming a complete historical account. A word such as "previous", "earlier", "remember", or "history" is not enough by itself to search when the visible context already contains the requested prior facts.
+
+Do not search merely because a prior result or fix might exist. For an exact calculation from currently available data, or a current screenshot or reproducible symptom with sufficient live evidence, use the current evidence first. Search only when the user request or visible context establishes a concrete historical dependency.
 
 Choose the closest coding scene to shape the query:
 
@@ -34,23 +38,47 @@ If the user asks for commit, PR, MR, issue, or repository architecture evidence,
 
 ## Query Workflow
 
-Run at most one focused search before answering or editing. A development task may run one additional materially different search only after a failed test or dead-end investigation.
+Before searching, identify the user's current action, target, concrete behavior or symptom, and the historical knowledge that could change the next action. When the request is fragmented, derive one narrow working intent from only its explicit target, condition, and requested or implied outcome. Do not add generic security, authorization, concurrency, auditing, reliability, or best-practice concerns unless the request names that boundary or it is necessary to resolve the working intent. Ask one focused question when no actionable intent can be named.
+
+Run up to two focused first-round searches before answering or editing: a primary query for the smallest user-facing decision, and a materially different complementary query only when a second independent fact can change the action. Keep one query when the request describes one strongly coupled calculation, diagnosis, ownership question, or lifecycle decision; do not split it merely to create coverage. Run independent first-round searches in parallel by default. If parallel execution encounters a transport, rate-limit, or caller-environment failure, run any remaining searches serially; do not switch solely because a successful search returns an unexpected number of items. After merging the first-round results, run at most one follow-up query only when one named residual gap can change implementation, localization, risk, or validation. Do not use the follow-up merely because results are few, generic, or incomplete.
+
+Write each query as one short natural-language question or intent statement, not a keyword list. Derive it from the user's retrieval goal instead of copying or concatenating nouns from the prompt. Follow the user's language for the prose while preserving exact code, API, path, workflow, and project identifiers. Retain at least one distinctive noun phrase from the user's wording as an anchor, together with any explicit negation, time/order, quantity, or scope qualifier. Also retain one stable task entity explicitly established by the current conversation or live code/documentation when it is needed to resolve that anchor or make the target decidable; do not drop it merely because it is absent from the newest fragmented user message. Do not replace an anchor or stable entity with a more abstract mechanism, a more specific implementation guess, or an unverified term. Preserve whether a retained detail is an observed symptom, desired outcome, disputed field or hypothesis, or explicit exclusion; do not turn an observation into a required invariant or replace a named disputed field with a generic reference.
 
-Write each query as one short natural-language question or intent statement, not a keyword list. Derive it from the user's retrieval goal instead of copying or concatenating nouns from the prompt. Follow the user's language for the prose while preserving exact code, API, path, workflow, and project identifiers. State what prior knowledge is needed and the relationship, decision, constraint, behavior, or risk being investigated. Include 2-5 stable exact identifiers when they are relevant and known, but integrate them grammatically instead of appending search tags or filler.
+Preserve the user's requested answer shape as well as the target: for example, whether a value was introduced by a prior code change, which failed experiments require rerun, how a negative case differs, what source boundary applies, or which existing plan remains current. Encode an explicit exclusion, source boundary, or qualifier such as only, previous, failed, negative, not, latest, or before/after when it changes the answer. Do not turn an imperative, URL, copied log, or full task request into the query verbatim; extract the smallest reusable historical fact that could change the next action. When the user explicitly names several independent deliverables and their respective historical facts could change different next actions, use the existing two-query allowance for complementary coverage: let the primary query cover the central implementation or decision, and let the complementary query cover the separate validation, artifact, reporting, or boundary question. Do not split one tightly coupled task or create a second query merely to enumerate every noun.
+
+State a fact-sized relationship that can change the next action: a target under a condition, and the decision, invariant, consequence, root cause, ownership, compatibility, validation question, or requested answer at issue. For behavior, data, and lifecycle work, every query must use this visible shape: `<target>: <condition>，<decision / invariant / consequence / validation question>?`. Keep the colon in both Chinese and English so the target, condition, and decision boundary remain explicit. Do not emit a generic topic, a keyword list, a label such as `primary query`, or an explanation around the query.
+
+For a complementary first-round pair, each query must stand alone and cover a different decision boundary. Use a complementary pair only when the provided context gives each decision boundary a distinct exact code, API, path, workflow, or project identifier; otherwise keep one focused combined query that preserves both user-stated facts. Do not merely restate the same question with synonyms. If the user describes only one tightly coupled decision, emit exactly one query. Use one or two stable exact identifiers when they sharpen the query, and integrate them grammatically instead of appending search tags or filler. Use only user-provided anchors and stable terms from live code or documentation; do not reconstruct unseen fact wording from recalled memory.
 
 Pass the query directly with `--query`. Put every dynamically generated query in single quotes, never double quotes. Treat `$HOME`, backticks, and `$(command)` as literal text inside those quotes. Replace each literal single quote in the value with the exact POSIX sequence `'\''`.
 
-For example:
+Use these actual output shapes as examples. They are queries themselves, not full user prompts or instructions for the user. Each Chinese/English pair is a language variant: choose the one matching the user, never run both merely because both are shown. The comments explain the example only and are not part of emitted query text.
 
 ```bash
-memorax-cli search --query 'What prior decisions define the memorax-code parser API failure boundary for malformed input?'
-memorax-cli search --query 'What prior review policies and regression risks apply to the memorax-code parser API cleanup boundary?'
-memorax-cli search --query 'memorax-code 中 Backend、Codex adapter 与 memory 层的职责如何衔接，之前为什么这样划分？'
+# One tightly coupled decision: emit one query.
+memorax-cli search --query 'Trace 生产版本：升级后到达的记录中，应以哪个客户端版本字段判断由旧插件产生，而非新版本上传进程？'
+memorax-cli search --query 'Trace producer version: after an upgrade, which client-version field shows that an event came from the old plugin rather than the new uploader?'
+
+# Two independent boundaries: emit a complementary pair.
+memorax-cli search --query '任务上下文：升级新包后已打开任务仍按旧提示，是否绑定旧版本且必须新开对话？'
+memorax-cli search --query '包缓存版本冲突：本地新包与缓存冲突时，已打开任务为何仍使用旧提示，如何确认实际加载版本？'
+memorax-cli search --query 'Task context after upgrade: can an already-open task keep old injected context, and must validation use a fresh task?'
+memorax-cli search --query 'Package-cache version collision: how do we confirm which version the active task actually loaded?'
+
+# Preserve an explicit lifecycle condition and the required invariant.
+memorax-cli search --query '自动写回：事件回调不等待 Promise 时，如何在消息终态后执行并防止重复？'
+memorax-cli search --query 'Automatic writeback: when an event callback does not await a Promise, how should it run after message terminal state without duplicates?'
+
+# Preserve a source boundary rather than turning it into a generic SDK question.
+memorax-cli search --query '桌面 SDK 数据权威：无原生命令行时，应从哪些规范化消息和会话生命周期事件获取数据？'
+memorax-cli search --query 'Desktop SDK authority: without a native CLI, which normalized messages and session lifecycle events are authoritative?'
 ```
 
 Keep queries under 25 words when practical for the language, but do not shorten them into ungrammatical fragments. Exclude secrets, private URLs, full prompts, raw transcripts, copied files, long logs, stack traces, and one-off task details.
 
-Read or summarize at most two relevant items. Prefer memories matching the current repository, module, API, lifecycle surface, ownership boundary, behavior, and failure mode. Treat verified memories as routing and validation hints, not patch recipes. Treat failed-attempt memories as negative evidence. Ignore stale or unrelated items and anything conflicting with current source, tests, or durable documentation.
+Do not use abstract query facets such as "state", "fix", "safety", or "best practice" unless they are the concrete target. Do not use generic security or safety queries as complementary queries; bind every query to an exact target, condition, and behavior boundary.
+
+Merge and deduplicate first-round results by item identity when available, otherwise by matching scope, condition, claim, and consequence. Accept a memory only when all three checks pass: it has the same component, API, workflow, or ownership boundary; it has the same behavior, symptom, condition, or change; and it supplies a condition, conclusion, consequence, fix, or validation idea that can change the current action. Read or summarize at most two accepted direct hits. Prefer memories matching the current repository, module, API, lifecycle surface, ownership boundary, behavior, and failure mode. Treat verified memories as routing and validation hints, not patch recipes. Treat failed-attempt memories as negative evidence. Ignore stale or unrelated items and anything conflicting with current source, tests, or durable documentation. For application questions, reject retrieval-strategy, evaluation, prompting, or workflow-process memories as domain evidence even if they repeat application terms. If no memory passes all three checks, say that memory is insufficient for the requested decision rather than filling the gap with a generic principle.
 
 ## Transport Failures