@memorax/memorax-code 0.1.2 → 0.1.4

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

@@ -1,217 +1,8 @@
 #!/usr/bin/env node
-import { createServer, } from "node:http";
-import { isMainEntrypoint } from "./entrypoint.js";
-import { backendDebug } from "./debug-log.js";
-import { createMemoryReminderTraceRecorder } from "./memory-reminder-trace-recorder.js";
-import { handleMemoryViewerRequest } from "./server-memory-viewer.js";
-import { handleMemoryHookRequest } from "./server-memory-hook.js";
-import { createBackendMemoryObservability } from "./server-observability.js";
-import { createMemoryService } from "./memory-service.js";
-import { handleHealthRequest } from "./server-health.js";
-import { authorized, memoryViewerSessionCookieHeader, publicErrorMessage, statusCodeFromError } from "./server-http.js";
-import { json } from "./server-json.js";
-import { createBackendState } from "./backend-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 "./active-client-selection.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 memoryService = createMemoryService({
-        diagnosticLogger: backendDebug,
-        env: memoryEnv,
-        memoraxCodeHome: state.sessionHome,
-        memoryObservability,
-    });
-    const memoryHookDependencies = {
-        memoryService,
-        memoryReminderTraceRecorder: createMemoryReminderTraceRecorder({
-            diagnosticLogger: backendDebug,
-            env: memoryEnv,
-            memoraxCodeHome: state.sessionHome,
-        }),
-    };
-    for (const client of TRACE_CLIENTS) {
-        void pruneExpiredTraceSessionsForClient({
-            client,
-            memoraxCodeHome: state.sessionHome,
-        }).catch((error) => {
-            backendDebug(`${client}_trace.retention_cleanup_failed`, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-    }
-    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", {
-            method: req.method,
-            path: url.pathname,
-        });
-        try {
-            if (req.method === "GET" && url.pathname === "/health")
-                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" });
-        }
-        catch (error) {
-            const status = statusCodeFromError(error);
-            const publicMessage = publicErrorMessage(error);
-            if (status >= 500)
-                console.error("request failed", error);
-            if (res.headersSent) {
-                return res.end();
-            }
-            return json(res, status, { ok: false, error: publicMessage });
-        }
-    };
-    const activeRequests = new Set();
-    const server = createServer((req, res) => {
-        const request = handleRequest(req, res);
-        activeRequests.add(request);
-        void request.then(() => activeRequests.delete(request), () => activeRequests.delete(request));
-    });
-    return attachBackendShutdown(server, {
-        activeRequests,
-        memoryObservability,
-        memoryService,
-        memoryWritebackReconcilers,
-        timeoutMs: positiveShutdownTimeout(options.shutdownTimeoutMs),
-    });
-}
-function attachBackendShutdown(server, resources) {
-    const closeHttpServer = server.close.bind(server);
-    const backendServer = server;
-    let shutdownPromise;
-    backendServer.shutdown = () => {
-        shutdownPromise ??= shutdownBackend(backendServer, closeHttpServer, resources);
-        return shutdownPromise;
-    };
-    backendServer.close = ((callback) => {
-        void backendServer.shutdown().then(() => callback?.(), (error) => callback?.(error instanceof Error ? error : new Error(String(error))));
-        return backendServer;
-    });
-    return backendServer;
-}
-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);
-        if (Date.now() < deadline) {
-            await waitForShutdownPhase("memory_service", settleShutdownWork("memory_service", resources.memoryService.drain()), deadline);
-        }
-        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();
-    }
-}
-function closeBackendHttpServer(server, closeHttpServer, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const forceTimer = setTimeout(() => {
-            backendDebug("shutdown.http_connections_forced", { timeoutMs });
-            try {
-                server.closeAllConnections();
-            }
-            catch (error) {
-                backendDebug("shutdown.http_connections_force_failed", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }, timeoutMs);
-        const done = (error) => {
-            clearTimeout(forceTimer);
-            if (error && error.code !== "ERR_SERVER_NOT_RUNNING") {
-                reject(error);
-                return;
-            }
-            resolve();
-        };
-        try {
-            closeHttpServer(done);
-            server.closeIdleConnections();
-        }
-        catch (error) {
-            done(error instanceof Error ? error : new Error(String(error)));
-        }
-    });
-}
-async function waitForActiveRequests(activeRequests) {
-    while (activeRequests.size > 0) {
-        await Promise.allSettled([...activeRequests]);
-    }
-}
-async function waitForShutdownPhase(phase, work, deadline) {
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-        backendDebug("shutdown.phase_timed_out", { phase, remainingMs: 0 });
-        return false;
-    }
-    let timer;
-    const result = await Promise.race([
-        work.then(() => ({ completed: true }), (error) => ({ completed: true, error })),
-        new Promise((resolve) => {
-            timer = setTimeout(() => resolve({ completed: false }), remainingMs);
-        }),
-    ]);
-    if (timer)
-        clearTimeout(timer);
-    if (!result.completed) {
-        backendDebug("shutdown.phase_timed_out", { phase, remainingMs });
-        return false;
-    }
-    if ("error" in result)
-        throw result.error;
-    return true;
-}
-async function settleShutdownWork(label, work) {
-    try {
-        await work;
-    }
-    catch (error) {
-        backendDebug("shutdown.work_failed", {
-            label,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-function positiveShutdownTimeout(value) {
-    if (typeof value === "number" && Number.isSafeInteger(value) && value > 0)
-        return value;
-    return DEFAULT_BACKEND_SHUTDOWN_TIMEOUT_MS;
-}
+import { isMainEntrypoint } from "./entrypoints/main.js";
+export { createBackendServer } from "./app/backend-server.js";
 if (isMainEntrypoint(import.meta.url)) {
-    import("./server-cli.js")
+    import("./entrypoints/backend-cli.js")
         .then(({ runBackendCli }) => runBackendCli(process.argv))
         .catch((error) => {
         console.error(error instanceof Error ? error.message : String(error));

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

@@ -1,4 +1,4 @@
-import { runBackendCli } from "./server-cli.js";
+import { runBackendCli } from "./entrypoints/backend-cli.js";
 const markerIndex = process.argv.indexOf("--memorax-code-backend-instance");
 const instanceId = markerIndex >= 0 ? process.argv[markerIndex + 1] : undefined;
 if (!instanceId

package/lib/memorax-code-backend/dist/{debug-log.js → shared/debug-log.js}

@@ -1,4 +1,4 @@
-import { backendEnv } from "./backend-env.js";
+import { backendEnv } from "../config/backend-env.js";
 export function backendDebugEnabled() {
     const value = backendEnv("DEBUG_REQUESTS");
     return value === "1" || value === "true" || value === "yes";

package/lib/memorax-code-backend/dist/shared/jsonl-append.js

@@ -0,0 +1,75 @@
+import { open } from "node:fs/promises";
+const JSONL_TAIL_SCAN_CHUNK_BYTES = 8 * 1024;
+const pathOperations = new Map();
+export async function appendRepairingJsonl(path, text) {
+    await serializePath(path, async () => {
+        const handle = await open(path, "a+", 0o600);
+        try {
+            const { rollbackSize, separator } = await prepareTailForAppend(handle);
+            try {
+                await handle.writeFile(`${separator}${text}`, "utf8");
+            }
+            catch (error) {
+                await handle.truncate(rollbackSize).catch(() => undefined);
+                throw error;
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    });
+}
+async function serializePath(path, operation) {
+    const previous = pathOperations.get(path) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(operation);
+    pathOperations.set(path, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (pathOperations.get(path) === current)
+            pathOperations.delete(path);
+    }
+}
+async function prepareTailForAppend(handle) {
+    const size = (await handle.stat()).size;
+    if (size === 0)
+        return { rollbackSize: 0, separator: "" };
+    const lastByte = Buffer.allocUnsafe(1);
+    await readExactAt(handle, lastByte, size - 1);
+    if (lastByte[0] === 0x0a)
+        return { rollbackSize: size, separator: "" };
+    const tailStart = await jsonlTailStart(handle, size);
+    const tail = Buffer.allocUnsafe(size - tailStart);
+    await readExactAt(handle, tail, tailStart);
+    try {
+        JSON.parse(tail.toString("utf8"));
+        return { rollbackSize: size, separator: "\n" };
+    }
+    catch {
+        await handle.truncate(tailStart);
+        return { rollbackSize: tailStart, separator: "" };
+    }
+}
+async function jsonlTailStart(handle, size) {
+    let end = size;
+    while (end > 0) {
+        const start = Math.max(0, end - JSONL_TAIL_SCAN_CHUNK_BYTES);
+        const buffer = Buffer.allocUnsafe(end - start);
+        await readExactAt(handle, buffer, start);
+        const newline = buffer.lastIndexOf(0x0a);
+        if (newline >= 0)
+            return start + newline + 1;
+        end = start;
+    }
+    return 0;
+}
+async function readExactAt(handle, buffer, position) {
+    let offset = 0;
+    while (offset < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
+        if (bytesRead === 0)
+            throw new Error("failed to read JSONL tail");
+        offset += bytesRead;
+    }
+}

package/lib/memorax-code-backend/dist/shared/windows-cli-invocation.js

@@ -0,0 +1,148 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+export function resolveWindowsCliInvocation(command, args, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "win32")
+        return { command, args };
+    const pathApi = path.win32;
+    const fileExists = options.existsSync ?? existsSync;
+    const env = options.env ?? process.env;
+    let resolvedCommand = options.resolvedCommand;
+    if (!resolvedCommand && !/[\\/]/.test(command)) {
+        const located = options.whereOutput === undefined
+            ? (options.spawnSync ?? spawnSync)("where.exe", [command], {
+                env,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            })
+            : { status: 0, stdout: options.whereOutput };
+        if (located.status === 0) {
+            resolvedCommand = selectWindowsCommandCandidate(command, located.stdout);
+        }
+    }
+    resolvedCommand ??= command;
+    if (/\.(?:exe|com)$/i.test(resolvedCommand))
+        return { command: resolvedCommand, args };
+    if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
+        throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
+    }
+    const name = pathApi.basename(resolvedCommand).replace(/\.(?:cmd|bat)$/i, "").toLowerCase();
+    const nativeCli = nativeCliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+        .filter(isNativeEntrypoint)
+        .find((candidate) => fileExists(candidate));
+    if (nativeCli)
+        return { command: nativeCli, args };
+    const cli = cliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+        .filter(isNodeEntrypoint)
+        .find((candidate) => fileExists(candidate));
+    if (!cli) {
+        const override = name === "claude" ? "MEMORAX_CODE_CLAUDE_CLI_JS" : "MEMORAX_CODE_CODEX_CLI_JS";
+        throw new Error(`refusing to execute ${pathApi.basename(resolvedCommand)} through a command shell; `
+            + `set ${override} to its Node entrypoint`);
+    }
+    return { command: options.nodePath ?? process.execPath, args: [cli, ...args] };
+}
+function nativeCliEntrypointCandidates(name, command, env, pathApi) {
+    if (name !== "claude")
+        return [];
+    const root = pathApi.dirname(command);
+    return [
+        env.MEMORAX_CODE_CLAUDE_CLI_EXE,
+        env.CLAUDE_CLI_EXE,
+        pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+        pathApi.join(root, "..", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+    ].filter((candidate) => typeof candidate === "string");
+}
+function cliEntrypointCandidates(name, command, env, pathApi) {
+    const root = pathApi.dirname(command);
+    if (name === "codex") {
+        return [
+            env.MEMORAX_CODE_CODEX_CLI_JS,
+            env.CODEX_CLI_JS,
+            pathApi.join(root, "node_modules", "@openai", "codex", "bin", "codex.js"),
+            pathApi.join(root, "..", "@openai", "codex", "bin", "codex.js"),
+        ].filter((candidate) => typeof candidate === "string");
+    }
+    if (name === "claude") {
+        return [
+            env.MEMORAX_CODE_CLAUDE_CLI_JS,
+            env.CLAUDE_CLI_JS,
+            pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+            pathApi.join(root, "..", "@anthropic-ai", "claude-code", "cli.js"),
+        ].filter((candidate) => typeof candidate === "string");
+    }
+    return [];
+}
+function isNativeEntrypoint(value) {
+    return /\.(?:exe|com)$/i.test(value);
+}
+function isNodeEntrypoint(value) {
+    return /\.(?:cjs|js|mjs)$/i.test(value);
+}
+export function selectWindowsCommandCandidate(command, output) {
+    const candidates = String(output ?? "")
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .filter(Boolean);
+    const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
+        ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+    if (!selected) {
+        throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
+    }
+    return selected;
+}
+export function resolveWindowsNpmInvocation(args, env, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "win32")
+        return { command: "npm", args };
+    const nodePath = options.nodePath ?? process.execPath;
+    const fileExists = options.existsSync ?? existsSync;
+    const candidates = [
+        env.MEMORAX_CODE_NPM_EXEC_PATH,
+        env.npm_execpath,
+        env.NPM_CLI_JS,
+        path.win32.join(path.win32.dirname(nodePath), "node_modules", "npm", "bin", "npm-cli.js"),
+        path.win32.join(path.win32.dirname(path.win32.dirname(nodePath)), "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+    ].filter((candidate) => (typeof candidate === "string" && /\.(?:cjs|js|mjs)$/i.test(candidate)));
+    const npmCli = candidates.find((candidate) => fileExists(candidate));
+    if (!npmCli) {
+        throw new Error("npm CLI JavaScript entrypoint was not found; set MEMORAX_CODE_NPM_EXEC_PATH, "
+            + "npm_execpath, or NPM_CLI_JS");
+    }
+    return { command: nodePath, args: [npmCli, ...args] };
+}
+export function runProcessWithWindowsNpm(command, args, options) {
+    return new Promise((resolveResult) => {
+        let invocation = { command, args };
+        try {
+            if (command === "npm") {
+                invocation = resolveWindowsNpmInvocation(args, options.env);
+            }
+        }
+        catch (error) {
+            resolveResult({
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => { stdout += String(chunk); });
+        child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+        child.on("error", (error) => {
+            resolveResult({ ok: false, stdout, stderr: stderr || error.message });
+        });
+        child.on("close", (code) => {
+            resolveResult({ ok: code === 0, stdout, stderr });
+        });
+    });
+}

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

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { loadMemoraxCodeConfig } from "./memorax-code-config.js";
-import { isTraceClient } from "./trace-context.js";
-export const TRACE_CLIENTS = ["codex", "claude"];
+import { loadMemoraxCodeConfig } from "../config/memorax-code.js";
+import { isTraceClient } from "./context.js";
+export const TRACE_CLIENTS = ["codex", "claude", "dsh", "opencode"];
 export const CODEX_TRACE_DEFAULT_CONFIG = {
     enabled: true,
     captureContent: true,
@@ -18,6 +18,32 @@ export const CLAUDE_TRACE_DEFAULT_CONFIG = {
     maxEventChars: 20_000,
     maxFileBytes: 52_428_800,
 };
+export const DSH_TRACE_DEFAULT_CONFIG = {
+    enabled: true,
+    captureContent: true,
+    retentionDays: 7,
+    maxEventChars: 20_000,
+    maxFileBytes: 52_428_800,
+};
+export const OPENCODE_TRACE_DEFAULT_CONFIG = {
+    enabled: true,
+    captureContent: true,
+    retentionDays: 7,
+    maxEventChars: 20_000,
+    maxFileBytes: 52_428_800,
+};
+const TRACE_DEFAULT_CONFIGS = {
+    codex: CODEX_TRACE_DEFAULT_CONFIG,
+    claude: CLAUDE_TRACE_DEFAULT_CONFIG,
+    dsh: DSH_TRACE_DEFAULT_CONFIG,
+    opencode: OPENCODE_TRACE_DEFAULT_CONFIG,
+};
+const TRACE_ENV_PREFIXES = {
+    codex: "MEMORAX_CODE_CODEX_TRACE",
+    claude: "MEMORAX_CODE_CLAUDE_TRACE",
+    dsh: "MEMORAX_CODE_DSH_TRACE",
+    opencode: "MEMORAX_CODE_OPENCODE_TRACE",
+};
 export const TRACE_CLEANUP_DEBOUNCE_MS = 60 * 60 * 1000;
 export const TRACE_CURRENT_TURN_TTL_MS = 30 * 60 * 1000;
 export const CODEX_TRACE_CLEANUP_DEBOUNCE_MS = TRACE_CLEANUP_DEBOUNCE_MS;
@@ -30,12 +56,18 @@ export function codexTraceConfigFromEnv(env = process.env, fileConfig) {
 export function claudeTraceConfigFromEnv(env = process.env, fileConfig) {
     return clientTraceConfigFromEnv("claude", env, fileConfig);
 }
+export function dshTraceConfigFromEnv(env = process.env, fileConfig) {
+    return clientTraceConfigFromEnv("dsh", env, fileConfig);
+}
+export function openCodeTraceConfigFromEnv(env = process.env, fileConfig) {
+    return clientTraceConfigFromEnv("opencode", env, fileConfig);
+}
 export function clientTraceConfigFromEnv(client, env = process.env, fileConfig) {
     assertTraceClient(client);
     const config = fileConfig ?? loadMemoraxCodeConfig(memoraxCodeHomeForTrace(env), { warn: () => undefined });
     const section = config.trace?.[client];
-    const defaults = client === "claude" ? CLAUDE_TRACE_DEFAULT_CONFIG : CODEX_TRACE_DEFAULT_CONFIG;
-    const prefix = client === "claude" ? "MEMORAX_CODE_CLAUDE_TRACE" : "MEMORAX_CODE_CODEX_TRACE";
+    const defaults = TRACE_DEFAULT_CONFIGS[client];
+    const prefix = TRACE_ENV_PREFIXES[client];
     return {
         enabled: booleanValue(env[`${prefix}_ENABLED`], section?.enabled ?? defaults.enabled),
         captureContent: booleanValue(env[`${prefix}_CAPTURE_CONTENT`], section?.capture_content ?? defaults.captureContent),
@@ -53,6 +85,12 @@ export function tracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env
 export function claudeTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     return clientTracePaths("claude", memoraxCodeHome);
 }
+export function dshTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
+    return clientTracePaths("dsh", memoraxCodeHome);
+}
+export function openCodeTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
+    return clientTracePaths("opencode", memoraxCodeHome);
+}
 export function clientTracePaths(client, memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     assertTraceClient(client);
     const root = join(memoraxCodeHome, "debug", "traces", client);

package/lib/memorax-code-backend/dist/{trace-context.js → trace/context.js}

@@ -1,4 +1,4 @@
-import { memoryProjectFromUnknown, resolveMemoryProject, } from "./memory-project.js";
+import { memoryProjectFromUnknown, resolveMemoryProject, } from "../memory/project.js";
 export function traceContextFromHookBody(body, capturedAt = new Date().toISOString()) {
     if (!isRecord(body))
         return undefined;
@@ -42,6 +42,35 @@ export function traceContextFromClaudeHookBody(body, capturedAt = new Date().toI
         capturedAt,
     });
 }
+export function traceContextFromOpenCodeHookBody(body, capturedAt = new Date().toISOString()) {
+    if (!isRecord(body))
+        return undefined;
+    const sessionId = stringField(body, "sessionId");
+    const turnId = stringField(body, "userMessageId");
+    if (!sessionId || !turnId)
+        return undefined;
+    const cwd = stringField(body, "cwd");
+    return pruneTraceContext({
+        schemaVersion: "1",
+        client: "opencode",
+        sessionId,
+        turnId,
+        cwd,
+        memoryProject: resolveMemoryProject(cwd),
+        workspaceKind: stringField(body, "workspaceKind"),
+        contextOrigin: "opencode-hook-body",
+        capturedAt,
+    });
+}
+export function traceContextFromDshTurnStart(body, capturedAt = new Date().toISOString()) {
+    return traceContextFromDshBody(body, "dsh-cordis-turn-start", capturedAt);
+}
+export function traceContextFromDshSkillReminder(body, capturedAt = new Date().toISOString()) {
+    return traceContextFromDshBody(body, "dsh-cordis-reminder", capturedAt);
+}
+export function traceContextFromDshSessionEventLog(body, capturedAt = new Date().toISOString()) {
+    return traceContextFromDshBody(body, "dsh-session-event-log", capturedAt);
+}
 export function traceContextFromCurrentTurnRecord(value) {
     if (!isRecord(value))
         return undefined;
@@ -100,7 +129,29 @@ function pruneRecord(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
 }
 export function isTraceClient(value) {
-    return value === "codex" || value === "claude";
+    return value === "codex" || value === "claude" || value === "dsh" || value === "opencode";
+}
+function traceContextFromDshBody(body, contextOrigin, capturedAt) {
+    if (!isRecord(body))
+        return undefined;
+    const sessionId = stringField(body, "session_id") ?? stringField(body, "sessionId");
+    const turn = body.turn;
+    if (!sessionId || typeof turn !== "number" || !Number.isSafeInteger(turn) || turn <= 0) {
+        return undefined;
+    }
+    const cwd = stringField(body, "cwd");
+    if (!cwd)
+        return undefined;
+    return pruneTraceContext({
+        schemaVersion: "1",
+        client: "dsh",
+        sessionId,
+        turnId: String(turn),
+        cwd,
+        memoryProject: resolveMemoryProject(cwd),
+        contextOrigin,
+        capturedAt,
+    });
 }
 function stringField(record, key) {
     const value = record[key];

package/lib/memorax-code-backend/dist/{trace-store.js → trace/store.js}

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { TRACE_CLEANUP_DEBOUNCE_MS, TRACE_CURRENT_TURN_TTL_MS, clientTraceConfigFromEnv, clientTracePaths, memoraxCodeHomeForTrace, } from "./trace-config.js";
-import { isTraceClient, traceContextFromCurrentTurnRecord, traceContextJson, } from "./trace-context.js";
-import { appendRepairingJsonl } from "./jsonl-append.js";
+import { TRACE_CLEANUP_DEBOUNCE_MS, TRACE_CURRENT_TURN_TTL_MS, clientTraceConfigFromEnv, clientTracePaths, memoraxCodeHomeForTrace, } from "./config.js";
+import { isTraceClient, traceContextFromCurrentTurnRecord, traceContextJson, } from "./context.js";
+import { appendRepairingJsonl } from "../shared/jsonl-append.js";
 const eventCounters = new Map();
 const lastCleanupByRoot = new Map();
 const currentTurnPathOperations = new Map();

package/lib/memorax-code-backend/dist/{server-health.js → transport/http/health.js}

@@ -1,4 +1,4 @@
-import { json } from "./server-json.js";
+import { json } from "./json.js";
 export function handleHealthRequest(state, res) {
     return json(res, 200, {
         ok: true,

package/lib/memorax-code-backend/dist/{server-memory-hook.js → transport/http/memory-hook.js}

@@ -1,6 +1,6 @@
-import { parseTurnStartCommand, parseWritebackCommand, } from "./memory-hook-command.js";
-import { readJson } from "./server-http.js";
-import { json } from "./server-json.js";
+import { parseTurnStartCommand, parseWritebackCommand, } from "../../memory/hook-command.js";
+import { readJson } from "./request.js";
+import { json } from "./json.js";
 export async function handleMemoryHookRequest(dependencies, url, req, res) {
     if (req.method !== "POST")
         return false;

package/lib/memorax-code-backend/dist/{server-http.js → transport/http/request.js}

@@ -1,4 +1,4 @@
-import { backendEnv } from "./backend-env.js";
+import { backendEnv } from "../../config/backend-env.js";
 const DEFAULT_MAX_JSON_BODY_BYTES = 16 * 1024 * 1024;
 const MEMORY_VIEWER_SESSION_COOKIE = "memorax_code_memory_viewer_session";
 export class HttpRequestError extends Error {

package/lib/memorax-code-backend/dist/{claude-local-transcript.js → viewer/history/claude-transcript.js}

@@ -2,9 +2,9 @@ import { createHash } from "node:crypto";
 import { open, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join, resolve as resolvePath } from "node:path";
-import { memoryViewerEventKey } from "./memory-viewer-event-identity.js";
-import { claudeTranscriptMemoryActivitiesFromJsonLines } from "./claude-transcript-turn.js";
-import { resolveMemoryProject, } from "./memory-project.js";
+import { memoryViewerEventKey } from "../projection/event-identity.js";
+import { claudeTranscriptMemoryActivitiesFromJsonLines } from "../../clients/claude/transcript-turn.js";
+import { resolveMemoryProject, } from "../../memory/project.js";
 const projections = new Map();
 const EMPTY_TRANSCRIPT_HISTORY = Object.freeze([]);
 const MAX_TRANSCRIPT_FILES = 250;

package/lib/memorax-code-backend/dist/{memory-viewer-session-title.js → viewer/history/session-title.js}

@@ -1,4 +1,4 @@
-import { redactViewerPaths } from "./memory-viewer-redaction.js";
+import { redactViewerPaths } from "../projection/redaction.js";
 const MAX_SESSION_TITLE_LENGTH = 120;
 const COMMON_RELATIVE_PATH_ROOTS = new Set([
     "app",