@memorax/memorax-code 0.1.1 → 0.1.2

package/lib/memorax-code-backend/dist/repository-memory-context.js

@@ -1,12 +1,23 @@
 import { memoraxConfigFromEnv, } from "./memorax-config.js";
-import { repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, resolveRepositoryMemoryScope, } from "./repository-memory-scope.js";
+import { repositoryMemoryScopeCanUpgradeFromDegradedGit, repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, resolveRepositoryMemoryScope, } from "./repository-memory-scope.js";
+export function resolvedRepoMemoryWorktree(result) {
+    if (!result.ok || !result.memory.scope)
+        return undefined;
+    return repositoryMemoryScopeKind(result.memory.scope) === "git-repository"
+        ? result.memory.scope.boundWorkspaceRoot
+        : undefined;
+}
 const sessionScopes = new WeakMap();
 const scopeResolutionQueues = new WeakMap();
-export function createRepositoryMemorySessionRuntime() {
+export function createRepositoryMemorySessionRuntime(options = {}) {
     const owner = {};
     return {
         async resolve(input) {
-            return await resolveConfiguredRepositoryMemoryForSession({ owner, ...input });
+            return await resolveConfiguredRepositoryMemoryForSession({
+                owner,
+                onScopeUpgrade: options.onScopeUpgrade,
+                ...input,
+            });
         },
         close() {
             sessionScopes.delete(owner);
@@ -93,6 +104,16 @@ export async function resolveConfiguredRepositoryMemoryForSession(input) {
             return scopeResult;
         if (cached?.scope.baseUserId === configResult.config.userId) {
             if (!repositoryMemoryScopesMatch(cached.scope, scopeResult.scope)) {
+                if (repositoryMemoryScopeCanUpgradeFromDegradedGit(cached.scope, scopeResult.scope)) {
+                    input.onScopeUpgrade?.({
+                        client: input.client,
+                        sessionId,
+                        previousScope: cached.scope,
+                        currentScope: scopeResult.scope,
+                    });
+                    cached.scope = scopeResult.scope;
+                    return { ok: true, memory: { config: configResult.config, scope: scopeResult.scope } };
+                }
                 cached.mismatch = true;
                 return repositoryScopeMismatch();
             }

package/lib/memorax-code-backend/dist/repository-memory-scope.js

@@ -57,7 +57,10 @@ export async function resolveRepositoryMemoryScope(input) {
             }),
         };
     }
-    const workspaceName = sanitizeWorkspaceName(basename(workspace));
+    const localWorkspace = gitRepository.kind === "degraded"
+        ? gitRepository.workspaceRoot
+        : workspace;
+    const workspaceName = sanitizeWorkspaceName(basename(localWorkspace));
     if (!workspaceName) {
         return {
             ok: false,
@@ -69,18 +72,30 @@ export async function resolveRepositoryMemoryScope(input) {
         ok: true,
         scope: memoryScope({
             baseUserId,
-            repositoryKey: identityKey("workspace-directory", workspace),
+            repositoryKey: identityKey("workspace-directory", localWorkspace),
             repositorySlug: workspaceName,
             identitySource: "workspace-directory",
             scopeKind: "local-directory",
-            boundWorkspaceRoot: workspace,
+            fallbackReason: gitRepository.kind === "degraded" ? gitRepository.reason : undefined,
+            boundWorkspaceRoot: localWorkspace,
         }),
     };
 }
 export function repositoryMemoryScopesMatch(left, right) {
     return left.repositoryKey === right.repositoryKey
         && left.baseUserId === right.baseUserId
-        && left.effectiveUserId === right.effectiveUserId;
+        && left.effectiveUserId === right.effectiveUserId
+        && left.fallbackReason === right.fallbackReason;
+}
+export function repositoryMemoryScopeCanUpgradeFromDegradedGit(previous, current) {
+    return previous.scopeKind === "local-directory"
+        && previous.identitySource === "workspace-directory"
+        && previous.fallbackReason === "git_metadata_invalid"
+        && current.scopeKind === "git-repository"
+        && current.fallbackReason === undefined
+        && previous.baseUserId === current.baseUserId
+        && previous.boundWorkspaceRoot !== undefined
+        && previous.boundWorkspaceRoot === current.boundWorkspaceRoot;
 }
 export async function repositoryMemoryScopeContainsWorkspace(scope, workspaceRoot) {
     if (!scope.boundWorkspaceRoot || !workspaceRoot?.trim())
@@ -96,6 +111,11 @@ export async function repositoryMemoryScopeContainsWorkspace(scope, workspaceRoo
     }
     if (!pathContains(scope.boundWorkspaceRoot, workspace))
         return false;
+    if (scope.scopeKind === "local-directory" && scope.fallbackReason === "git_metadata_invalid") {
+        const gitRepository = await resolveGitRepository(workspace);
+        return gitRepository.kind === "degraded"
+            && identityKey("workspace-directory", gitRepository.workspaceRoot) === scope.repositoryKey;
+    }
     return scope.scopeKind !== "local-directory"
         || !await hasGitMarkerBetween(workspace, scope.boundWorkspaceRoot);
 }
@@ -112,6 +132,7 @@ function memoryScope(input) {
         repositoryName: input.repositorySlug,
         identitySource: input.identitySource,
         scopeKind: input.scopeKind,
+        ...(input.fallbackReason ? { fallbackReason: input.fallbackReason } : {}),
         ...(input.boundWorkspaceRoot ? { boundWorkspaceRoot: input.boundWorkspaceRoot } : {}),
     };
 }
@@ -134,8 +155,11 @@ async function resolveGitRepository(workspace) {
     }
     if (!marker)
         return { kind: "none" };
+    let directDirectoryMarker = false;
     try {
-        const gitDir = await resolveGitDir(marker.path);
+        const resolvedGitDir = await resolveGitDir(marker.path);
+        directDirectoryMarker = resolvedGitDir.directDirectoryMarker;
+        const gitDir = resolvedGitDir.path;
         await validateGitHead(gitDir);
         const commonDir = await resolveGitCommonDir(gitDir);
         await validateGitCommonDir(commonDir);
@@ -149,7 +173,14 @@ async function resolveGitRepository(workspace) {
             workspaceRoot: marker.workspaceRoot,
         };
     }
-    catch {
+    catch (error) {
+        if (directDirectoryMarker && canFallbackFromDirectGitDirectory(error)) {
+            return {
+                kind: "degraded",
+                reason: "git_metadata_invalid",
+                workspaceRoot: marker.workspaceRoot,
+            };
+        }
         return { kind: "invalid" };
     }
 }
@@ -191,19 +222,27 @@ async function hasGitMarkerBetween(workspace, boundary) {
     }
 }
 async function resolveGitDir(marker) {
-    if ((await fs.lstat(marker)).isSymbolicLink())
-        throw new Error("symbolic Git metadata marker is not allowed");
-    const markerStat = await fs.stat(marker);
-    if (markerStat.isDirectory())
-        return await canonicalDirectory(marker);
+    const markerStat = await fs.lstat(marker);
+    if (markerStat.isSymbolicLink()) {
+        throw new GitMetadataValidationError("symbolic Git metadata marker is not allowed");
+    }
+    if (markerStat.isDirectory()) {
+        return {
+            path: await canonicalDirectory(marker),
+            directDirectoryMarker: true,
+        };
+    }
     if (!markerStat.isFile())
-        throw new Error("invalid Git metadata marker");
+        throw new GitMetadataValidationError("invalid Git metadata marker");
     const line = await readSingleLine(marker, MAX_GIT_POINTER_BYTES);
     const match = /^gitdir:[ \t]*(.+)$/i.exec(line);
     const gitDir = match?.[1]?.trim();
     if (!gitDir)
-        throw new Error("invalid Git metadata pointer");
-    return await canonicalDirectory(resolveMetadataPath(dirname(marker), gitDir));
+        throw new GitMetadataValidationError("invalid Git metadata pointer");
+    return {
+        path: await canonicalDirectory(resolveMetadataPath(dirname(marker), gitDir)),
+        directDirectoryMarker: false,
+    };
 }
 async function resolveGitCommonDir(gitDir) {
     const path = join(gitDir, "commondir");
@@ -217,34 +256,35 @@ async function resolveGitCommonDir(gitDir) {
     }
     const commonDir = (await readSingleLine(path, MAX_GIT_POINTER_BYTES)).trim();
     if (!commonDir)
-        throw new Error("invalid Git common directory pointer");
+        throw new GitMetadataValidationError("invalid Git common directory pointer");
     return await canonicalDirectory(resolveMetadataPath(gitDir, commonDir));
 }
 function resolveMetadataPath(base, value) {
     if (value.includes("\0"))
-        throw new Error("invalid Git metadata path");
+        throw new GitMetadataValidationError("invalid Git metadata path");
     return isAbsolute(value) ? value : resolve(base, value);
 }
 async function canonicalDirectory(path) {
     const canonical = await fs.realpath(path);
-    if (!(await fs.stat(canonical)).isDirectory())
-        throw new Error("Git metadata path is not a directory");
+    if (!(await fs.stat(canonical)).isDirectory()) {
+        throw new GitMetadataValidationError("Git metadata path is not a directory");
+    }
     return canonical;
 }
 async function validateGitHead(gitDir) {
     const head = (await readSingleLine(join(gitDir, "HEAD"), MAX_GIT_POINTER_BYTES)).trim();
     if (!/^ref: refs\/[^\0\r\n]+$/.test(head) && !/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(head)) {
-        throw new Error("invalid Git HEAD");
+        throw new GitMetadataValidationError("invalid Git HEAD");
     }
 }
 async function validateGitCommonDir(commonDir) {
     if (!(await fs.stat(join(commonDir, "objects"))).isDirectory()) {
-        throw new Error("invalid Git objects directory");
+        throw new GitMetadataValidationError("invalid Git objects directory");
     }
     const hasRefs = await isDirectory(join(commonDir, "refs"));
     const hasReftable = await isDirectory(join(commonDir, "reftable"));
     if (!hasRefs && !hasReftable)
-        throw new Error("invalid Git references directory");
+        throw new GitMetadataValidationError("invalid Git references directory");
 }
 async function isDirectory(path) {
     try {
@@ -263,17 +303,18 @@ async function readSingleLine(path, maxBytes) {
     else if (value.endsWith("\n"))
         value = value.slice(0, -1);
     if (!value || value.includes("\0") || value.includes("\r") || value.includes("\n")) {
-        throw new Error("invalid single-line Git metadata");
+        throw new GitMetadataValidationError("invalid single-line Git metadata");
     }
     return value;
 }
 async function readBoundedTextFile(path, maxBytes) {
     const file = await fs.stat(path);
-    if (!file.isFile() || file.size > maxBytes)
-        throw new Error("invalid Git metadata file");
+    if (!file.isFile() || file.size > maxBytes) {
+        throw new GitMetadataValidationError("invalid Git metadata file");
+    }
     const value = await fs.readFile(path, "utf8");
     if (Buffer.byteLength(value, "utf8") > maxBytes || value.includes("\0")) {
-        throw new Error("invalid Git metadata file");
+        throw new GitMetadataValidationError("invalid Git metadata file");
     }
     return value;
 }
@@ -306,7 +347,7 @@ function parseDirectRemoteUrls(source) {
             continue;
         const assignment = /^[ \t]*([A-Za-z][A-Za-z0-9-]*)[ \t]*(?:=[ \t]*)?(.*)$/.exec(line);
         if (!assignment)
-            throw new Error("invalid Git config assignment");
+            throw new GitMetadataValidationError("invalid Git config assignment");
         if (assignment[1]?.toLowerCase() !== "url")
             continue;
         remotes.set(remote, parseGitConfigValue(assignment[2] ?? ""));
@@ -328,7 +369,7 @@ function logicalGitConfigLines(source) {
         }
     }
     if (pending)
-        throw new Error("unterminated Git config continuation");
+        throw new GitMetadataValidationError("unterminated Git config continuation");
     return lines;
 }
 function hasUnescapedTrailingBackslash(value) {
@@ -340,7 +381,7 @@ function hasUnescapedTrailingBackslash(value) {
 function parseGitConfigSection(line) {
     const match = /^\[[ \t]*([A-Za-z0-9][A-Za-z0-9.-]*)[ \t]*(?:"((?:[^"\\]|\\.)*)")?[ \t]*\](?:[ \t]*[#;].*)?$/.exec(line);
     if (!match?.[1])
-        throw new Error("invalid Git config section");
+        throw new GitMetadataValidationError("invalid Git config section");
     if (!match[2] && match[1].includes(".")) {
         const separator = match[1].indexOf(".");
         return {
@@ -378,11 +419,11 @@ function parseGitConfigValue(value) {
         }
         const trailing = input.slice(index + 1).trim();
         if (trailing && !trailing.startsWith("#") && !trailing.startsWith(";")) {
-            throw new Error("invalid Git config value");
+            throw new GitMetadataValidationError("invalid Git config value");
         }
         return result;
     }
-    throw new Error("unterminated Git config value");
+    throw new GitMetadataValidationError("unterminated Git config value");
 }
 function unescapeGitConfigText(value) {
     let result = "";
@@ -394,7 +435,7 @@ function unescapeGitConfigText(value) {
         }
         const escaped = value[index + 1];
         if (escaped === undefined)
-            throw new Error("invalid Git config escape");
+            throw new GitMetadataValidationError("invalid Git config escape");
         result += unescapeGitConfigCharacter(escaped);
         index += 1;
     }
@@ -409,7 +450,7 @@ function unescapeGitConfigCharacter(value) {
         return "\b";
     if (value === '"' || value === "\\")
         return value;
-    throw new Error("invalid Git config escape");
+    throw new GitMetadataValidationError("invalid Git config escape");
 }
 function selectedRemoteRepositoryName(remotes) {
     const origin = remotes.get("origin");
@@ -465,7 +506,7 @@ function repositoryNameFromCommonDir(commonDir) {
         : commonName.replace(/\.git$/i, "");
     const normalized = sanitizeWorkspaceName(name);
     if (!normalized)
-        throw new Error("Git common directory has no usable repository name");
+        throw new GitMetadataValidationError("Git common directory has no usable repository name");
     return normalized;
 }
 function identityKey(source, value) {
@@ -488,3 +529,10 @@ function pathContains(root, candidate) {
 function isNodeErrorCode(error, code) {
     return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
+class GitMetadataValidationError extends Error {
+}
+function canFallbackFromDirectGitDirectory(error) {
+    return error instanceof GitMetadataValidationError
+        || isNodeErrorCode(error, "ENOENT")
+        || isNodeErrorCode(error, "ENOTDIR");
+}

package/lib/memorax-code-backend/dist/server-cli.js

@@ -559,7 +559,12 @@ function printLifecycleResult(report) {
     if (report.message)
         backendLog(report.message);
     if (report.backend) {
-        backendLog(`Backend: ${report.backend.ok ? green(report.backend.degraded ? "ok (degraded)" : "ok") : red("not ok")}${report.backend.state?.url ? ` ${report.backend.state.url}` : ""}${report.backend.errorCode ? ` code=${report.backend.errorCode}` : ""}${report.backend.error ? ` error=${report.backend.error}` : ""}`);
+        const status = !report.backend.ok
+            ? red("not ok")
+            : report.backend.action === "stop"
+                ? green(report.backend.skipped ? "kept running" : "stopped")
+                : green(report.backend.degraded ? "ok (degraded)" : "ok");
+        backendLog(`Backend: ${status}${report.backend.state?.url ? ` ${report.backend.state.url}` : ""}${report.backend.errorCode ? ` code=${report.backend.errorCode}` : ""}${report.backend.error ? ` error=${report.backend.error}` : ""}`);
         for (const warning of report.backend.warnings ?? []) {
             backendLog(`Warning: ${warning.message}${warning.errorCode ? ` code=${warning.errorCode}` : ""}`);
         }
@@ -666,15 +671,33 @@ function lifecycleGuidance(report) {
             ];
     }
     if (report.action === "uninstall") {
-        return report.ok
-            ? [
-                green("MemoraX Code has been uninstalled from this npm installation."),
-                green("Restart or refresh Codex so it drops the removed adapter plugin."),
-            ]
-            : [
+        if (!report.ok) {
+            return [
                 red("Uninstall needs attention."),
                 "Run `memorax-code status` and `memorax-code logs` before retrying.",
             ];
+        }
+        const clientName = report.codexAdapter && report.claudeAdapter
+            ? "Codex and Claude Code"
+            : report.codexAdapter
+                ? "Codex"
+                : report.claudeAdapter
+                    ? "Claude Code"
+                    : undefined;
+        const npmPackageRemoved = report.npmPackageRemoval?.ok === true
+            && report.npmPackageRemoval.skipped !== true;
+        return [
+            ...(npmPackageRemoved
+                ? [green("MemoraX Code has been uninstalled from this npm installation.")]
+                : clientName
+                    ? [green(`MemoraX Code has been uninstalled from ${clientName}.`)]
+                    : []),
+            ...(clientName
+                ? [green(report.codexAdapter && report.claudeAdapter
+                        ? "Restart or refresh Codex and Claude Code so they drop the removed adapter plugins."
+                        : `Restart or refresh ${clientName} so it drops the removed adapter plugin.`)]
+                : []),
+        ];
     }
     return [];
 }

package/lib/memorax-code-backend/dist/server-memory-viewer.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { MEMORAX_ICON_DATA_URL } from "./memory-viewer-icon.js";
 import { isMemoryProjectId, UNCLASSIFIED_PROJECT_ID } from "./memory-project.js";
 import { MEMORAX_LOGO_DATA_URL } from "./memory-viewer-logo.js";
 import { memoryViewerUserHtml } from "./memory-viewer-user-html.js";
@@ -10,6 +11,7 @@ import { memoraxCodeHomeForTrace } from "./trace-config.js";
 const MEMORY_VIEWER_SESSION_ACTIVITY_WINDOW_MS = 72 * 60 * 60 * 1_000;
 const MEMORY_VIEWER_ACTIVITY_CUTOFF_GRANULARITY_MS = 60_000;
 const MEMORY_VIEWER_LOGO = Buffer.from(MEMORAX_LOGO_DATA_URL.slice(MEMORAX_LOGO_DATA_URL.indexOf(",") + 1), "base64");
+const MEMORY_VIEWER_ICON = Buffer.from(MEMORAX_ICON_DATA_URL.slice(MEMORAX_ICON_DATA_URL.indexOf(",") + 1), "base64");
 export async function handleMemoryViewerRequest(url, req, res, options = {}) {
     if (req.method === "GET" && url.pathname === "/memory-viewer") {
         if (!memoryViewerUserClient(url)) {
@@ -36,6 +38,15 @@ export async function handleMemoryViewerRequest(url, req, res, options = {}) {
         res.end(MEMORY_VIEWER_LOGO);
         return true;
     }
+    if (req.method === "GET" && url.pathname === "/memory-viewer/favicon.png") {
+        res.writeHead(200, {
+            "content-type": "image/png",
+            "cache-control": "private, max-age=86400",
+            "x-content-type-options": "nosniff",
+        });
+        res.end(MEMORY_VIEWER_ICON);
+        return true;
+    }
     if (req.method !== "GET" || url.pathname !== "/memory-viewer/api/summary") {
         return false;
     }

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

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/backend",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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.1",
+  "version": "0.1.2",
   "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.1",
+  "shellVersion": "0.1.2",
   "runtimeAbi": 1
 }

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

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

package/lib/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-adapter/skills/memorax-code/SKILL.md

@@ -1,21 +1,20 @@
 ---
 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

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

@@ -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.

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

@@ -8,7 +8,9 @@ Run the CLI from the active task workspace. The installed Hook and session bindi
 
 Coding memory uses `<MemoraX base user ID>@<normalized repository name>` for Git workspaces and the normalized folder name for genuine non-Git directories. MemoraX Code resolves `.git`, `gitdir`, and `commondir` without executing Git. Linked worktrees share one repository scope; another clone, repository, or non-Git directory retains a different local session key even when its readable name matches.
 
-Require a readable active workspace binding. A CLI command from a linked worktree of the bound repository is valid. If the CLI reports `workspace_scope_mismatch`, ask the user to start a task in the target repository or local workspace. Do not retry from an unrelated scope or fall back to an unscoped user id.
+If a successful Search result reports `workspaceScopeFallbackReason: git_metadata_invalid`, malformed or incomplete metadata inside a direct `.git` directory was downgraded to the normalized local folder scope. Search has already run with the reported `effectiveUserId`. Present its `userNotice` once without pausing the current task or asking the user to repair Git first, then continue with the returned memory and live evidence. 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.
+
+Require a readable active workspace binding. A CLI command from a linked worktree of the bound repository is valid. If `memorax-cli search` reports `workspace_scope_mismatch` or `workspace_scope_unavailable`, do not bypass the scope or fall back to an unscoped user id. Do not change the CLI working directory and retry. Tell the user that memory search was not executed 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.
 
 If `memorax-cli` is not on `PATH`, or memory is disabled, unconfigured, or unavailable, report that briefly and continue with live code or documentation. Authenticate through MemoraX Code configuration; never recover credentials from shell history or place tokens in prompts. Treat injected memory as a hypothesis and verify it against the current checkout.
 

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

@@ -35,6 +35,7 @@ const STABLE_SHELL_REQUIRED_FILES = Object.freeze([
   "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",
+  "memorax-code-adapter-common/src/repo-memory/repo-memory-auto-build.mjs",
   "memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs",
   "memorax-code-adapter-common/src/repo-memory/repo-procedure-memory-context.mjs",
   "memorax-code-adapter-common/src/repo-memory/repo-user-profile-context.mjs",

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.1",
+  "version": "0.1.2",
   "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.1",
+  "shellVersion": "0.1.2",
   "runtimeAbi": 1
 }

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

@@ -182,7 +182,7 @@ function combinedReminderContext(options, due, cadenceReminderContext, personalM
 
 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.`;
+  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() {

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(process.execPath, [jobHookPath, "maintain", "--repo", repoPath], {
+      cwd: repoPath,
+      detached: true,
+      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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/claude-adapter",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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({