@memorax/memorax-code 0.1.1 → 0.1.3

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

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
-import { createMemoryWritebackBufferRuntime, } from "./memory-writeback-buffer.js";
-import { memoryWritebackAddParts, } from "./memory-writeback-chunk.js";
-import { invokeMemoraxMemoryProvider, } from "./memorax-adapter.js";
-import { memoryWritebackBufferEnabled, memoryWritebackEnabled, memoryWritebackMaxMessageChars, } from "./memorax-config.js";
+import { createMemoryWritebackBufferRuntime, } from "./writeback-buffer.js";
+import { memoryWritebackAddParts, } from "./writeback-chunk.js";
+import { invokeMemoraxMemoryProvider, } from "../provider/memorax/adapter.js";
+import { memoryWritebackBufferEnabled, memoryWritebackEnabled, memoryWritebackMaxMessageChars, } from "../provider/memorax/config.js";
+import { hasMeaningfulMemoryPayloadText, redactMemoryPayloadText, } from "./payload-redaction.js";
 const WRITEBACK_DEDUPE_TTL_MS = 5 * 60 * 1000;
 const WRITEBACK_DEDUPE_MAX = 1024;
 const AUTOMATIC_MEMORY_WRITEBACK_MAX_ATTEMPTS = 2;
@@ -20,6 +21,13 @@ export function createAutomaticMemoryWritebackRuntime(options = {}) {
         enqueue(options) {
             return enqueueAutomaticMemoryWritebackForRuntime(state, options);
         },
+        discardForScopeUpgrade(upgrade) {
+            return state.writebackBuffer.discardForScopeUpgrade({
+                client: upgrade.client,
+                sessionKey: upgrade.sessionId,
+                currentScope: upgrade.currentScope,
+            });
+        },
         drain() {
             if (state.drainPromise)
                 return state.drainPromise;
@@ -40,7 +48,7 @@ function enqueueAutomaticMemoryWritebackForRuntime(state, options) {
         state.diagnosticLogger("memory.automatic_writeback", {
             scheduled: false,
             skipReason: "runtime_closed",
-            sessionKey: options.sessionKey,
+            sessionKeyHash: hashOptionalText(options.sessionKey),
         });
         return { accepted: false, reason: "runtime_closed" };
     }
@@ -50,7 +58,7 @@ function enqueueAutomaticMemoryWritebackForRuntime(state, options) {
             state.diagnosticLogger("memory.automatic_writeback", {
                 scheduled: false,
                 skipReason: decision.skipReason,
-                sessionKey: options.sessionKey,
+                sessionKeyHash: hashOptionalText(options.sessionKey),
             });
             return decision.skipReason === "duplicate_pending"
                 ? { accepted: true }
@@ -58,7 +66,7 @@ function enqueueAutomaticMemoryWritebackForRuntime(state, options) {
         }
         if (memoryWritebackBufferEnabled(options.env ?? process.env)) {
             state.writebackBuffer.enqueue(decision, options, {
-                debug: state.diagnosticLogger,
+                debug: redactAutomaticMemoryWritebackDiagnosticIdentifiers(state.diagnosticLogger),
                 flush: (bufferedDecision, bufferedOptions) => flushAutomaticMemoryWritebackBuffer(state, bufferedDecision, bufferedOptions),
                 hasPendingWriteback: (idempotencyKey) => hasPendingWriteback(state, idempotencyKey),
                 reservePendingWritebacks: (idempotencyKeys) => reservePendingWritebacks(state, idempotencyKeys),
@@ -69,8 +77,8 @@ function enqueueAutomaticMemoryWritebackForRuntime(state, options) {
         reservePendingWriteback(state, decision.idempotencyKey);
         state.diagnosticLogger("memory.automatic_writeback", {
             scheduled: true,
-            sessionKey: options.sessionKey,
-            idempotencyKey: decision.idempotencyKey,
+            sessionKeyHash: hashText(decision.sessionKey),
+            idempotencyKeyHash: hashText(decision.idempotencyKey),
             messageCount: decision.messages.length,
             userChars: decision.messages[0]?.content.length ?? 0,
             assistantChars: decision.messages[1]?.content.length ?? 0,
@@ -82,12 +90,23 @@ function enqueueAutomaticMemoryWritebackForRuntime(state, options) {
         state.diagnosticLogger("memory.automatic_writeback", {
             scheduled: false,
             skipReason: "decision_error",
-            sessionKey: options.sessionKey,
+            sessionKeyHash: hashOptionalText(options.sessionKey),
             error: error instanceof Error ? error.message : String(error),
         });
         return { accepted: false, reason: "decision_error" };
     }
 }
+function redactAutomaticMemoryWritebackDiagnosticIdentifiers(diagnosticLogger) {
+    return (message, fields = {}) => {
+        const { sessionKey, idempotencyKey, parentIdempotencyKey, ...rest } = fields;
+        diagnosticLogger(message, {
+            ...rest,
+            ...(typeof sessionKey === "string" ? { sessionKeyHash: hashText(sessionKey) } : {}),
+            ...(typeof idempotencyKey === "string" ? { idempotencyKeyHash: hashText(idempotencyKey) } : {}),
+            ...(typeof parentIdempotencyKey === "string" ? { parentIdempotencyKeyHash: hashText(parentIdempotencyKey) } : {}),
+        });
+    };
+}
 function automaticMemoryWritebackDecision(state, options) {
     const env = options.env ?? process.env;
     if (!memoryWritebackEnabled(env))
@@ -103,17 +122,35 @@ function automaticMemoryWritebackDecision(state, options) {
     }
     const sessionKey = options.sessionKey.trim();
     const maxMessageChars = memoryWritebackMaxMessageChars(env);
-    const userText = limitMessageContent(options.userText?.trim() ?? "", maxMessageChars, {
+    const rawUserText = options.userText?.trim() ?? "";
+    const rawAssistantText = options.assistantText?.trim() ?? "";
+    if (!rawUserText)
+        return { write: false, skipReason: "user_prompt_empty" };
+    if (!rawAssistantText)
+        return { write: false, skipReason: "assistant_text_empty" };
+    const boundedUserText = limitMessageContent(rawUserText, maxMessageChars, {
+        role: "user",
+        sessionKey,
+    }, state.diagnosticLogger);
+    const boundedAssistantText = limitMessageContent(rawAssistantText, maxMessageChars, {
+        role: "assistant",
+        sessionKey,
+    }, state.diagnosticLogger);
+    const userRedaction = redactMemoryPayloadText(boundedUserText);
+    const assistantRedaction = redactMemoryPayloadText(boundedAssistantText);
+    logAutomaticMemoryPayloadRedaction(state, sessionKey, "user", rawUserText, userRedaction);
+    logAutomaticMemoryPayloadRedaction(state, sessionKey, "assistant", rawAssistantText, assistantRedaction);
+    const userText = limitMessageContent(userRedaction.text, maxMessageChars, {
         role: "user",
         sessionKey,
     }, state.diagnosticLogger);
-    const assistantText = limitMessageContent(options.assistantText?.trim() ?? "", maxMessageChars, {
+    const assistantText = limitMessageContent(assistantRedaction.text, maxMessageChars, {
         role: "assistant",
         sessionKey,
     }, state.diagnosticLogger);
-    if (!userText)
+    if (!hasMeaningfulMemoryPayloadText(userText))
         return { write: false, skipReason: "user_prompt_empty" };
-    if (!assistantText)
+    if (!hasMeaningfulMemoryPayloadText(assistantText))
         return { write: false, skipReason: "assistant_text_empty" };
     const idempotencyKey = `automatic:${options.client}:${hashText(options.repositoryScope.effectiveUserId)}:${sessionKey}:${hashText(userText)}:${hashText(assistantText)}`;
     if (hasPendingWriteback(state, idempotencyKey))
@@ -129,8 +166,26 @@ function automaticMemoryWritebackDecision(state, options) {
         ],
     };
 }
+function logAutomaticMemoryPayloadRedaction(state, sessionKey, role, originalText, result) {
+    if (!result.redacted)
+        return;
+    state.diagnosticLogger("memory.automatic_writeback.redacted", {
+        sessionKeyHash: hashText(sessionKey),
+        role,
+        originalChars: originalText.length,
+        redactedChars: result.text.length,
+        counts: result.counts,
+    });
+}
 async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
     try {
+        if (decision.messages.some((message) => redactMemoryPayloadText(message.content).redacted)) {
+            state.diagnosticLogger("memory.writeback.redaction_rejected", {
+                source: options.memoryObservabilitySource ?? "automatic_writeback",
+                messageCount: decision.messages.length,
+            });
+            throw new Error("automatic writeback content must be redacted before provider dispatch");
+        }
         const parts = memoryWritebackAddParts(decision, options.env ?? process.env);
         for (const [index, part] of parts.entries()) {
             for (let attempt = 1; attempt <= AUTOMATIC_MEMORY_WRITEBACK_MAX_ATTEMPTS; attempt += 1) {
@@ -172,9 +227,9 @@ async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
                 state.diagnosticLogger("memory.automatic_writeback", {
                     scheduled: true,
                     accepted: response.ok,
-                    sessionKey: decision.sessionKey,
-                    idempotencyKey: part.idempotencyKey,
-                    parentIdempotencyKey: part.idempotencyKey === decision.idempotencyKey ? undefined : decision.idempotencyKey,
+                    sessionKeyHash: hashText(decision.sessionKey),
+                    idempotencyKeyHash: hashText(part.idempotencyKey),
+                    parentIdempotencyKeyHash: part.idempotencyKey === decision.idempotencyKey ? undefined : hashText(decision.idempotencyKey),
                     flushReason: decision.flushReason,
                     turnCount: decision.turnCount,
                     partIndex: parts.length > 1 ? index : undefined,
@@ -203,8 +258,8 @@ async function enqueueAutomaticMemoryWritebackAsync(state, decision, options) {
         state.diagnosticLogger("memory.automatic_writeback", {
             scheduled: true,
             accepted: false,
-            sessionKey: decision.sessionKey,
-            idempotencyKey: decision.idempotencyKey,
+            sessionKeyHash: hashText(decision.sessionKey),
+            idempotencyKeyHash: hashText(decision.idempotencyKey),
             flushReason: decision.flushReason,
             turnCount: decision.turnCount,
             error: error instanceof Error ? error.message : String(error),
@@ -264,9 +319,12 @@ function prunePendingWritebacks(state, now = Date.now()) {
 function limitMessageContent(content, maxChars, fields, diagnosticLogger = () => { }) {
     if (content.length <= maxChars)
         return content;
-    const kept = content.slice(0, maxChars).trim();
+    const prefix = content.slice(0, maxChars);
+    const kept = (/\S$/.test(prefix) && /^\S/.test(content.slice(maxChars)))
+        ? prefix.replace(/\S+$/, "").trim()
+        : prefix.trim();
     diagnosticLogger("memory.automatic_writeback.truncated", {
-        sessionKey: fields?.sessionKey,
+        sessionKeyHash: hashOptionalText(fields?.sessionKey),
         role: fields?.role,
         originalChars: content.length,
         keptChars: kept.length,
@@ -277,6 +335,9 @@ function limitMessageContent(content, maxChars, fields, diagnosticLogger = () =>
 function hashText(text) {
     return createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
+function hashOptionalText(text) {
+    return text?.trim() ? hashText(text.trim()) : undefined;
+}
 function automaticMemoryWritebackRetryDelayMs(failure, attempt) {
     if (!isRetryableAutomaticMemoryWritebackFailure(failure))
         return undefined;

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

@@ -1,12 +1,12 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { backendDebug } from "./debug-log.js";
-import { invokeMemoraxMemoryProvider } from "./memorax-adapter.js";
-import { defaultMemoraxCodeHome, memoryCliAddEnabled, memoryCliMaxMemoryChars, memoryCliSessionId, memoryConfigStatus, } from "./memorax-config.js";
-import { resolveConfiguredRepositoryMemory, } from "./repository-memory-context.js";
-import { repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, } from "./repository-memory-scope.js";
-import { isTraceClient } from "./trace-context.js";
-import { readCurrentTraceTurn, recordTraceEvent } from "./trace-store.js";
+import { backendDebug } from "../shared/debug-log.js";
+import { invokeMemoraxMemoryProvider } from "../provider/memorax/adapter.js";
+import { defaultMemoraxCodeHome, memoryCliAddEnabled, memoryCliMaxMemoryChars, memoryCliSessionId, memoryConfigStatus, } from "../provider/memorax/config.js";
+import { resolveConfiguredRepositoryMemory, } from "./repository-session.js";
+import { repositoryMemoryScopeContainsWorkspace, repositoryMemoryScopeKind, repositoryMemoryScopesMatch, } from "../repository/scope.js";
+import { isTraceClient } from "../trace/context.js";
+import { readCurrentTraceTurn, recordTraceEvent } from "../trace/store.js";
 export async function runMemoryCli(args, options = {}) {
     const command = args[0] || "status";
     const env = options.env ?? process.env;
@@ -72,7 +72,7 @@ async function memorySearch(args, options) {
     const query = queryResult.text;
     const repositoryMemory = await resolveMemoryCliRepositoryMemory(options);
     if (!repositoryMemory.ok) {
-        return { ok: false, action: "memory.search", query, error: repositoryMemory.error };
+        return memoryCliRepositoryFailure("memory.search", repositoryMemory, { query });
     }
     const observability = await memoryCliObservability(options.env);
     const response = await invokeMemoraxMemoryProvider({ sessionId: memoryCliSessionId(args, options.env), prompt: query }, {
@@ -135,7 +135,7 @@ async function memoryAdd(args, options) {
         return { ok: false, action: "memory.add", error: contentOptions.error };
     const repositoryMemory = await resolveMemoryCliRepositoryMemory(options);
     if (!repositoryMemory.ok)
-        return { ok: false, action: "memory.add", error: repositoryMemory.error };
+        return memoryCliRepositoryFailure("memory.add", repositoryMemory);
     const sessionId = memoryCliSessionId(args, env);
     const observability = await memoryCliObservability(env);
     const response = await invokeMemoraxMemoryProvider({ sessionId, prompt: memory }, {
@@ -217,7 +217,7 @@ async function resolveMemoryCliRepositoryMemory(options) {
     if (!commandMemory.ok || !commandMemory.memory.scope)
         return commandMemory;
     if (turnMemory?.ok && (!turnMemory.memory.scope || !repositoryMemoryScopesMatch(commandMemory.memory.scope, turnMemory.memory.scope))) {
-        const clientLabel = traceBinding?.client === "claude" ? "Claude" : "Codex";
+        const clientLabel = traceClientLabel(traceBinding?.client);
         return {
             ok: false,
             reason: "workspace_scope_mismatch",
@@ -226,6 +226,24 @@ async function resolveMemoryCliRepositoryMemory(options) {
     }
     return commandMemory;
 }
+function memoryCliRepositoryFailure(action, failure, fields = {}) {
+    const userAction = failure.reason === "workspace_scope_mismatch"
+        ? "Start a new Codex, Claude Code, DSH, or OpenCode session from the target repository or local workspace."
+        : failure.reason === "workspace_scope_unavailable"
+            ? "Start a new Codex, Claude Code, DSH, or OpenCode session from the target repository or local workspace. If the problem continues, make sure its .git metadata is readable and valid."
+            : undefined;
+    return {
+        ok: false,
+        action,
+        ...fields,
+        ...(userAction ? {
+            workspaceScope: "unavailable",
+            workspaceScopeReason: failure.reason,
+            userAction,
+        } : {}),
+        error: failure.error,
+    };
+}
 function memoryCliIdentityFields(memory) {
     return {
         baseUserId: memory.config.userId,
@@ -234,6 +252,10 @@ function memoryCliIdentityFields(memory) {
             scopeKind: repositoryMemoryScopeKind(memory.scope),
             effectiveUserId: memory.scope.effectiveUserId,
             workspaceScope: "bound",
+            ...(memory.scope.fallbackReason === "git_metadata_invalid" ? {
+                workspaceScopeFallbackReason: memory.scope.fallbackReason,
+                userNotice: `Git repository metadata is invalid or incomplete. MemoraX Code is using the local folder name "${memory.scope.repositorySlug}" for memory scope, so Search and Add use "${memory.scope.effectiveUserId}". Repair the repository or restore valid .git metadata. Later Search, Add, and automatic writeback in the same client session will automatically use the restored Git repository scope.`,
+            } : {}),
         } : {
             workspaceScope: "unavailable",
         }),
@@ -276,6 +298,10 @@ async function memoryCliObservability(env = process.env) {
     };
 }
 function memoryCliTraceBinding(env) {
+    if (env.DSH_SHELL === "1") {
+        const expectedSessionId = env.DSH_SESSION_ID?.trim();
+        return expectedSessionId ? { client: "dsh", expectedSessionId } : undefined;
+    }
     const explicitClientRaw = env.MEMORAX_CODE_MEMORY_CLI_TRACE_CLIENT;
     const explicitSessionIdRaw = env.MEMORAX_CODE_MEMORY_CLI_TRACE_SESSION_ID;
     if (explicitClientRaw !== undefined || explicitSessionIdRaw !== undefined) {
@@ -293,6 +319,15 @@ function memoryCliTraceBinding(env) {
 function memoryCliTraceEventType(event) {
     return event.operation === "writeback" ? "memory_cli_add" : "memory_cli_search";
 }
+function traceClientLabel(client) {
+    if (client === "claude")
+        return "Claude";
+    if (client === "dsh")
+        return "DSH";
+    if (client === "opencode")
+        return "OpenCode";
+    return client === "codex" ? "Codex" : "coding agent";
+}
 function memoryAddContentOptions(args) {
     const contentType = argValue(args, "--content-type")?.trim();
     const mode = argValue(args, "--mode")?.trim();

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

@@ -1,4 +1,4 @@
-import { isRecord } from "./utils.js";
+import { isRecord } from "../shared/record.js";
 export const MEMORY_HOOK_COMMAND_VERSION = 1;
 export const INVALID_MEMORY_HOOK_COMMAND = "invalid memory Hook command";
 const BASE_COMMAND_KEYS = [
@@ -11,6 +11,8 @@ const BASE_COMMAND_KEYS = [
 const TURN_START_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "prompt", "transcriptPath"]),
     "claude-code": new Set([...BASE_COMMAND_KEYS, "promptId", "prompt", "transcriptPath"]),
+    opencode: new Set([...BASE_COMMAND_KEYS, "userMessageId", "prompt"]),
+    dsh: new Set(["version", "client", "sessionId", "turn", "startSeq", "cwd", "prompt"]),
 };
 const WRITEBACK_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "lastAssistantMessage", "transcriptPath"]),
@@ -20,10 +22,29 @@ const WRITEBACK_KEYS = {
         "lastAssistantMessage",
         "transcriptPath",
     ]),
+    opencode: new Set([
+        ...BASE_COMMAND_KEYS,
+        "userMessageId",
+        "assistantMessageId",
+        "messages",
+    ]),
+    dsh: new Set([
+        "version",
+        "client",
+        "sessionId",
+        "turn",
+        "startSeq",
+        "endSeq",
+        "cwd",
+        "sessionHeader",
+        "events",
+    ]),
 };
 const SKILL_REMINDER_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "transcriptPath", "content", "triggers"]),
     "claude-code": new Set([...BASE_COMMAND_KEYS, "promptId", "transcriptPath", "content", "triggers"]),
+    dsh: new Set(["version", "client", "sessionId", "turn", "cwd", "content", "triggers"]),
+    opencode: new Set([...BASE_COMMAND_KEYS, "userMessageId", "content", "triggers"]),
 };
 export function parseTurnStartCommand(value) {
     if (!isRecord(value))
@@ -32,12 +53,29 @@ export function parseTurnStartCommand(value) {
     if (!base)
         return invalidCommand();
     const prompt = requiredStringField(value, "prompt");
-    const transcriptPath = requiredStringField(value, "transcriptPath");
-    if (!prompt || !transcriptPath)
+    if (!prompt)
         return invalidCommand();
+    if (base.client === "dsh") {
+        const turn = positiveSafeIntegerField(value, "turn");
+        const startSeq = nonNegativeSafeIntegerField(value, "startSeq");
+        if (!turn || startSeq === undefined || !base.cwd)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "dsh",
+                turn,
+                startSeq,
+                cwd: base.cwd,
+                prompt,
+            },
+        };
+    }
     if (base.client === "codex") {
+        const transcriptPath = requiredStringField(value, "transcriptPath");
         const turnId = optionalStringField(value, "turnId");
-        if (!turnId.ok)
+        if (!transcriptPath || !turnId.ok)
             return invalidCommand();
         return {
             ok: true,
@@ -50,8 +88,23 @@ export function parseTurnStartCommand(value) {
             },
         };
     }
+    if (base.client === "opencode") {
+        const userMessageId = requiredStringField(value, "userMessageId");
+        if (!userMessageId)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "opencode",
+                userMessageId,
+                prompt,
+            },
+        };
+    }
     const promptId = requiredStringField(value, "promptId");
-    if (!promptId)
+    const transcriptPath = requiredStringField(value, "transcriptPath");
+    if (!promptId || !transcriptPath)
         return invalidCommand();
     return {
         ok: true,
@@ -70,6 +123,49 @@ export function parseWritebackCommand(value) {
     const base = parseCommandBase(value, WRITEBACK_KEYS);
     if (!base)
         return invalidCommand();
+    if (base.client === "dsh") {
+        const turn = positiveSafeIntegerField(value, "turn");
+        const startSeq = nonNegativeSafeIntegerField(value, "startSeq");
+        const endSeq = nonNegativeSafeIntegerField(value, "endSeq");
+        if (!turn
+            || startSeq === undefined
+            || endSeq === undefined
+            || endSeq < startSeq
+            || !base.cwd
+            || !isRecord(value.sessionHeader)
+            || !Array.isArray(value.events))
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "dsh",
+                turn,
+                startSeq,
+                endSeq,
+                cwd: base.cwd,
+                sessionHeader: value.sessionHeader,
+                events: value.events,
+            },
+        };
+    }
+    if (base.client === "opencode") {
+        const userMessageId = requiredStringField(value, "userMessageId");
+        const assistantMessageId = requiredStringField(value, "assistantMessageId");
+        if (!userMessageId || !assistantMessageId || !Array.isArray(value.messages)) {
+            return invalidCommand();
+        }
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "opencode",
+                userMessageId,
+                assistantMessageId,
+                messages: value.messages,
+            },
+        };
+    }
     const lastAssistantMessage = requiredStringField(value, "lastAssistantMessage");
     if (!lastAssistantMessage)
         return invalidCommand();
@@ -110,10 +206,43 @@ export function parseSkillReminderCommand(value) {
     const base = parseCommandBase(value, SKILL_REMINDER_KEYS);
     if (!base)
         return invalidCommand();
-    const transcriptPath = requiredStringField(value, "transcriptPath");
     const content = requiredContentField(value, "content");
     const triggers = skillReminderTriggers(value.triggers);
-    if (!transcriptPath || !content || !triggers)
+    if (!content || !triggers)
+        return invalidCommand();
+    if (base.client === "dsh") {
+        const turn = positiveSafeIntegerField(value, "turn");
+        if (!turn || !base.cwd)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "dsh",
+                turn,
+                cwd: base.cwd,
+                content,
+                triggers,
+            },
+        };
+    }
+    if (base.client === "opencode") {
+        const userMessageId = requiredStringField(value, "userMessageId");
+        if (!userMessageId)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "opencode",
+                userMessageId,
+                content,
+                triggers,
+            },
+        };
+    }
+    const transcriptPath = requiredStringField(value, "transcriptPath");
+    if (!transcriptPath)
         return invalidCommand();
     if (base.client === "codex") {
         const turnId = requiredStringField(value, "turnId");
@@ -131,6 +260,8 @@ export function parseSkillReminderCommand(value) {
             },
         };
     }
+    if (base.client !== "claude-code")
+        return invalidCommand();
     const promptId = requiredStringField(value, "promptId");
     if (!promptId)
         return invalidCommand();
@@ -150,9 +281,13 @@ function parseCommandBase(value, allowedKeys) {
     if (value.version !== MEMORY_HOOK_COMMAND_VERSION)
         return undefined;
     const client = value.client;
-    if (client !== "codex" && client !== "claude-code")
+    if (client !== "codex"
+        && client !== "claude-code"
+        && client !== "opencode"
+        && client !== "dsh")
         return undefined;
-    if (Object.keys(value).some((key) => !allowedKeys[client].has(key)))
+    const clientKeys = allowedKeys[client];
+    if (!clientKeys || Object.keys(value).some((key) => !clientKeys.has(key)))
         return undefined;
     const sessionId = requiredStringField(value, "sessionId");
     if (!sessionId)
@@ -169,6 +304,18 @@ function parseCommandBase(value, allowedKeys) {
         ...(workspaceKind.value ? { workspaceKind: workspaceKind.value } : {}),
     };
 }
+function positiveSafeIntegerField(value, key) {
+    const field = value[key];
+    return typeof field === "number" && Number.isSafeInteger(field) && field > 0
+        ? field
+        : undefined;
+}
+function nonNegativeSafeIntegerField(value, key) {
+    const field = value[key];
+    return typeof field === "number" && Number.isSafeInteger(field) && field >= 0
+        ? field
+        : undefined;
+}
 function requiredStringField(value, key) {
     const field = value[key];
     return typeof field === "string" && field.trim() ? field.trim() : undefined;

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

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