@memorax/memorax-code 0.1.0

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

@@ -0,0 +1,345 @@
+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";
+export async function runMemoryCli(args, options = {}) {
+    const command = args[0] || "status";
+    const env = options.env ?? process.env;
+    const nextOptions = { ...options, env };
+    if (command === "status")
+        return await memoryStatus(nextOptions, args.includes("--config-only"));
+    if (command === "search")
+        return memorySearch(args.slice(1), nextOptions);
+    if (command === "add")
+        return memoryAdd(args.slice(1), nextOptions);
+    return { ok: false, action: "memory.status", error: `unknown memory command: ${command}` };
+}
+async function memoryStatus(options, configOnly = false) {
+    const env = options.env ?? process.env;
+    const status = memoryConfigStatus(env);
+    if (configOnly) {
+        return {
+            ok: status.configured,
+            action: "memory.status",
+            provider: "memory.memorax",
+            searchEnabled: status.search.enabled,
+            addEnabled: status.cli.addEnabled,
+            config: status,
+            ...(status.configured ? {} : { error: status.error }),
+        };
+    }
+    if (!status.configured) {
+        return {
+            ok: false,
+            action: "memory.status",
+            provider: "memory.memorax",
+            searchEnabled: false,
+            addEnabled: status.cli.addEnabled,
+            config: status,
+            workspaceScope: "unavailable",
+            workspaceScopeReason: "config_missing",
+            error: status.error,
+        };
+    }
+    const repositoryMemory = await resolveMemoryCliRepositoryMemory(options);
+    return {
+        ok: true,
+        action: "memory.status",
+        provider: "memory.memorax",
+        baseUrl: status.baseUrl,
+        userId: status.userId,
+        baseUserId: status.userId,
+        ...(repositoryMemory.ok
+            ? memoryCliIdentityFields(repositoryMemory.memory)
+            : {
+                workspaceScope: "unavailable",
+                workspaceScopeReason: repositoryMemory.reason,
+            }),
+        searchEnabled: status.search.enabled,
+        addEnabled: status.cli.addEnabled,
+        config: status,
+    };
+}
+async function memorySearch(args, options) {
+    const queryResult = await readTextArg(args, "--query", "--query-file", "query");
+    if (!queryResult.ok)
+        return { ok: false, action: "memory.search", error: queryResult.error };
+    const query = queryResult.text;
+    const repositoryMemory = await resolveMemoryCliRepositoryMemory(options);
+    if (!repositoryMemory.ok) {
+        return { ok: false, action: "memory.search", query, error: repositoryMemory.error };
+    }
+    const observability = await memoryCliObservability(options.env);
+    const response = await invokeMemoraxMemoryProvider({ sessionId: memoryCliSessionId(args, options.env), prompt: query }, {
+        provider_family: "memory",
+        provider_id: "memory.memorax",
+        transport: "external_http",
+        slot: "state_context",
+        operation: "query",
+        query,
+        context: {
+            ...(limitFromArgs(args) === undefined ? {} : { limit: limitFromArgs(args) }),
+        },
+    }, {
+        config: repositoryMemory.memory.config,
+        diagnosticLogger: backendDebug,
+        fetchImpl: options.fetchImpl,
+        observability: observability.hook,
+        observabilitySource: "memory_cli",
+        repositoryScope: repositoryMemory.memory.scope,
+    });
+    await observability.flush();
+    if (!response.ok)
+        return { ok: false, action: "memory.search", query, error: response.error };
+    const payload = isRecord(response.result.tool_result_payload) ? response.result.tool_result_payload : {};
+    return {
+        ok: true,
+        action: "memory.search",
+        provider: "memory.memorax",
+        query,
+        ...memoryCliIdentityFields(repositoryMemory.memory),
+        answer: typeof payload.answer === "string" ? payload.answer : "",
+        items: Array.isArray(payload.items) ? payload.items : [],
+        receipt: response.result.dispatch_receipt ?? null,
+    };
+}
+async function memoryAdd(args, options) {
+    const env = options.env ?? process.env;
+    if (env.MEMORAX_CODE_MEMORAX_WRITEBACK_ENABLED === "false") {
+        return { ok: false, action: "memory.add", error: "MEMORAX_CODE_MEMORAX_WRITEBACK_ENABLED=false disables MemoraX add" };
+    }
+    if (!memoryCliAddEnabled(env)) {
+        return { ok: false, action: "memory.add", error: "memory add is disabled by MEMORAX_CODE_MEMORY_CLI_ADD_ENABLED=false or [memory.cli].add_enabled=false" };
+    }
+    const memoryResult = await readTextArg(args, "--memory", "--memory-file", "memory");
+    if (!memoryResult.ok)
+        return { ok: false, action: "memory.add", error: memoryResult.error };
+    const memory = memoryResult.text;
+    const maxChars = memoryCliMaxMemoryChars(env);
+    if (memory.length > maxChars) {
+        return { ok: false, action: "memory.add", error: `memory is too long: ${memory.length} chars > ${maxChars}` };
+    }
+    const memoryType = requiredArg(args, "--type");
+    if (!memoryType.ok)
+        return { ok: false, action: "memory.add", error: memoryType.error };
+    const reason = requiredArg(args, "--reason");
+    if (!reason.ok)
+        return { ok: false, action: "memory.add", error: reason.error };
+    const contentOptions = memoryAddContentOptions(args);
+    if (!contentOptions.ok)
+        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 };
+    const sessionId = memoryCliSessionId(args, env);
+    const observability = await memoryCliObservability(env);
+    const response = await invokeMemoraxMemoryProvider({ sessionId, prompt: memory }, {
+        provider_family: "memory",
+        provider_id: "memory.memorax",
+        transport: "external_http",
+        slot: "state_context",
+        operation: "writeback",
+        dispatch: "async_best_effort",
+        context: {
+            idempotencyKey: `memory-cli:${sessionId}:${hashText(`${memoryType.value}\n${reason.value}\n${memory}`)}`,
+            messages: [{ role: "user", content: memory }],
+            ...contentOptions.context,
+            metadata: {
+                source_detail: "memorax_code_memory_cli",
+                memory_type: memoryType.value,
+                memorax_code_memory_reason: reason.value,
+            },
+        },
+    }, {
+        config: repositoryMemory.memory.config,
+        diagnosticLogger: backendDebug,
+        env,
+        fetchImpl: options.fetchImpl,
+        observability: observability.hook,
+        observabilitySource: "memory_cli",
+        repositoryScope: repositoryMemory.memory.scope,
+    });
+    await observability.flush();
+    if (!response.ok)
+        return { ok: false, action: "memory.add", error: response.error };
+    return {
+        ok: true,
+        action: "memory.add",
+        provider: "memory.memorax",
+        ...memoryCliIdentityFields(repositoryMemory.memory),
+        receipt: response.result.dispatch_receipt ?? null,
+    };
+}
+async function resolveMemoryCliRepositoryMemory(options) {
+    const env = options.env ?? process.env;
+    const memoraxCodeHome = defaultMemoraxCodeHome(env);
+    let turnMemory;
+    const traceBinding = memoryCliTraceBinding(env);
+    if (traceBinding?.expectedSessionId) {
+        const current = await readCurrentTraceTurn({
+            client: traceBinding.client,
+            memoraxCodeHome,
+            env,
+            expectedSessionId: traceBinding.expectedSessionId,
+        });
+        if (current.ok
+            && (current.traceContext.cwd?.trim() || current.traceContext.workspaceKind?.trim().toLowerCase() === "projectless")) {
+            turnMemory = await resolveConfiguredRepositoryMemory({
+                workspaceRoot: current.traceContext.cwd,
+                workspaceKind: current.traceContext.workspaceKind,
+                memoraxCodeHome,
+                env,
+            });
+            if (!turnMemory.ok)
+                return turnMemory;
+        }
+    }
+    const commandWorkspace = options.cwd ?? process.cwd();
+    if (turnMemory?.ok && turnMemory.memory.scope) {
+        const turnScope = turnMemory.memory.scope;
+        const turnScopeKind = repositoryMemoryScopeKind(turnScope);
+        if ((turnScopeKind === "codex-projectless" && !turnScope.boundWorkspaceRoot)
+            || ((turnScopeKind === "codex-projectless" || turnScopeKind === "local-directory")
+                && await repositoryMemoryScopeContainsWorkspace(turnScope, commandWorkspace))) {
+            return turnMemory;
+        }
+    }
+    const commandMemory = await resolveConfiguredRepositoryMemory({
+        workspaceRoot: commandWorkspace,
+        memoraxCodeHome,
+        env,
+    });
+    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";
+        return {
+            ok: false,
+            reason: "workspace_scope_mismatch",
+            error: `memory CLI cwd does not match the current ${clientLabel} turn repository/workspace scope; start a new session in the target scope`,
+        };
+    }
+    return commandMemory;
+}
+function memoryCliIdentityFields(memory) {
+    return {
+        baseUserId: memory.config.userId,
+        ...(memory.scope ? {
+            workspace: memory.scope.repositorySlug,
+            scopeKind: repositoryMemoryScopeKind(memory.scope),
+            effectiveUserId: memory.scope.effectiveUserId,
+            workspaceScope: "bound",
+        } : {
+            workspaceScope: "unavailable",
+        }),
+    };
+}
+async function memoryCliObservability(env = process.env) {
+    const memoraxCodeHome = defaultMemoraxCodeHome(env);
+    const traceBinding = memoryCliTraceBinding(env);
+    const current = traceBinding
+        ? await readCurrentTraceTurn({
+            client: traceBinding.client,
+            memoraxCodeHome,
+            env,
+            expectedSessionId: traceBinding.expectedSessionId,
+        })
+        : undefined;
+    const pending = [];
+    if (!current?.ok)
+        return { flush: async () => undefined };
+    return {
+        hook: {
+            recordEvent(event) {
+                pending.push(recordTraceEvent({
+                    memoraxCodeHome,
+                    env,
+                    traceContext: current.traceContext,
+                    type: memoryCliTraceEventType(event),
+                    source: event.source,
+                    operation: event.operation,
+                    ok: event.ok,
+                    request: event.request,
+                    response: event.response,
+                    error: event.error,
+                }));
+            },
+        },
+        flush: async () => {
+            await Promise.allSettled(pending);
+        },
+    };
+}
+function memoryCliTraceBinding(env) {
+    const explicitClientRaw = env.MEMORAX_CODE_MEMORY_CLI_TRACE_CLIENT;
+    const explicitSessionIdRaw = env.MEMORAX_CODE_MEMORY_CLI_TRACE_SESSION_ID;
+    if (explicitClientRaw !== undefined || explicitSessionIdRaw !== undefined) {
+        const client = explicitClientRaw?.trim();
+        const expectedSessionId = explicitSessionIdRaw?.trim();
+        if (!isTraceClient(client) || !expectedSessionId)
+            return undefined;
+        return { client, expectedSessionId };
+    }
+    const expectedSessionId = env.CODEX_THREAD_ID?.trim();
+    return expectedSessionId
+        ? { client: "codex", expectedSessionId }
+        : undefined;
+}
+function memoryCliTraceEventType(event) {
+    return event.operation === "writeback" ? "memory_cli_add" : "memory_cli_search";
+}
+function memoryAddContentOptions(args) {
+    const contentType = argValue(args, "--content-type")?.trim();
+    const mode = argValue(args, "--mode")?.trim();
+    const context = {};
+    const effectiveContentType = contentType || "code";
+    const effectiveMode = mode || (effectiveContentType === "code" ? "pre_summarized" : "default");
+    context.contentType = effectiveContentType;
+    context.mode = effectiveMode;
+    return { ok: true, context };
+}
+async function readTextArg(args, inlineFlag, fileFlag, label) {
+    const inline = argValue(args, inlineFlag);
+    const file = argValue(args, fileFlag);
+    if (inline && file)
+        return { ok: false, error: `use either ${inlineFlag} or ${fileFlag}, not both` };
+    let text = inline ?? "";
+    if (file) {
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch (error) {
+            return { ok: false, error: `failed to read ${fileFlag}: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    text = text.trim();
+    if (!text)
+        return { ok: false, error: `${label} is required` };
+    return { ok: true, text };
+}
+function requiredArg(args, flag) {
+    const value = argValue(args, flag)?.trim();
+    return value ? { ok: true, value } : { ok: false, error: `${flag} is required` };
+}
+function argValue(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function limitFromArgs(args) {
+    const value = argValue(args, "--limit");
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? Math.max(1, Math.min(100, Math.trunc(parsed))) : undefined;
+}
+function hashText(text) {
+    return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,200 @@
+import { isRecord } from "./utils.js";
+export const MEMORY_HOOK_COMMAND_VERSION = 1;
+export const INVALID_MEMORY_HOOK_COMMAND = "invalid memory Hook command";
+const BASE_COMMAND_KEYS = [
+    "version",
+    "client",
+    "sessionId",
+    "cwd",
+    "workspaceKind",
+];
+const TURN_START_KEYS = {
+    codex: new Set([...BASE_COMMAND_KEYS, "turnId", "prompt", "transcriptPath"]),
+    "claude-code": new Set([...BASE_COMMAND_KEYS, "promptId", "prompt", "transcriptPath"]),
+};
+const WRITEBACK_KEYS = {
+    codex: new Set([...BASE_COMMAND_KEYS, "turnId", "lastAssistantMessage", "transcriptPath"]),
+    "claude-code": new Set([
+        ...BASE_COMMAND_KEYS,
+        "promptId",
+        "lastAssistantMessage",
+        "transcriptPath",
+    ]),
+};
+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"]),
+};
+export function parseTurnStartCommand(value) {
+    if (!isRecord(value))
+        return invalidCommand();
+    const base = parseCommandBase(value, TURN_START_KEYS);
+    if (!base)
+        return invalidCommand();
+    const prompt = requiredStringField(value, "prompt");
+    const transcriptPath = requiredStringField(value, "transcriptPath");
+    if (!prompt || !transcriptPath)
+        return invalidCommand();
+    if (base.client === "codex") {
+        const turnId = optionalStringField(value, "turnId");
+        if (!turnId.ok)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "codex",
+                prompt,
+                transcriptPath,
+                ...(turnId.value ? { turnId: turnId.value } : {}),
+            },
+        };
+    }
+    const promptId = requiredStringField(value, "promptId");
+    if (!promptId)
+        return invalidCommand();
+    return {
+        ok: true,
+        command: {
+            ...base,
+            client: "claude-code",
+            promptId,
+            prompt,
+            transcriptPath,
+        },
+    };
+}
+export function parseWritebackCommand(value) {
+    if (!isRecord(value))
+        return invalidCommand();
+    const base = parseCommandBase(value, WRITEBACK_KEYS);
+    if (!base)
+        return invalidCommand();
+    const lastAssistantMessage = requiredStringField(value, "lastAssistantMessage");
+    if (!lastAssistantMessage)
+        return invalidCommand();
+    if (base.client === "codex") {
+        const turnId = optionalStringField(value, "turnId");
+        const transcriptPath = optionalStringField(value, "transcriptPath");
+        if (!turnId.ok || !transcriptPath.ok)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "codex",
+                lastAssistantMessage,
+                ...(turnId.value ? { turnId: turnId.value } : {}),
+                ...(transcriptPath.value ? { transcriptPath: transcriptPath.value } : {}),
+            },
+        };
+    }
+    const promptId = requiredStringField(value, "promptId");
+    const transcriptPath = requiredStringField(value, "transcriptPath");
+    if (!promptId || !transcriptPath)
+        return invalidCommand();
+    return {
+        ok: true,
+        command: {
+            ...base,
+            client: "claude-code",
+            promptId,
+            lastAssistantMessage,
+            transcriptPath,
+        },
+    };
+}
+export function parseSkillReminderCommand(value) {
+    if (!isRecord(value))
+        return invalidCommand();
+    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)
+        return invalidCommand();
+    if (base.client === "codex") {
+        const turnId = requiredStringField(value, "turnId");
+        if (!turnId)
+            return invalidCommand();
+        return {
+            ok: true,
+            command: {
+                ...base,
+                client: "codex",
+                turnId,
+                transcriptPath,
+                content,
+                triggers,
+            },
+        };
+    }
+    const promptId = requiredStringField(value, "promptId");
+    if (!promptId)
+        return invalidCommand();
+    return {
+        ok: true,
+        command: {
+            ...base,
+            client: "claude-code",
+            promptId,
+            transcriptPath,
+            content,
+            triggers,
+        },
+    };
+}
+function parseCommandBase(value, allowedKeys) {
+    if (value.version !== MEMORY_HOOK_COMMAND_VERSION)
+        return undefined;
+    const client = value.client;
+    if (client !== "codex" && client !== "claude-code")
+        return undefined;
+    if (Object.keys(value).some((key) => !allowedKeys[client].has(key)))
+        return undefined;
+    const sessionId = requiredStringField(value, "sessionId");
+    if (!sessionId)
+        return undefined;
+    const cwd = optionalStringField(value, "cwd");
+    const workspaceKind = optionalStringField(value, "workspaceKind");
+    if (!cwd.ok || !workspaceKind.ok)
+        return undefined;
+    return {
+        version: MEMORY_HOOK_COMMAND_VERSION,
+        client,
+        sessionId,
+        ...(cwd.value ? { cwd: cwd.value } : {}),
+        ...(workspaceKind.value ? { workspaceKind: workspaceKind.value } : {}),
+    };
+}
+function requiredStringField(value, key) {
+    const field = value[key];
+    return typeof field === "string" && field.trim() ? field.trim() : undefined;
+}
+function requiredContentField(value, key) {
+    const field = value[key];
+    return typeof field === "string" && field.trim() ? field : undefined;
+}
+function skillReminderTriggers(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const triggers = [];
+    for (const trigger of value) {
+        if (trigger !== "cadence" && trigger !== "post_compaction")
+            return undefined;
+        if (!triggers.includes(trigger))
+            triggers.push(trigger);
+    }
+    return triggers;
+}
+function optionalStringField(value, key) {
+    if (!Object.prototype.hasOwnProperty.call(value, key))
+        return { ok: true };
+    const field = requiredStringField(value, key);
+    return field ? { ok: true, value: field } : { ok: false };
+}
+function invalidCommand() {
+    return { ok: false, error: INVALID_MEMORY_HOOK_COMMAND };
+}

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

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

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

@@ -0,0 +1,89 @@
+import { createHash } from "node:crypto";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+export const UNCLASSIFIED_PROJECT_ID = "__unclassified__";
+const PROJECT_ROOT_CACHE_CAPACITY = 512;
+const projectsByCwd = new Map();
+const projectRootsById = new Map();
+export function resolveMemoryProject(cwd) {
+    if (!cwd || !isAbsolute(cwd))
+        return undefined;
+    const normalizedCwd = normalizePath(cwd);
+    const cached = projectsByCwd.get(normalizedCwd);
+    if (cached) {
+        rememberProjectRoot(cached.identity.projectId, cached.root);
+        return cached.identity;
+    }
+    let current = normalizedCwd;
+    while (true) {
+        if (existsSync(join(current, ".git"))) {
+            const root = normalizePath(current);
+            const label = basename(root).trim();
+            const identity = {
+                projectId: `repo:${createHash("sha256").update(root).digest("hex").slice(0, 32)}`,
+                projectLabel: isSafeProjectLabel(label) ? label : "Repository",
+            };
+            projectsByCwd.set(normalizedCwd, { identity, root });
+            rememberProjectRoot(identity.projectId, root);
+            return identity;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+export function memoryProjectRoot(projectId) {
+    const root = projectRootsById.get(projectId);
+    if (root)
+        rememberProjectRoot(projectId, root);
+    return root;
+}
+export function memoryProjectFromUnknown(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const rawProjectId = rawString(record.projectId) || rawString(record.project_id) || rawString(record.id);
+    const rawProjectLabel = rawString(record.projectLabel) || rawString(record.project_label) || rawString(record.label);
+    const projectId = rawProjectId.trim();
+    const projectLabel = rawProjectLabel.trim();
+    if (rawProjectId !== projectId
+        || !isMemoryProjectId(projectId)
+        || !projectLabel
+        || !isSafeProjectLabel(rawProjectLabel)
+        || !isSafeProjectLabel(projectLabel))
+        return undefined;
+    return { projectId, projectLabel };
+}
+export function isMemoryProjectId(value) {
+    return /^repo:[a-f0-9]{32}$/.test(value);
+}
+function isSafeProjectLabel(value) {
+    return value.length <= 256
+        && value !== "."
+        && value !== ".."
+        && !/[\\/\u0000-\u001f\u007f]/.test(value);
+}
+function normalizePath(value) {
+    const absolute = resolve(value);
+    try {
+        return realpathSync.native(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+function rememberProjectRoot(projectId, root) {
+    projectRootsById.delete(projectId);
+    projectRootsById.set(projectId, root);
+    while (projectRootsById.size > PROJECT_ROOT_CACHE_CAPACITY) {
+        const oldest = projectRootsById.keys().next().value;
+        if (typeof oldest !== "string")
+            break;
+        projectRootsById.delete(oldest);
+    }
+}
+function rawString(value) {
+    return typeof value === "string" ? value : "";
+}

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

@@ -0,0 +1,58 @@
+import { parseSkillReminderCommand, } from "./memory-hook-command.js";
+import { traceContextFromClaudeHookBody, traceContextFromHookBody, } from "./trace-context.js";
+import { recordTraceEvent } from "./trace-store.js";
+export function createMemoryReminderTraceRecorder(options = {}) {
+    return {
+        async recordSkillReminder(body) {
+            const parsed = parseSkillReminderCommand(body);
+            if (!parsed.ok) {
+                options.diagnosticLogger?.("memory_hook.skill_reminder_invalid", {
+                    error: parsed.error,
+                });
+                return { ok: true };
+            }
+            const request = parsed.command;
+            const traceContext = traceContextForReminder(request);
+            await recordTraceBestEffort("memory_hook.skill_reminder_event", recordTraceEvent({
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "skill_reminder",
+                source: request.client === "codex" ? "codex-hook" : "claude-hook",
+                operation: "reminder",
+                ok: true,
+                request: {
+                    triggers: request.triggers,
+                },
+                response: {
+                    role: "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,
+                triggers: request.triggers,
+                contentChars: request.content.length,
+            });
+            return { ok: true };
+        },
+    };
+}
+function traceContextForReminder(command) {
+    if (command.client === "codex")
+        return traceContextFromHookBody(command);
+    return traceContextFromClaudeHookBody(command);
+}
+async function recordTraceBestEffort(label, promise, diagnosticLogger) {
+    try {
+        await promise;
+    }
+    catch (error) {
+        diagnosticLogger?.("memory_trace.write_failed", {
+            label,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}