@memorax/memorax-code 0.1.1 → 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,12 +1,23 @@
-import { memoraxConfigFromEnv, } from "./memorax-config.js";
-import { 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;
+    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/{memory-service.js → memory/service.js}

@@ -1,13 +1,17 @@
-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,
     });
-    const repositoryMemorySession = createRepositoryMemorySessionRuntime();
+    const repositoryMemorySession = createRepositoryMemorySessionRuntime({
+        onScopeUpgrade: automaticWriteback.discardForScopeUpgrade,
+    });
     const turnCoordinator = createMemoryTurnCoordinator({
         automaticWriteback: automaticWriteback.enqueue,
         now: options.now,
@@ -25,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) {
@@ -33,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);
         },
@@ -42,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);
         },
@@ -54,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 { 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,
@@ -72,10 +73,13 @@ export function createMemoryTurnCoordinator(options) {
             if (!currentScope) {
                 return reject(input.metadata ? "workspace_scope_mismatch" : "workspace_scope_unavailable");
             }
-            const repositoryScope = input.metadata?.repositoryScope ?? currentScope;
+            let repositoryScope = input.metadata?.repositoryScope ?? currentScope;
             if (input.metadata?.repositoryScope
                 && !repositoryMemoryScopesMatch(input.metadata.repositoryScope, currentScope)) {
-                return reject("workspace_scope_mismatch");
+                if (!repositoryMemoryScopeCanUpgradeFromDegradedGit(input.metadata.repositoryScope, currentScope)) {
+                    return reject("workspace_scope_mismatch");
+                }
+                repositoryScope = currentScope;
             }
             const acceptance = options.automaticWriteback({
                 ...input.writeback,

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

@@ -1,5 +1,6 @@
-import { writebackMessagesContentChars } from "./memory-writeback-chunk.js";
-import { memoryWritebackBufferConfig } from "./memorax-config.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),
@@ -11,6 +12,9 @@ export function createMemoryWritebackBufferRuntime() {
         enqueue(decision, options, deps) {
             enqueueMemoryWritebackBufferForRuntime(writebackBuffers, decision, options, deps);
         },
+        discardForScopeUpgrade(upgrade) {
+            return discardDegradedGitBuffersForUpgrade(writebackBuffers, upgrade);
+        },
         flushAll(flushReason) {
             let flushed = 0;
             for (const [bufferKey, buffer] of [...writebackBuffers.entries()]) {
@@ -34,6 +38,11 @@ function enqueueMemoryWritebackBufferForRuntime(writebackBuffers, decision, opti
     const config = memoryWritebackBufferConfig(env);
     if (!options.repositoryScope)
         return;
+    discardDegradedGitBuffersForUpgrade(writebackBuffers, {
+        client: decision.client,
+        sessionKey: decision.sessionKey,
+        currentScope: options.repositoryScope,
+    });
     const bufferKey = memoryWritebackBufferKey(decision.client, decision.sessionKey, options.repositoryScope);
     let buffer = writebackBuffers.get(bufferKey);
     if (buffer?.turnKeys.has(decision.idempotencyKey)) {
@@ -85,6 +94,26 @@ function enqueueMemoryWritebackBufferForRuntime(writebackBuffers, decision, opti
         resetMemoryWritebackIdleTimer(writebackBuffers, buffer, config.maxAgeMs, deps);
     }
 }
+function discardDegradedGitBuffersForUpgrade(writebackBuffers, upgrade) {
+    let discarded = 0;
+    for (const [bufferKey, buffer] of writebackBuffers.entries()) {
+        if (buffer.client !== upgrade.client
+            || buffer.sessionKey !== upgrade.sessionKey
+            || !repositoryMemoryScopeCanUpgradeFromDegradedGit(buffer.repositoryScope, upgrade.currentScope))
+            continue;
+        writebackBuffers.delete(bufferKey);
+        if (buffer.timer)
+            buffer.clock.clearTimeout(buffer.timer);
+        buffer.deps.debug("memory.automatic_writeback", {
+            scheduled: false,
+            skipReason: "buffer_scope_upgraded",
+            sessionKey: upgrade.sessionKey,
+            discardedTurnCount: buffer.turns.length,
+        });
+        discarded += 1;
+    }
+    return discarded;
+}
 function createMemoryWritebackBuffer(bufferKey, client, sessionKey, env, options, repositoryScope, clock, deps) {
     const now = clock.now();
     const buffer = {

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);
     }