@memorax/memorax-code 0.1.2 → 0.1.3

package/lib/memorax-code-backend/dist/memory/payload-redaction.js

@@ -0,0 +1,212 @@
+const PLACEHOLDER_PATTERN = /\[REDACTED:[A-Z_]+\]/g;
+const PLACEHOLDER_VALUE_PATTERN = /^\[REDACTED:[A-Z_]+\]$/;
+const SENSITIVE_KEY_SOURCE = String.raw `(?:[A-Za-z_$][A-Za-z0-9_$-]*)?(?:password|passwd|pwd|client[-_$]?secret|consumer[-_$]?secret|api[-_$]?key|access[-_$]?token|refresh[-_$]?token|auth[-_$]?token|id[-_$]?token|private[-_$]?key|secret[-_$]?access[-_$]?key|secret[-_$]?key|credential|secret|token)`;
+const CREDENTIAL_VALUE_SOURCE = String.raw `(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*?\}\}|\{\{[^\r\n]*?\}\}|\$\{[^}\r\n]+\}|\$[A-Za-z_][A-Za-z0-9_]*|"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^,;#}\]\)\r\n]+)`;
+const SAFE_CREDENTIAL_VALUE_PATTERN = /^(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*\}\}|\{\{[^\r\n]*\}\}|\$\{[A-Z_][A-Z0-9_]*\}|\$[A-Z_][A-Z0-9_]*|(?:process\.)?env\.[A-Z_][A-Z0-9_]*|<[^>]+>|--\S+|x{2,}|\*{2,}|\.{3}|sk[_-]x+|example|sample|change-?me|(?:your|replace)[-_][a-z0-9_-]+|string|str|number|boolean|unknown|any|null|undefined|none)$/i;
+const NON_CONTENT_LABEL_PATTERN = /\b(?:proxy-authorization|authorization|bearer|basic|cookie|set-cookie|password|passwd|pwd|client[_-]?secret|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|private[_-]?key|credential|secret|token|jwt|email|contact|card|key|export)\b/gi;
+const RULES = [
+    {
+        pattern: /-----BEGIN ((?:(?:RSA|EC|DSA|OPENSSH|ENCRYPTED) )?PRIVATE KEY|PGP PRIVATE KEY BLOCK)-----[\s\S]*?(?:-----END \1-----|$)/gi,
+        kind: "PRIVATE_KEY",
+        priority: 100,
+    },
+    {
+        pattern: /(?:^|[\r\n])[ \t]*(?:Proxy-)?Authorization[ \t]*:[ \t]*([^ \t\r\n][^\r\n]*)/gim,
+        group: 1,
+        kind: "AUTH_TOKEN",
+        priority: 95,
+    },
+    {
+        pattern: /(?:^|[^A-Za-z0-9_-])(?:Bearer|Basic)\s+["']?([A-Za-z0-9._~+/=-]{16,})(?![A-Za-z0-9._~+/=-])/gi,
+        group: 1,
+        kind: "AUTH_TOKEN",
+        priority: 94,
+    },
+    {
+        pattern: /\beyJ[A-Za-z0-9_-]{5,}\.eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{16,}\b/g,
+        kind: "AUTH_TOKEN",
+        priority: 94,
+    },
+    {
+        pattern: /(?:^|[\r\n])[ \t]*(?:Set-Cookie|Cookie)\s*:\s*([^\r\n]+)/gim,
+        group: 1,
+        kind: "COOKIE",
+        priority: 92,
+    },
+    {
+        pattern: new RegExp(String.raw `(?:^|[\r\n;,{}])[ \t]*(?:-[ \t]+)?(?:(?:export|const|let|var)[ \t]+)*["']?${SENSITIVE_KEY_SOURCE}["']?[ \t]*[:=][ \t]*(${CREDENTIAL_VALUE_SOURCE})`, "gim"),
+        group: 1,
+        kind: "CREDENTIAL",
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        pattern: new RegExp(String.raw `--${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])(?:[ \t]+|=[ \t]*)(${CREDENTIAL_VALUE_SOURCE})`, "gi"),
+        group: 1,
+        kind: "CREDENTIAL",
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        pattern: new RegExp(String.raw `[?&]${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])=([^&#\s"'<>]+)`, "gi"),
+        group: 1,
+        kind: "CREDENTIAL",
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        pattern: /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s/:@]*:([^\s/@]+)@/g,
+        group: 1,
+        kind: "CREDENTIAL",
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    { pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\bsk_[A-Za-z0-9_-]{8,}\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\bxox[baprs]-[A-Za-z0-9-]{16,}[A-Za-z0-9]\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\b(?:(?:sk|rk)_live_[A-Za-z0-9]{16,}|whsec_[A-Za-z0-9]{16,})\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\bglpat-[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g, kind: "API_KEY", priority: 80 },
+    { pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, kind: "API_KEY", priority: 80 },
+    {
+        pattern: /(?<![A-Z0-9._%+-])[A-Z0-9._%+-]{1,64}@[A-Z0-9](?:[A-Z0-9.-]{0,251}[A-Z0-9])?\.[A-Z]{2,63}(?![A-Z0-9-]|\.[A-Z0-9])/gi,
+        kind: "EMAIL",
+        priority: 70,
+    },
+    {
+        pattern: /(?<![A-Za-z0-9])[0-9A-Fa-f]{8}-(?:[0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}(?![A-Za-z0-9])/g,
+        kind: "OPAQUE_ID",
+        priority: 60,
+    },
+    {
+        pattern: /(?<![A-Za-z0-9])(?:[0-9A-Fa-f]{64}|[0-9A-Fa-f]{40}|[0-9A-Fa-f]{32})(?![A-Za-z0-9])/g,
+        kind: "OPAQUE_ID",
+        priority: 60,
+        accept: (value) => /[A-Fa-f]/.test(value),
+    },
+    {
+        pattern: /(?<![A-Za-z0-9])[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g,
+        kind: "OPAQUE_ID",
+        priority: 60,
+        accept: looksLikeHighEntropyOpaqueId,
+    },
+    {
+        pattern: /(?<![A-Za-z0-9.])\+?(?:\d|\(\d)[\d ()-]*\d[Xx]?\)?(?![A-Za-z0-9]|\.\d)/g,
+        kind: "LONG_NUMBER",
+        priority: 50,
+        accept: (value) => {
+            if (value.replace(/\D/g, "").length < 9)
+                return false;
+            const normalized = value.trim().replace(/[()]/g, "");
+            return !/^(?:19|20)\d{2}-\d{1,2}-\d{1,2}(?:[ T-]\d{1,2})?$/.test(normalized)
+                && !/^(?:19|20)\d{2}\s+\d{1,2}\s+\d{1,2}(?:\s+\d{1,2})?$/.test(normalized);
+        },
+    },
+];
+export function redactMemoryPayloadText(text) {
+    if (!text)
+        return { text, counts: {}, redacted: false };
+    const spans = [];
+    for (const rule of RULES)
+        collectRuleSpans(text, rule, spans);
+    const selected = mergeOverlappingSpans(spans);
+    if (selected.length === 0)
+        return { text, counts: {}, redacted: false };
+    const counts = {};
+    const output = [];
+    let offset = 0;
+    for (const span of selected) {
+        output.push(text.slice(offset, span.start), `[REDACTED:${span.kind}]`);
+        counts[span.kind] = (counts[span.kind] ?? 0) + 1;
+        offset = span.end;
+    }
+    output.push(text.slice(offset));
+    return { text: output.join(""), counts, redacted: true };
+}
+export function hasMeaningfulMemoryPayloadText(text) {
+    if (!text.trim())
+        return false;
+    const remainder = text
+        .replace(PLACEHOLDER_PATTERN, " ")
+        .replace(NON_CONTENT_LABEL_PATTERN, " ")
+        .replace(/[\s.,;:!?"'`(){}\[\]<>/\\|=_-]+/g, "");
+    return /[\p{L}\p{N}]/u.test(remainder);
+}
+function collectRuleSpans(text, rule, spans) {
+    rule.pattern.lastIndex = 0;
+    for (const match of text.matchAll(rule.pattern)) {
+        const value = match[rule.group ?? 0];
+        if (match.index === undefined || !value || PLACEHOLDER_VALUE_PATTERN.test(value.trim()))
+            continue;
+        if (rule.accept && !rule.accept(value))
+            continue;
+        const relativeStart = match[0].lastIndexOf(value);
+        if (relativeStart < 0)
+            continue;
+        spans.push({
+            start: match.index + relativeStart,
+            end: match.index + relativeStart + value.length,
+            kind: rule.kind,
+            priority: rule.priority,
+        });
+    }
+}
+function isSafeCredentialValue(rawValue) {
+    let value = rawValue.trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1).trim();
+    }
+    return !value || SAFE_CREDENTIAL_VALUE_PATTERN.test(value);
+}
+function looksLikeHighEntropyOpaqueId(value) {
+    let lowercase = 0;
+    let uppercase = 0;
+    let digits = 0;
+    let transitions = 0;
+    let letterRun = 0;
+    let longestLetterRun = 0;
+    let previousWasDigit;
+    const unique = new Set();
+    for (const character of value) {
+        const isDigit = character >= "0" && character <= "9";
+        if (isDigit) {
+            digits += 1;
+            letterRun = 0;
+        }
+        else {
+            if (character >= "a" && character <= "z")
+                lowercase += 1;
+            else
+                uppercase += 1;
+            letterRun += 1;
+            longestLetterRun = Math.max(longestLetterRun, letterRun);
+        }
+        if (previousWasDigit !== undefined && previousWasDigit !== isDigit)
+            transitions += 1;
+        previousWasDigit = isDigit;
+        unique.add(character);
+    }
+    return lowercase >= 2
+        && uppercase >= 2
+        && digits >= 2
+        && transitions >= 4
+        && longestLetterRun <= 5
+        && unique.size >= 12;
+}
+function mergeOverlappingSpans(spans) {
+    const sorted = [...spans].sort((left, right) => (left.start - right.start
+        || right.end - left.end
+        || right.priority - left.priority));
+    const merged = [];
+    for (const span of sorted) {
+        const previous = merged.at(-1);
+        if (!previous || span.start >= previous.end) {
+            merged.push({ ...span });
+            continue;
+        }
+        previous.end = Math.max(previous.end, span.end);
+    }
+    return merged;
+}

package/lib/memorax-code-backend/dist/{memory-reminder-trace-recorder.js → memory/reminder-trace-recorder.js}

@@ -1,6 +1,6 @@
-import { parseSkillReminderCommand, } from "./memory-hook-command.js";
-import { traceContextFromClaudeHookBody, traceContextFromHookBody, } from "./trace-context.js";
-import { recordTraceEvent } from "./trace-store.js";
+import { parseSkillReminderCommand, } from "./hook-command.js";
+import { traceContextFromClaudeHookBody, traceContextFromDshSkillReminder, traceContextFromHookBody, traceContextFromOpenCodeHookBody, } from "../trace/context.js";
+import { recordTraceEvent } from "../trace/store.js";
 export function createMemoryReminderTraceRecorder(options = {}) {
     return {
         async recordSkillReminder(body) {
@@ -18,21 +18,21 @@ export function createMemoryReminderTraceRecorder(options = {}) {
                 env: options.env,
                 traceContext,
                 type: "skill_reminder",
-                source: request.client === "codex" ? "codex-hook" : "claude-hook",
+                source: reminderSource(request),
                 operation: "reminder",
                 ok: true,
                 request: {
                     triggers: request.triggers,
                 },
                 response: {
-                    role: "developer",
+                    role: request.client === "dsh" ? "user" : "developer",
                     content: request.content,
                 },
             }), options.diagnosticLogger);
             options.diagnosticLogger?.("memory_hook.skill_reminder", {
                 client: request.client,
                 sessionId: request.sessionId,
-                turnId: request.client === "codex" ? request.turnId : request.promptId,
+                turnId: traceContext?.turnId,
                 triggers: request.triggers,
                 contentChars: request.content.length,
             });
@@ -43,7 +43,20 @@ export function createMemoryReminderTraceRecorder(options = {}) {
 function traceContextForReminder(command) {
     if (command.client === "codex")
         return traceContextFromHookBody(command);
-    return traceContextFromClaudeHookBody(command);
+    if (command.client === "claude-code")
+        return traceContextFromClaudeHookBody(command);
+    if (command.client === "dsh")
+        return traceContextFromDshSkillReminder(command);
+    return traceContextFromOpenCodeHookBody(command);
+}
+function reminderSource(command) {
+    if (command.client === "codex")
+        return "codex-hook";
+    if (command.client === "claude-code")
+        return "claude-hook";
+    if (command.client === "dsh")
+        return "dsh-cordis";
+    return "opencode-plugin";
 }
 async function recordTraceBestEffort(label, promise, diagnosticLogger) {
     try {

package/lib/memorax-code-backend/dist/{repository-memory-context.js → memory/repository-session.js}

@@ -1,5 +1,5 @@
-import { memoraxConfigFromEnv, } from "./memorax-config.js";
-import { repositoryMemoryScopeCanUpgradeFromDegradedGit, repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, resolveRepositoryMemoryScope, } from "./repository-memory-scope.js";
+import { memoraxConfigFromEnv, } from "../provider/memorax/config.js";
+import { repositoryMemoryScopeCanUpgradeFromDegradedGit, repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, resolveRepositoryMemoryScope, } from "../repository/scope.js";
 export function resolvedRepoMemoryWorktree(result) {
     if (!result.ok || !result.memory.scope)
         return undefined;

package/lib/memorax-code-backend/dist/{memory-service.js → memory/service.js}

@@ -1,8 +1,10 @@
-import { createAutomaticMemoryWritebackRuntime } from "./automatic-memory-writeback.js";
-import { createCodexMemoryHookRuntime, } from "./codex-memory-hook-runtime.js";
-import { createClaudeMemoryHookRuntime, } from "./claude-memory-hook-runtime.js";
-import { createMemoryTurnCoordinator } from "./memory-turn-coordinator.js";
-import { createRepositoryMemorySessionRuntime, } from "./repository-memory-context.js";
+import { createAutomaticMemoryWritebackRuntime } from "./automatic-writeback.js";
+import { createCodexMemoryHookRuntime, } from "../clients/codex/memory-hook-runtime.js";
+import { createClaudeMemoryHookRuntime, } from "../clients/claude/memory-hook-runtime.js";
+import { createDshMemoryHookRuntime, } from "../clients/dsh/memory-hook-runtime.js";
+import { createOpenCodeMemoryHookRuntime, } from "../clients/opencode/memory-hook-runtime.js";
+import { createMemoryTurnCoordinator } from "./turn-coordinator.js";
+import { createRepositoryMemorySessionRuntime, } from "./repository-session.js";
 export function createMemoryService(options = {}) {
     const automaticWriteback = createAutomaticMemoryWritebackRuntime({
         diagnosticLogger: options.diagnosticLogger,
@@ -27,6 +29,16 @@ export function createMemoryService(options = {}) {
         repositoryMemorySession,
         turnCoordinator,
     });
+    const openCodeHook = createOpenCodeMemoryHookRuntime({
+        ...options,
+        repositoryMemorySession,
+        turnCoordinator,
+    });
+    const dshHook = createDshMemoryHookRuntime({
+        ...options,
+        repositoryMemorySession,
+        turnCoordinator,
+    });
     let closed = false;
     return {
         async recordTurnStart(command) {
@@ -35,6 +47,10 @@ export function createMemoryService(options = {}) {
                     return await codexHook.recordTurnStart(command);
                 case "claude-code":
                     return await claudeHook.recordTurnStart(command);
+                case "opencode":
+                    return await openCodeHook.recordTurnStart(command);
+                case "dsh":
+                    return await dshHook.recordTurnStart(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -44,6 +60,10 @@ export function createMemoryService(options = {}) {
                     return await codexHook.writeback(command);
                 case "claude-code":
                     return await claudeHook.writeback(command);
+                case "opencode":
+                    return await openCodeHook.writeback(command);
+                case "dsh":
+                    return await dshHook.writeback(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -56,6 +76,8 @@ export function createMemoryService(options = {}) {
             closed = true;
             codexHook.close();
             claudeHook.close();
+            openCodeHook.close();
+            dshHook.close();
             turnCoordinator.close();
             repositoryMemorySession.close();
             automaticWriteback.close();

package/lib/memorax-code-backend/dist/{memory-turn-coordinator.js → memory/turn-coordinator.js}

@@ -1,4 +1,4 @@
-import { repositoryMemoryScopeCanUpgradeFromDegradedGit, repositoryMemoryScopesMatch, } from "./repository-memory-scope.js";
+import { repositoryMemoryScopeCanUpgradeFromDegradedGit, repositoryMemoryScopesMatch, } from "../repository/scope.js";
 const DEFAULT_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_MAX_ENTRIES = 256;
 const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000;
@@ -19,6 +19,7 @@ export function createMemoryTurnCoordinator(options) {
                 cwd: input.cwd,
                 workspaceKind: input.workspaceKind,
                 transcriptPath: input.transcriptPath,
+                eventStartSeq: input.eventStartSeq,
                 createdAt: input.createdAt,
                 sessionTurnIndex: input.sessionTurnIndex,
                 traceContext: input.traceContext,

package/lib/memorax-code-backend/dist/{memory-writeback-buffer.js → memory/writeback-buffer.js}

@@ -1,6 +1,6 @@
-import { writebackMessagesContentChars } from "./memory-writeback-chunk.js";
-import { memoryWritebackBufferConfig } from "./memorax-config.js";
-import { repositoryMemoryScopeCanUpgradeFromDegradedGit, } from "./repository-memory-scope.js";
+import { writebackMessagesContentChars } from "./writeback-chunk.js";
+import { memoryWritebackBufferConfig } from "../provider/memorax/config.js";
+import { repositoryMemoryScopeCanUpgradeFromDegradedGit, } from "../repository/scope.js";
 const SYSTEM_CLOCK = {
     now: () => Date.now(),
     setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),

package/lib/memorax-code-backend/dist/{memory-writeback-chunk.js → memory/writeback-chunk.js}

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { memoryWritebackChunkConfig, memoryWritebackChunkEnabled, } from "./memorax-config.js";
+import { memoryWritebackChunkConfig, memoryWritebackChunkEnabled, } from "../provider/memorax/config.js";
 const CODE_CHUNK_GROUP_ID_PREFIX = "memory-writeback-chunk:v1:";
 export function memoryWritebackAddParts(decision, env) {
     if (!memoryWritebackChunkEnabled(env)) {

package/lib/memorax-code-backend/dist/{memory-writeback-reconciler.js → memory/writeback-reconciler.js}

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { backendDebug } from "./debug-log.js";
-import { callMemoAddStatus, memoraxConfigFromEnv } from "./memorax-adapter.js";
-import { MEMORAX_PROVIDER_ID, memoraxWritebackEnabled } from "./memorax-config.js";
-import { completeMemoryWritebackTask, createMemoryWritebackTaskProjection, } from "./memory-writeback-task-projection.js";
-import { clientTraceConfigFromEnv } from "./trace-config.js";
-import { recordTraceEvent } from "./trace-store.js";
+import { backendDebug } from "../shared/debug-log.js";
+import { callMemoAddStatus, memoraxConfigFromEnv } from "../provider/memorax/adapter.js";
+import { MEMORAX_PROVIDER_ID, memoraxWritebackEnabled } from "../provider/memorax/config.js";
+import { completeMemoryWritebackTask, createMemoryWritebackTaskProjection, } from "./writeback-task-projection.js";
+import { clientTraceConfigFromEnv } from "../trace/config.js";
+import { recordTraceEvent } from "../trace/store.js";
 const DEFAULT_INTERVAL_MS = 60_000;
 const DEFAULT_MAX_TASKS_PER_RUN = 20;
 const DEFAULT_CONCURRENCY = 4;

package/lib/memorax-code-backend/dist/{memory-writeback-task-projection.js → memory/writeback-task-projection.js}

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { readIncrementalJsonlProjection, } from "./incremental-jsonl-projection.js";
-import { memoryProjectFromUnknown, resolveMemoryProject, } from "./memory-project.js";
-import { clientTracePaths } from "./trace-config.js";
-import { isTraceClient, } from "./trace-context.js";
+import { readIncrementalJsonlProjection, } from "../shared/incremental-jsonl-projection.js";
+import { memoryProjectFromUnknown, resolveMemoryProject, } from "./project.js";
+import { clientTracePaths } from "../trace/config.js";
+import { isTraceClient, } from "../trace/context.js";
 const LIVE_TASK_CAPACITY = 1_024;
 const PENDING_WRITEBACK_STATUSES = new Set([
     "accepted",

package/lib/memorax-code-backend/dist/{memorax-adapter.js → provider/memorax/adapter.js}

@@ -1,14 +1,14 @@
-import { MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, MEMORAX_PROVIDER_ID, clampInteger, memoraxAddOptionsFromContext, memoraxConfigFromEnv, parseScore, } from "./memorax-config.js";
-import { getMemoraxJson, memoraxInvocationFailure, postMemoraxJson, } from "./memorax-http.js";
-import { repositoryMemoryScopeKind, } from "./repository-memory-scope.js";
-import { isRecord } from "./utils.js";
+import { MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, MEMORAX_PROVIDER_ID, clampInteger, memoraxAddOptionsFromContext, memoraxConfigFromEnv, parseScore, } from "./config.js";
+import { getMemoraxJson, memoraxInvocationFailure, postMemoraxJson, } from "./http.js";
+import { repositoryMemoryScopeKind, } from "../../repository/scope.js";
+import { isRecord } from "../../shared/record.js";
 const SLOT_RESULT_SCHEMA_VERSION = "slot-invocation-result.preview.v1";
 const FORWARDED_WRITEBACK_METADATA_KEYS = [
     "memorax_code_memory_reason",
     "memory_type",
     "source_detail",
 ];
-export { memoraxConfigFromEnv } from "./memorax-config.js";
+export { memoraxConfigFromEnv } from "./config.js";
 export async function invokeMemoraxMemoryProvider(run, request, options = {}) {
     const configResult = options.config ? { ok: true, config: options.config } : memoraxConfigFromEnv(options.env);
     if (!configResult.ok)

package/lib/memorax-code-backend/dist/{memorax-config.js → provider/memorax/config.js}

@@ -1,7 +1,7 @@
-import { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, normalizeMemoraxBaseUrl, normalizeMemoraxMemoryOutputLanguage, } from "../../memorax-code-adapter-common/src/memorax-defaults.mjs";
-import { defaultMemoraxCodeHome, loadMemoraxCodeConfig, } from "./memorax-code-config.js";
-export { defaultMemoraxCodeHome, memoraxCodeConfigPath, loadMemoraxCodeConfig } from "./memorax-code-config.js";
-export { seedMissingMemoraxCodeConfig } from "./memorax-code-config.js";
+import { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, normalizeMemoraxBaseUrl, normalizeMemoraxMemoryOutputLanguage, } from "../../../../memorax-code-adapter-common/src/memorax-defaults.mjs";
+import { defaultMemoraxCodeHome, loadMemoraxCodeConfig, } from "../../config/memorax-code.js";
+export { defaultMemoraxCodeHome, memoraxCodeConfigPath, loadMemoraxCodeConfig } from "../../config/memorax-code.js";
+export { seedMissingMemoraxCodeConfig } from "../../config/memorax-code.js";
 export { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE };
 export const MEMORAX_PROVIDER_ID = "memory.memorax";
 export const MEMORAX_DEFAULT_MEMORY_TYPE_ORDER = ["core", "episodic", "semantic", "procedural", "unclassified"];

package/lib/memorax-code-backend/dist/{memorax-http.js → provider/memorax/http.js}

@@ -1,4 +1,4 @@
-import { isRecord } from "./utils.js";
+import { isRecord } from "../../shared/record.js";
 export async function postMemoraxJson(config, path, payload, fetchImpl) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), config.timeoutMs);

package/lib/memorax-code-backend/dist/{repo-memory-readiness.js → repository/readiness.js}

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
-import { memoryProjectRoot } from "./memory-project.js";
+import { memoryProjectRoot } from "../memory/project.js";
 const execFileAsync = promisify(execFile);
 const STABLE_READINESS_CACHE_TTL_MS = 30_000;
 const PREPARING_READINESS_CACHE_TTL_MS = 5_000;
@@ -134,7 +134,7 @@ function releaseBundleValidationSlot() {
     activeBundleValidations -= 1;
 }
 async function readActiveRepoMemoryJob(input) {
-    const moduleUrl = new URL("../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-marker.mjs", import.meta.url);
+    const moduleUrl = new URL("../../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-marker.mjs", import.meta.url);
     const markerModule = await import(moduleUrl.href);
     if (typeof markerModule.readActiveRepoMemoryJobMarker !== "function") {
         throw new Error("repo memory job marker reader is unavailable");
@@ -149,7 +149,7 @@ async function validateRepoMemoryBundle(repoRoot) {
     catch {
         return "missing";
     }
-    const validatorUrl = new URL("../../memorax-code-codex-adapter/skills/memorax-code/scripts/validate_memory.py", import.meta.url);
+    const validatorUrl = new URL("../../../memorax-code-codex-adapter/skills/memorax-code/scripts/validate_memory.py", import.meta.url);
     try {
         await access(validatorUrl, constants.R_OK);
     }