@memorax/memorax-code 0.1.7 → 0.1.8

package/README.md

@@ -14,14 +14,45 @@ Harness, and OpenCode.
 
 ```bash
 npm install -g @memorax/memorax-code
+```
+
+### Connect a MemoraX Account (Recommended)
+
+[Create a MemoraX account](https://platform.memorax.net/) or use an existing
+one, then run:
+
+```bash
+memorax-code setup --existing-account
+```
+
+> Using MemoraX Code across devices? Find the MemoraX username and API key
+> needed by setup in the MemoraX Code configuration file on a configured device
+> (normally `~/.memorax-code/config.toml`), then enter them locally during setup
+> on another device. This file contains your API key—keep it private and never
+> paste it into chats or public issues.
+
+### Or Try Without an Account (90-Day Guest Mode)
+
+To start immediately and connect an account later, run:
+
+```bash
 memorax-code setup
 ```
 
-Setup automatically detects supported coding agents and completes an
-account-free connection. If you already have a MemoraX account, run
-`memorax-code setup --existing-account` instead. Later setup runs reuse a
-complete saved configuration; use `memorax-code setup --reconfigure` to
-replace it.
+To activate your guest account, first run this command directly in your local
+terminal:
+
+```bash
+memorax-code account --show-mark-id
+```
+
+After obtaining the Mark ID, create your MemoraX account. The platform does
+not currently support attaching a Mark ID to an account that has already been
+registered.
+
+Both setup paths automatically detect supported coding agents. Later setup
+runs reuse a complete saved configuration; use
+`memorax-code setup --reconfigure` to replace it.
 
 After the first installation, restart or refresh the detected coding agents
 before opening a new session. In Codex, enable **MemoraX Code Codex Adapter**

package/bin/memorax-code-setup.mjs

@@ -260,9 +260,6 @@ printPostinstallSummary(
   backendAndAdaptersStatus,
   backendAndAdapters.dshAdapterUnavailable,
 );
-if (backendAndAdaptersStatus === "enabled") {
-  log("View local memory activity: http://127.0.0.1:8787/memory-viewer");
-}
 if (backendAndAdaptersStatus !== "enabled") process.exit(1);
 if (!updateMode && readMemoraxInstallStatus()?.configured !== true) {
   logRed("Setup could not verify a ready MemoraX connection after Backend reconciliation.");

package/docs/configuration.md

@@ -354,9 +354,7 @@ export, or public collector.
 
 DSH trace contains only normalized lifecycle and memory-operation events. Its
 native Session Event Log and raw events remain local to DSH; MemoraX Code does
-not copy that log into trace. Memory Viewer includes DSH activity from
-normalized operational events and retained trace, and never reads the native
-Session Event Log.
+not copy that log into trace.
 
 ## Backend runtime settings
 

package/docs/troubleshooting.md

@@ -135,19 +135,20 @@ again at 0%; raw quota counts are not shown.
 Automatic quota reminders are currently supported in Codex, Claude Code, and
 OpenCode. DeepSeek Harness does not currently surface these reminders.
 
-Routine reminders do not include a complete Mark ID. If this device uses an
-unregistered anonymous identity and the MemoraX account page requires its Mark
-ID, run this command yourself in a local terminal:
+A guest reminder displays the complete Mark ID when the ready local trial
+identity matches the active API key. Registered-account reminders do not
+include it. If a guest reminder cannot verify a matching local identity, it
+instead directs you to run this command yourself in a local terminal:
 
 ```sh
 memorax-code account --show-mark-id
 ```
 
-The command reads a ready local trial identity and prints only its Mark ID. Do
-not ask an Agent to run it or paste the output into a conversation, screenshot,
-or log. If no ready local trial identity exists, use `memorax-code setup`; a
-connection copied from another computer does not include that computer's
-device-local Mark ID.
+The command reads a ready local trial identity and prints only its Mark ID. A
+reminder or command output containing the Mark ID is sensitive; do not share it
+in a conversation, screenshot, or log. If no ready local trial identity exists,
+use `memorax-code setup`; a connection copied from another computer does not
+include that computer's device-local Mark ID.
 
 ## Backend does not start
 

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

@@ -1,27 +1,19 @@
 import { createServer, } from "node:http";
 import { backendDebug } from "../shared/debug-log.js";
 import { createMemoryReminderTraceRecorder } from "../memory/reminder-trace-recorder.js";
-import { handleMemoryViewerRequest } from "../viewer/http/public-routes.js";
 import { handleMemoryHookRequest } from "../transport/http/memory-hook.js";
 import { createBackendMemoryObservability } from "./memory-observability.js";
 import { createMemoryService } from "../memory/service.js";
 import { handleHealthRequest } from "../transport/http/health.js";
-import { authorized, memoryViewerSessionCookieHeader, publicErrorMessage, statusCodeFromError } from "../transport/http/request.js";
+import { authorized, publicErrorMessage, statusCodeFromError } from "../transport/http/request.js";
 import { json } from "../transport/http/json.js";
 import { createBackendState } from "./state.js";
 import { TRACE_CLIENTS } from "../trace/config.js";
 import { pruneExpiredTraceSessionsForClient } from "../trace/store.js";
-import { startMemoryWritebackReconciler } from "../memory/writeback-reconciler.js";
-import { createMemoryWritebackTaskProjection } from "../memory/writeback-task-projection.js";
-import { readActiveManagedClients } from "../lifecycle/active-clients.js";
 const DEFAULT_BACKEND_SHUTDOWN_TIMEOUT_MS = 4_000;
 export function createBackendServer(state = createBackendState(), options = {}) {
     const memoryEnv = { ...process.env, MEMORAX_CODE_HOME: state.sessionHome };
-    const memoryWritebackTaskProjections = TRACE_CLIENTS.map((client) => createMemoryWritebackTaskProjection({
-        memoraxCodeHome: state.sessionHome,
-        client,
-    }));
-    const memoryObservability = createBackendMemoryObservability(state.sessionHome, options.memoryObservability, memoryEnv, memoryWritebackTaskProjections.map((projection) => projection.observabilityHook));
+    const memoryObservability = createBackendMemoryObservability(state.sessionHome, options.memoryObservability, memoryEnv);
     const memoryService = createMemoryService({
         diagnosticLogger: backendDebug,
         env: memoryEnv,
@@ -46,11 +38,6 @@ export function createBackendServer(state = createBackendState(), options = {})
             });
         });
     }
