@memorax/memorax-code 0.1.1 → 0.1.3

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; when in doubt, run one focused coding-memory search for relevant prior knowledge. 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

@@ -0,0 +1,38 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export function scheduleMissingRepoMemoryBuild(repo, options = {}) {
+  try {
+    const repoPath = nonEmptyString(repo);
+    const pluginRoot = nonEmptyString(options.pluginRoot);
+    if (!repoPath || !pluginRoot) return false;
+    if (existsSync(join(repoPath, ".repo_memory", "PROFILE.md"))) return false;
+
+    const jobHookPath = join(pluginRoot, "hooks", "repo-memory-job.mjs");
+    if (!existsSync(jobHookPath)) return false;
+    const child = spawn(options.nodePath ?? process.execPath, [jobHookPath, "maintain", "--repo", repoPath], {
+      cwd: repoPath,
+      detached: true,
+      env: options.env ?? process.env,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.once("error", (error) => debug(options, error));
+    child.unref();
+    return true;
+  } catch (error) {
+    debug(options, error);
+    return false;
+  }
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function debug(options, error) {
+  if (process.env[options.debugEnv] === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}

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.1",
+  "version": "0.1.3",
   "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/runtime-hooks/memory-turn.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { resolveBackendConnection } from "../memorax-code-adapter-common/src/backend-connection.mjs";
 import { readStdinJson } from "../memorax-code-adapter-common/src/config-utils.mjs";
+import { scheduleMissingRepoMemoryBuild } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-auto-build.mjs";
 import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
 
 const RETRIEVAL_BACKEND_TIMEOUT_MS = 12_000;
@@ -29,6 +30,10 @@ try {
       cwd: stringValue(input.cwd),
       workspaceKind: stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind),
     });
+    scheduleMissingRepoMemoryBuild(stringValue(response?.repoMemoryWorktree), {
+      debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+      pluginRoot: process.env.CLAUDE_PLUGIN_ROOT,
+    });
     const additionalContext = stringValue(response?.additionalContext);
     if (additionalContext) {
       process.stdout.write(`${JSON.stringify({

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

@@ -1,27 +1,31 @@
 ---
 name: memorax-code
 description: >-
-  Use this skill as the single entry point for persistent coding and
-  repository-local memory work, regardless of type, wording, or operation. Use
-  it whenever a request may involve information that should persist beyond the
-  current task,
-  knowledge remembered from prior work, repository memory,
-  reusable procedures or working rules, or durable user profile and interaction
-  preferences. This applies even when the user does not call it memory,
-  including naturally stated habits, preferences,
+  Use this skill as the single router for persistent coding and repository-local
+  memory. Invoke it whenever a request may involve prior-work knowledge,
+  repository memory, reusable procedures or rules, durable profile or
+  interaction preferences, or information worth retaining beyond the current
+  task. This applies without memory wording, including habits, preferences,
   checklists, action sequences, prerequisites, gates, exceptions, validation
   rules, communication style, preferred language, or result presentation.
-  Determine whether the request belongs to MemoraX Code coding memory,
-  repository memory, personal procedure memory, personal profile
-  memory, or no persistent memory, then route it to the appropriate operation.
-  Prefer this router over any underlying memory workflow. Ask one focused
-  question only when the memory authority remains ambiguous after routing.
+  Classify the request as coding memory, repository memory, personal procedure
+  memory, personal profile memory, or no persistent memory, then route it to the
+  matching operation. Invoking this router does not require coding-memory
+  search. Reuse a relevant coding-memory result already retrieved in this
+  conversation; otherwise let the matching operation decide on search. Prefer
+  this router over underlying memory workflows. Ask one focused question only when
+  memory authority remains ambiguous.
 ---
 
 # MemoraX Code
 
 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
@@ -52,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:
@@ -73,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
 
@@ -71,6 +71,10 @@ anchors: stable/source/path' \
 
 If add fails, report the exact failure and do not retry automatically, bypass the CLI, or call MemoraX directly.
 
+If a successful Add result reports `workspaceScopeFallbackReason: git_metadata_invalid`, malformed or incomplete metadata inside a direct `.git` directory was downgraded to the normalized local folder scope. Add has already been submitted with the reported `effectiveUserId`. Present its `userNotice` once without pausing the current task or asking the user to repair Git first, then continue the current task. After the repository or `.git` metadata is repaired, later Search, Add, and automatic writeback in the same client session automatically use the restored Git repository scope.
+
+If `memorax-cli add` reports `workspace_scope_mismatch` or `workspace_scope_unavailable`, do not bypass the scope. Do not change the CLI working directory and retry. Tell the user that the memory was not submitted and no request was sent to MemoraX, then present the CLI's `userAction` in natural language. Continue the current task using only live code and documentation.
+
 ## Exclusions
 
 Do not add secrets, credentials, private URLs, raw authorization headers, exact patches, target commits, hidden tests, target diffs, vulnerability details, exploit steps, copied source, long logs, stack traces, raw transcripts, temporary errors, or facts directly recoverable from current files and git history.