@memorax/memorax-code 0.1.1 → 0.1.3

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",

package/lib/memorax-code-backend/dist/{server-memory-viewer.js → viewer/http/public-routes.js}

@@ -1,19 +1,21 @@
 import { createHash } from "node:crypto";
-import { isMemoryProjectId, UNCLASSIFIED_PROJECT_ID } from "./memory-project.js";
-import { MEMORAX_LOGO_DATA_URL } from "./memory-viewer-logo.js";
-import { memoryViewerUserHtml } from "./memory-viewer-user-html.js";
-import { projectMemoryViewerUserData } from "./memory-viewer-user-projection.js";
-import { listMemoryViewerDataWithHistory, } from "./memory-viewer-store.js";
-import { repoMemoryReadinessForProject, } from "./repo-memory-readiness.js";
-import { json } from "./server-json.js";
-import { memoraxCodeHomeForTrace } from "./trace-config.js";
+import { MEMORAX_ICON_DATA_URL } from "../ui/icon.js";
+import { isMemoryProjectId, UNCLASSIFIED_PROJECT_ID } from "../../memory/project.js";
+import { MEMORAX_LOGO_DATA_URL } from "../ui/logo.js";
+import { memoryViewerUserHtml } from "../ui/user-html.js";
+import { projectMemoryViewerUserData } from "../projection/user.js";
+import { listMemoryViewerDataWithHistory } from "../store.js";
+import { repoMemoryReadinessForProject, } from "../../repository/readiness.js";
+import { json } from "../../transport/http/json.js";
+import { memoraxCodeHomeForTrace } from "../../trace/config.js";
 const MEMORY_VIEWER_SESSION_ACTIVITY_WINDOW_MS = 72 * 60 * 60 * 1_000;
 const MEMORY_VIEWER_ACTIVITY_CUTOFF_GRANULARITY_MS = 60_000;
 const MEMORY_VIEWER_LOGO = Buffer.from(MEMORAX_LOGO_DATA_URL.slice(MEMORAX_LOGO_DATA_URL.indexOf(",") + 1), "base64");
+const MEMORY_VIEWER_ICON = Buffer.from(MEMORAX_ICON_DATA_URL.slice(MEMORAX_ICON_DATA_URL.indexOf(",") + 1), "base64");
 export async function handleMemoryViewerRequest(url, req, res, options = {}) {
     if (req.method === "GET" && url.pathname === "/memory-viewer") {
         if (!memoryViewerUserClient(url)) {
-            json(res, 400, { ok: false, error: "client must be codex or claude-code" });
+            json(res, 400, { ok: false, error: "client must be codex, claude-code, dsh, or opencode" });
             return true;
         }
         res.writeHead(200, {
@@ -36,13 +38,22 @@ export async function handleMemoryViewerRequest(url, req, res, options = {}) {
         res.end(MEMORY_VIEWER_LOGO);
         return true;
     }
+    if (req.method === "GET" && url.pathname === "/memory-viewer/favicon.png") {
+        res.writeHead(200, {
+            "content-type": "image/png",
+            "cache-control": "private, max-age=86400",
+            "x-content-type-options": "nosniff",
+        });
+        res.end(MEMORY_VIEWER_ICON);
+        return true;
+    }
     if (req.method !== "GET" || url.pathname !== "/memory-viewer/api/summary") {
         return false;
     }
     const memoraxCodeHome = viewerMemoraxCodeHome(options);
     const selectedClient = memoryViewerUserClient(url);
     if (!selectedClient) {
-        json(res, 400, { ok: false, error: "client must be codex or claude-code" });
+        json(res, 400, { ok: false, error: "client must be codex, claude-code, dsh, or opencode" });
         return true;
     }
     const requestedProject = projectFilter(url);
@@ -66,7 +77,7 @@ export async function handleMemoryViewerRequest(url, req, res, options = {}) {
     conditionalViewerJson(req, res, {
         ok: true,
         selectedClient: selectedClient.publicClient,
-        availableClients: ["codex", "claude-code"],
+        availableClients: ["codex", "claude-code", "dsh", "opencode"],
         summary: projection.summary,
         activities: projection.activities.slice(0, 100),
         projects,
@@ -83,12 +94,12 @@ function memoryViewerUserClient(url) {
     const value = url.searchParams.get("client");
     const traceClient = value === null ? "codex" : traceClientFromPublicValue(value.trim().toLowerCase());
     return traceClient
-        ? { traceClient, publicClient: traceClient === "claude" ? "claude-code" : "codex" }
+        ? { traceClient, publicClient: traceClient === "claude" ? "claude-code" : traceClient }
         : undefined;
 }
 function traceClientFromPublicValue(value) {
-    if (value === "codex")
-        return "codex";
+    if (value === "codex" || value === "dsh" || value === "opencode")
+        return value;
     return value === "claude" || value === "claude-code" || value === "cc"
         ? "claude"
         : undefined;

package/lib/memorax-code-backend/dist/viewer/model.js

@@ -0,0 +1 @@
+export {};

package/lib/memorax-code-backend/dist/{memory-viewer-activity.js → viewer/projection/activity.js}

@@ -1,5 +1,5 @@
-import { UNCLASSIFIED_PROJECT_ID } from "./memory-project.js";
-import { memoryViewerEventTurnIds } from "./memory-viewer-turn-reference.js";
+import { UNCLASSIFIED_PROJECT_ID } from "../../memory/project.js";
+import { memoryViewerEventTurnIds } from "./turn-reference.js";
 export function memoryViewerActivitySummary(allEvents) {
     let recalledCount = 0;
     let addCount = 0;

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

@@ -1,4 +1,4 @@
-import { memoryViewerEventKey } from "./memory-viewer-event-identity.js";
+import { memoryViewerEventKey } from "./event-identity.js";
 /**
  * Marks a retained start without an end as interrupted only when a different
  * Turn demonstrably started later in the same client session.

package/lib/memorax-code-backend/dist/{memory-viewer-observability.js → viewer/projection/observability.js}

@@ -1,4 +1,4 @@
-import { recordMemoryViewerEvent } from "./memory-viewer-store.js";
+import { recordMemoryViewerEvent } from "../store.js";
 export function memoryViewerObservabilityHook() {
     return {
         recordEvent(event) {

package/lib/memorax-code-backend/dist/{memory-viewer-user-projection.js → viewer/projection/user.js}

@@ -1,4 +1,4 @@
-import { isTraceClient } from "./trace-context.js";
+import { isTraceClient } from "../../trace/context.js";
 /**
  * Projects raw Viewer events into the deliberately small user-facing summary contract.
  * Conversation, memory, session, turn, and diagnostic fields never cross this boundary.

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

@@ -1,4 +1,4 @@
-import { completeMemoryWritebackTask, memoryText, memoryWritebackTaskEventKey, memoryWritebackTaskOutcome, memoryWritebackTaskOutcomeForStatus, nonNegativeInteger, projectMemoryWritebackTasks, stringArray, } from "./memory-writeback-task-projection.js";
+import { completeMemoryWritebackTask, memoryText, memoryWritebackTaskEventKey, memoryWritebackTaskOutcome, memoryWritebackTaskOutcomeForStatus, nonNegativeInteger, projectMemoryWritebackTasks, stringArray, } from "../../memory/writeback-task-projection.js";
 export { memoryText, nonNegativeInteger, stringArray, };
 export function pendingMemoryViewerWritebacks(eventsToCheck) {
     const tasks = new Map(projectMemoryWritebackTasks(eventsToCheck.flatMap(memoryViewerWritebackProjectionRecord)).map((task) => [memoryWritebackTaskEventKey(task), task]));