-    const memoryWritebackReconcilers = memoryWritebackTaskProjections.map((taskProjection) => (startMemoryWritebackReconciler({
-        memoraxCodeHome: state.sessionHome,
-        env: memoryEnv,
-        taskProjection,
-    })));
     const handleRequest = async (req, res) => {
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
         backendDebug("http.request", {
@@ -62,17 +49,6 @@ export function createBackendServer(state = createBackendState(), options = {})
                 return handleHealthRequest(state, res);
             if (!authorized(state, req, url))
                 return json(res, 401, { ok: false, error: "unauthorized" });
-            if (url.pathname === "/memory-viewer"
-                || url.pathname.startsWith("/memory-viewer/")) {
-                if (await handleMemoryViewerRequest(url, req, res, {
-                    memoraxCodeHome: state.sessionHome,
-                    claudeProjectsRoot: readActiveManagedClients(state.sessionHome)?.claude === true
-                        ? state.claudeProjectsRoot
-                        : false,
-                    sessionCookie: memoryViewerSessionCookieHeader(state, req, url),
-                }))
-                    return;
-            }
             if (await handleMemoryHookRequest(memoryHookDependencies, url, req, res))
                 return;
             return json(res, 404, { ok: false, error: "not found" });
@@ -98,7 +74,6 @@ export function createBackendServer(state = createBackendState(), options = {})
         activeRequests,
         memoryObservability,
         memoryService,
-        memoryWritebackReconcilers,
         timeoutMs: positiveShutdownTimeout(options.shutdownTimeoutMs),
     });
 }
@@ -118,7 +93,6 @@ function attachBackendShutdown(server, resources) {
 }
 async function shutdownBackend(server, closeHttpServer, resources) {
     const deadline = Date.now() + resources.timeoutMs;
-    const reconcilerDrain = settleShutdownWork("memory_writeback_reconcilers", Promise.all(resources.memoryWritebackReconcilers.map((reconciler) => reconciler.close())));
     try {
         await waitForShutdownPhase("http_server", closeBackendHttpServer(server, closeHttpServer, resources.timeoutMs), deadline);
         await waitForShutdownPhase("http_requests", waitForActiveRequests(resources.activeRequests), deadline);
@@ -128,7 +102,6 @@ async function shutdownBackend(server, closeHttpServer, resources) {
         if (Date.now() < deadline && resources.memoryObservability?.drain) {
             await waitForShutdownPhase("memory_observability", settleShutdownWork("memory_observability", resources.memoryObservability.drain()), deadline);
         }
-        await waitForShutdownPhase("background_work", reconcilerDrain, deadline);
     }
     finally {
         resources.memoryService.close();

package/lib/memorax-code-backend/dist/app/memory-observability.js

@@ -2,14 +2,11 @@ import { randomUUID } from "node:crypto";
 import { backendDebug } from "../shared/debug-log.js";
 import { TRACE_CLIENTS, clientTraceConfigFromEnv, } from "../trace/config.js";
 import { recordTraceEvent } from "../trace/store.js";
-import { memoryViewerObservabilityHook } from "../viewer/projection/observability.js";
-export function createBackendMemoryObservability(memoraxCodeHome, existingHook, env = process.env, additionalDefaultHooks = []) {
+export function createBackendMemoryObservability(memoraxCodeHome, existingHook, env = process.env) {
     if (existingHook)
         return existingHook;
     const effectiveEnv = { ...env, MEMORAX_CODE_HOME: memoraxCodeHome };
     return composeMemoryObservabilityHooks([
-        ...additionalDefaultHooks,
-        memoryViewerObservabilityHook(),
         sessionTraceObservabilityHook(memoraxCodeHome, effectiveEnv),
     ]);
 }

package/lib/memorax-code-backend/dist/app/state.js

@@ -1,11 +1,9 @@
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { backendEnv } from "../config/backend-env.js";
 export function createBackendState(host = "127.0.0.1", options = {}) {
     const authToken = options.authToken ?? backendEnv("TOKEN");
     const sessionHome = options.sessionHome ?? process.env.MEMORAX_CODE_HOME ?? join(homedir(), ".memorax-code");
-    const claudeProjectsRoot = options.claudeProjectsRoot
-        ?? memoryViewerClaudeProjectsRootFromEnv(process.env);
     const security = {
         ...envBackendSecurity(),
         ...options.security,
@@ -13,19 +11,10 @@ export function createBackendState(host = "127.0.0.1", options = {}) {
     validateBackendSecurity(host, authToken, security);
     return {
         sessionHome,
-        claudeProjectsRoot,
         authToken,
         security,
     };
 }
-export function memoryViewerClaudeProjectsRootFromEnv(env) {
-    const configured = env.MEMORAX_CODE_MEMORY_VIEWER_CLAUDE_PROJECTS_ROOT?.trim();
-    if (!configured)
-        return undefined;
-    if (configured === "disabled")
-        return false;
-    return resolve(configured);
-}
 function envBackendSecurity() {
     const mode = backendEnv("MODE") === "server" ? "server" : "local";
     return {

package/lib/memorax-code-backend/dist/clients/claude/transcript-turn.js

@@ -137,53 +137,6 @@ export function claudeInterruptedTranscriptTurnFromJsonLines(transcript, input)
     }
     return { ok: false, reason: "turn_not_interrupted" };
 }
-export function claudeTranscriptMemoryActivitiesFromJsonLines(transcript, input) {
-    const requested = requestedTranscriptRecords(transcript, input.sessionId);
-    if (!requested.ok)
-        return [];
-    const records = requested.records;
-    const recordsByUuid = indexRecordsByUuid(records);
-    const terminals = new Map();
-    const interrupted = new Map();
-    for (const record of records) {
-        if (isMemoryActivityTerminalAssistantRecord(record)) {
-            const branch = promptBranch(record, recordsByUuid);
-            if (!branch.ambiguous && branch.promptId && branch.userPrompt) {
-                const candidates = terminals.get(branch.promptId) ?? [];
-                candidates.push(branch);
-                terminals.set(branch.promptId, candidates);
-            }
-            continue;
-        }
-        if (!interruptionMarker(record))
-            continue;
-        const branch = promptBranch(record, recordsByUuid);
-        if (branch.ambiguous
-            || !branch.promptId
-            || !branch.userPrompt
-            || branch.assistantMessages.some((message) => message.stop_reason === "end_turn")) {
-            continue;
-        }
-        const candidates = interrupted.get(branch.promptId) ?? [];
-        candidates.push(branch);
-        interrupted.set(branch.promptId, candidates);
-    }
-    const activities = [];
-    const promptIds = new Set([...terminals.keys(), ...interrupted.keys()]);
-    for (const promptId of promptIds) {
-        const terminalBranches = maximalTerminalLineages((terminals.get(promptId) ?? []).map((branch) => ({ branch }))).map((candidate) => candidate.branch);
-        const interruptedBranches = interrupted.get(promptId) ?? [];
-        const branch = terminalBranches.length === 1
-            ? terminalBranches[0]
-            : terminalBranches.length === 0 && interruptedBranches.length === 1
-                ? interruptedBranches[0]
-                : undefined;
-        if (!branch)
-            continue;
-        activities.push(...claudeMemoryActivityDetails(promptId, branch, input.includeAuthority === true));
-    }
-    return activities;
-}
 function requestedTranscriptRecords(transcript, sessionId) {
     const parsed = transcriptRecords(transcript);
     if (!parsed.ok) {
@@ -383,86 +336,6 @@ function transcriptRecordTimestamp(record) {
     const timestamp = stringValue(record.timestamp);
     return timestamp && Number.isFinite(Date.parse(timestamp)) ? timestamp : undefined;
 }
-function claudeMemoryActivityDetails(promptId, branch, includeAuthority) {
-    const activities = [];
-    const terminalRecordId = includeAuthority
-        ? stringValue(branch.records[0]?.uuid)
-        : undefined;
-    const seenToolUseIds = new Set();
-    let index = 1;
-    for (const record of branch.records.slice().reverse()) {
-        const message = assistantMessageFromRecord(record);
-        if (!message || !Array.isArray(message.content))
-            continue;
-        for (const block of message.content) {
-            if (!isRecord(block) || block.type !== "tool_use")
-                continue;
-            const toolUseId = stringValue(block.id);
-            if (!toolUseId || seenToolUseIds.has(toolUseId))
-                continue;
-            seenToolUseIds.add(toolUseId);
-            if (block.name !== "Bash")
-                continue;
-            const toolInput = isRecord(block.input) ? block.input : undefined;
-            const command = toolInput ? stringValue(toolInput.command) : undefined;
-            if (!command)
-                continue;
-            const types = memoryCliCommandTypes(command);
-            if (types.length === 0)
-                continue;
-            const timestamp = canonicalTranscriptActivityTimestamp(record);
-            const result = claudeToolResultDetails(branch.records, toolUseId, types.length === 1 && types[0] === "memory_cli_search");
-            for (const [occurrence, type] of types.entries()) {
-                activities.push({
-                    promptId,
-                    index,
-                    occurrence: occurrence + 1,
-                    type,
-                    toolUseId,
-                    ...(terminalRecordId ? { terminalRecordId } : {}),
-                    ...(timestamp ? { timestamp } : {}),
-                    ...(result.ok === undefined ? {} : { ok: result.ok }),
-                    ...(type === "memory_cli_search" && result.itemCount !== undefined
-                        ? { itemCount: result.itemCount }
-                        : {}),
-                });
-            }
-            index += 1;
-        }
-    }
-    return activities;
-}
-function canonicalTranscriptActivityTimestamp(record) {
-    const timestamp = transcriptRecordTimestamp(record);
-    return timestamp ? new Date(Date.parse(timestamp)).toISOString() : undefined;
-}
-function claudeToolResultDetails(branchRecords, toolUseId, deriveSearchItemCount) {
-    const matches = [];
-    let failed = false;
-    for (const record of branchRecords) {
-        const message = isRecord(record.message) ? record.message : undefined;
-        if (message?.role !== "user" || !Array.isArray(message.content))
-            continue;
-        for (const block of message.content) {
-            if (!isRecord(block)
-                || block.type !== "tool_result"
-                || stringValue(block.tool_use_id ?? block.toolUseId) !== toolUseId) {
-                continue;
-            }
-            matches.push(block);
-            if (block.is_error === true)
-                failed = true;
-        }
-    }
-    if (matches.length === 0)
-        return {};
-    if (failed)
-        return { ok: false };
-    if (!deriveSearchItemCount || matches.length !== 1)
-        return { ok: true };
-    const itemCount = safeMemorySearchItemCount(matches[0]?.content);
-    return itemCount === undefined ? { ok: true } : { ok: true, itemCount };
-}
 function memoryCliCommandTypes(command) {
     const activities = [];
     for (const segment of shellCommandSegments(command)) {
@@ -623,54 +496,6 @@ function isNamedExecutable(word, name) {
     const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
     return basename === name || basename === `${name}.mjs`;
 }
-function safeMemorySearchItemCount(content) {
-    if (typeof content !== "string" || content.length > 2 * 1024 * 1024)
-        return undefined;
-    const output = content.trim();
-    if (!output)
-        return undefined;
-    if (output.startsWith("{")) {
-        try {
-            const parsed = JSON.parse(output);
-            if (!isRecord(parsed)
-                || parsed.ok !== true
-                || parsed.action !== "memory.search"
-                || !Array.isArray(parsed.items)
-                || parsed.items.length > 100) {
-                return undefined;
-            }
-            return parsed.items.length;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    const lines = output.split(/\r?\n/u);
-    if (lines[0] !== "<memories>" || lines.at(-1) !== "</memories>")
-        return undefined;
-    let insideFacts = false;
-    let factsGroups = 0;
-    let itemCount = 0;
-    for (const line of lines.slice(1, -1)) {
-        if (!insideFacts && /^ {2}<facts(?: memory_type="[^"\r\n]*")?>$/u.test(line)) {
-            insideFacts = true;
-            factsGroups += 1;
-            continue;
-        }
-        if (insideFacts && line === "  </facts>") {
-            insideFacts = false;
-            continue;
-        }
-        if (insideFacts && /^ {3}-(?:\[[^\]\r\n]+\] | )\S.*$/u.test(line)) {
-            itemCount += 1;
-            if (itemCount > 100)
-                return undefined;
-            continue;
-        }
-        return undefined;
-    }
-    return !insideFacts && factsGroups > 0 && itemCount > 0 ? itemCount : undefined;
-}
 function claudeMemoryActivities(assistantMessages) {
     const activities = [];
     const seenToolUseIds = new Set();
@@ -820,13 +645,6 @@ function completedAssistantReply(record) {
 function isCompletedAssistantRecord(record) {
     return assistantMessageFromRecord(record)?.stop_reason === "end_turn";
 }
-function isMemoryActivityTerminalAssistantRecord(record) {
-    const message = assistantMessageFromRecord(record);
-    const stopReason = message ? stringValue(message.stop_reason) : undefined;
-    return Boolean(message && ((stopReason && stopReason !== "tool_use")
-        || record.isApiErrorMessage === true
-        || record.error));
-}
 function assistantMessageFromRecord(record) {
     if (record.type !== "assistant"
         || record.isSidechain === true

package/lib/memorax-code-backend/dist/clients/opencode/message-turn.js

@@ -10,7 +10,7 @@ export function openCodeMessageTurn(messages, input) {
     }
     if (stringField(user.info, "sessionID") !== input.sessionId
         || stringField(assistant.info, "sessionID") !== input.sessionId
-        || stringField(assistant.info, "parentID") !== input.userMessageId) {
+        || !assistantBelongsToTurn(messages, input, assistant)) {
         return { ok: false, reason: "message_identity_mismatch" };
     }
     const assistantTime = isRecord(assistant.info.time) ? assistant.info.time : undefined;
@@ -18,7 +18,7 @@ export function openCodeMessageTurn(messages, input) {
         return { ok: false, reason: "assistant_not_completed" };
     }
     const assistantError = assistant.info.error;
-    const interrupted = isRecord(assistantError) && assistantError.name === "MessageAbortedError";
+    const interrupted = isRecord(assistantError) && stringField(assistantError, "name") !== undefined;
     if (assistantError !== undefined && assistantError !== null && !interrupted) {
         return { ok: false, reason: "assistant_error" };
     }
@@ -46,6 +46,52 @@ export function openCodeMessageTurn(messages, input) {
         },
     };
 }
+function assistantBelongsToTurn(messages, input, assistant) {
+    return stringField(assistant.info, "parentID") === terminalUserMessageFor(messages, input);
+}
+function terminalUserMessageFor(messages, input) {
+    const sessionMessages = messages.filter((message) => (isMessageRecord(message)
+        && stringField(message.info, "sessionID") === input.sessionId
+        && messageId(message) !== undefined));
+    const startIndex = sessionMessages.findIndex((message) => (message.info.role === "user" && messageId(message) === input.userMessageId));
+    if (startIndex < 0)
+        return undefined;
+    const lineageAssistantIds = new Set();
+    let terminalUserMessageId = input.userMessageId;
+    let awaitingContinuation = false;
+    for (const message of sessionMessages.slice(startIndex + 1)) {
+        if (message.info.role === "assistant") {
+            if (stringField(message.info, "parentID") === terminalUserMessageId) {
+                const id = messageId(message);
+                if (id)
+                    lineageAssistantIds.add(id);
+            }
+            continue;
+        }
+        if (message.info.role !== "user")
+            continue;
+        if (hasCompactionPart(message.parts)) {
+            const compactionTailId = compactionTailStartId(message, input.sessionId);
+            if (!compactionTailId || !lineageAssistantIds.has(compactionTailId) || awaitingContinuation) {
+                return undefined;
+            }
+            awaitingContinuation = true;
+            continue;
+        }
+        if (isCompactionContinuation(message, input.sessionId)) {
+            if (!awaitingContinuation)
+                return undefined;
+            const id = messageId(message);
+            if (!id)
+                return undefined;
+            terminalUserMessageId = id;
+            awaitingContinuation = false;
+            continue;
+        }
+        break;
+    }
+    return !awaitingContinuation ? terminalUserMessageId : undefined;
+}
 function isMessageRecord(value) {
     return isRecord(value) && isRecord(value.info) && Array.isArray(value.parts);
 }
@@ -72,6 +118,26 @@ function messageText(message, sessionId, messageId) {
 function hasCompactionPart(parts) {
     return parts.some((part) => isRecord(part) && part.type === "compaction");
 }
+function compactionTailStartId(message, sessionId) {
+    const id = messageId(message);
+    const parts = message.parts.filter((part) => (isRecord(part)
+        && part.type === "compaction"
+        && stringField(part, "sessionID") === sessionId
+        && stringField(part, "messageID") === id));
+    if (parts.length !== 1 || !isRecord(parts[0]))
+        return undefined;
+    return stringField(parts[0], "tail_start_id");
+}
+function isCompactionContinuation(message, sessionId) {
+    const id = messageId(message);
+    return message.parts.some((part) => (isRecord(part)
+        && part.type === "text"
+        && part.synthetic === true
+        && isRecord(part.metadata)
+        && part.metadata.compaction_continue === true
+        && stringField(part, "sessionID") === sessionId
+        && stringField(part, "messageID") === id));
+}
 function stringField(value, key) {
     const field = value[key];
     return typeof field === "string" && field.trim() ? field.trim() : undefined;

package/lib/memorax-code-backend/dist/lifecycle/backend/service.js

@@ -144,11 +144,6 @@ export async function startBackendService(options = {}, runtime = {}) {
                 MEMORAX_CODE_BACKEND_HOST: host,
                 MEMORAX_CODE_BACKEND_PORT: String(port),
                 MEMORAX_CODE_BACKEND_INSTANCE_ID: instanceId,
-                ...(options.claudeProjectsRoot === false
-                    ? { MEMORAX_CODE_MEMORY_VIEWER_CLAUDE_PROJECTS_ROOT: "disabled" }
-                    : typeof options.claudeProjectsRoot === "string" && options.claudeProjectsRoot.trim()
-                        ? { MEMORAX_CODE_MEMORY_VIEWER_CLAUDE_PROJECTS_ROOT: resolve(options.claudeProjectsRoot.trim()) }
-                        : {}),
                 ...(token ? { MEMORAX_CODE_BACKEND_TOKEN: token } : {}),
             }, url),
             stdio: ["ignore", outFd, errFd],

package/lib/memorax-code-backend/dist/lifecycle/orchestrator.js

@@ -276,11 +276,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
             ...(opencodeAdapter ? { opencodeAdapter } : {}),
         };
     }
-    const backendStartOptions = {
-        ...serviceOptions,
-        claudeProjectsRoot: claudeProjectsRootForStart(argv, claudeAdapter),
-    };
-    const backend = await startBackendService(backendStartOptions);
+    const backend = await startBackendService(serviceOptions);
     if (!backend.ok) {
         const disabledCodex = codexAdapter
             ? await codexAdapterLifecycle.disable({ argv, serviceOptions })
@@ -314,15 +310,6 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
         ...(opencodeAdapter ? { opencodeAdapter } : {}),
     };
 }
-function claudeProjectsRootForStart(argv, claudeAdapter) {
-    if (claudeAdapter?.ok === false || claudeAdapter?.enabled !== true)
-        return false;
-    const claudeHome = argValue(argv, "--claude-home")?.trim()
-        || process.env.CLAUDE_CONFIG_DIR?.trim()
-        || process.env.CLAUDE_HOME?.trim()
-        || join(homedir(), ".claude");
-    return join(resolve(claudeHome), "projects");
-}
 function expectedBackendUrl(serviceOptions) {
     return preflightBackendServiceStart(serviceOptions).url;
 }

package/lib/memorax-code-backend/dist/memory/automatic-writeback.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { createMemoryWritebackBufferRuntime, } from "./writeback-buffer.js";
 import { memoryWritebackAddParts, } from "./writeback-chunk.js";
 import { invokeMemoraxMemoryProvider, } from "../provider/memorax/adapter.js";
-import { memoryWritebackBufferEnabled, memoryWritebackEnabled, memoryWritebackMaxMessageChars, } from "../provider/memorax/config.js";
+import { memoraxConfigFromEnv, memoryWritebackBufferEnabled, memoryWritebackEnabled, memoryWritebackMaxMessageChars, } from "../provider/memorax/config.js";
 import { hasMeaningfulMemoryPayloadText, redactMemoryPayloadText, } from "./payload-redaction.js";
 const WRITEBACK_DEDUPE_TTL_MS = 5 * 60 * 1000;
 const WRITEBACK_DEDUPE_MAX = 1024;
@@ -190,6 +190,7 @@ async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
         const parts = memoryWritebackAddParts(decision, options.env ?? process.env);
         for (const [index, part] of parts.entries()) {
             for (let attempt = 1; attempt <= AUTOMATIC_MEMORY_WRITEBACK_MAX_ATTEMPTS; attempt += 1) {
+                const configResult = memoraxConfigFromEnv(options.env);
                 const response = await invokeMemoraxMemoryProvider({
                     sessionId: decision.sessionKey,
                     prompt: part.messages.find((message) => message.role === "user")?.content ?? "",
@@ -208,6 +209,7 @@ async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
                         ...(part.chunk ? { chunk: part.chunk } : {}),
                     },
                 }, {
+                    ...(configResult.ok ? { config: configResult.config } : {}),
                     env: options.env,
                     fetchImpl: options.fetchImpl,
                     observability: options.memoryObservability,
@@ -245,8 +247,9 @@ async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
                     httpStatus: response.ok ? undefined : response.httpStatus,
                 });
                 if (response.ok) {
-                    if (response.result.quota)
-                        queueQuotaNoticeBestEffort(state, response.result.quota);
+                    if (response.result.quota && configResult.ok) {
+                        queueQuotaNoticeBestEffort(state, configResult.config, response.result.quota);
+                    }
                     break;
                 }
                 if (!retrying) {
@@ -287,9 +290,9 @@ function trackAutomaticMemoryWriteback(state, writeback) {
     state.inFlight.add(writeback);
     void writeback.then(() => state.inFlight.delete(writeback), () => state.inFlight.delete(writeback));
 }
-function queueQuotaNoticeBestEffort(state, quota) {
+function queueQuotaNoticeBestEffort(state, config, quota) {
     try {
-        state.queueQuotaNotice?.(quota);
+        state.queueQuotaNotice?.(config, quota);
     }
     catch {
         state.diagnosticLogger("memory.automatic_writeback.quota_notice_queue_failed", {});