@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/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/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@memorax-code/backend",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Local memory integration, lifecycle, trace, and diagnostics for MemoraX Code.",
+  "bin": {
+    "memorax-code": "dist/memorax-code.js",
+    "memorax-code-backend": "dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "dev:backend": "node --watch dist/server.js",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test --test-timeout=5000 --test-force-exit test/*.test.mjs",
+    "test:memory-viewer": "npm run build && node --test --test-timeout=5000 --test-force-exit test/memory-viewer-routes.test.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.2",
+    "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "smol-toml": "^1.7.0"
+  }
+}

package/lib/memorax-code-claude-adapter/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "memorax-code-claude-adapter",
+  "version": "0.1.0",
+  "description": "Memory skill and local hooks for MemoraX Code in Claude Code.",
+  "author": {
+    "name": "MemoraX Code Maintainers"
+  },
+  "license": "MIT",
+  "keywords": [
+    "memorax-code",
+    "claude-code",
+    "memory"
+  ],
+  "skills": "./skills/"
+}

package/lib/memorax-code-claude-adapter/hooks/hook-launcher.mjs

@@ -0,0 +1,27 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  readClientHookShellVersion,
+  runClientHookLauncher,
+} from "../../memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs";
+
+const COMPONENTS = new Set([
+  "capture-cwd",
+  "ensure-backend",
+  "memory-cli-session",
+  "memory-skill-reminder",
+  "memory-turn",
+]);
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+export async function runClaudeHookComponent(component) {
+  if (!COMPONENTS.has(component)) throw new Error(`unsupported Claude Hook component: ${component}`);
+  await runClientHookLauncher({
+    client: "claude-code",
+    component,
+    debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+    fallbackModuleUrl: new URL(`../runtime-hooks/${component}.mjs`, import.meta.url),
+    pluginRoot,
+    shellVersion: readClientHookShellVersion(pluginRoot),
+  });
+}

package/lib/memorax-code-claude-adapter/hooks/hooks.json

@@ -0,0 +1,66 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact|fork",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" ensure-backend",
+            "statusMessage": "Checking MemoraX Code backend",
+            "timeout": 35
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" capture-cwd",
+            "statusMessage": "Capturing MemoraX Code workspace"
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" memory-cli-session",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" capture-cwd",
+            "statusMessage": "Capturing MemoraX Code workspace"
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" memory-turn",
+            "statusMessage": "Retrieving MemoraX Code memory",
+            "timeout": 15
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" memory-skill-reminder",
+            "statusMessage": "Checking MemoraX Code memory reminder"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" capture-cwd",
+            "statusMessage": "Capturing MemoraX Code workspace"
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" memory-turn",
+            "statusMessage": "Saving MemoraX Code memory",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/lib/memorax-code-claude-adapter/hooks/repo-memory-job.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveHookClaudeCommand } from "../../memorax-code-adapter-common/src/clients/claude-command.mjs";
+import { runRepoMemoryJob } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-supervisor.mjs";
+import { evaluateRepository } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-update-policy-evaluator.mjs";
+
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = dirname(hookDir);
+
+try {
+  const payload = runRepoMemoryJob(process.argv.slice(2), {
+    runner: "claude",
+    finalMessageSource: "stdout",
+    memorySkillInvocation: "/memorax-code-claude-adapter:memorax-code",
+    validatorPath: resolve(pluginRoot, "skills/memorax-code/scripts/validate_memory.py"),
+    evaluateRepository,
+    createCommand({ prompt }) {
+      const claude = resolveHookClaudeCommand({
+        pluginRoot: process.env.CLAUDE_PLUGIN_ROOT || pluginRoot,
+      });
+      return [
+        claude,
+        "--print",
+        "--output-format",
+        "text",
+        "--dangerously-skip-permissions",
+        "--no-session-persistence",
+        prompt,
+      ];
+    },
+  });
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}

package/lib/memorax-code-claude-adapter/hooks/runtime-hook.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runClaudeHookComponent } from "./hook-launcher.mjs";
+
+await runClaudeHookComponent(process.argv[2]);

package/lib/memorax-code-claude-adapter/hooks/runtime-shell.json

@@ -0,0 +1,5 @@
+{
+  "version": 1,
+  "shellVersion": "0.1.0",
+  "runtimeAbi": 1
+}

package/lib/memorax-code-claude-adapter/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@memorax-code/claude-adapter",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Claude Code Hook adapter for MemoraX Code memory services.",
+  "bin": {
+    "memorax-code-claude": "src/cli.mjs"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
+}

package/lib/memorax-code-claude-adapter/runtime-hooks/capture-cwd.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { runCaptureCwdHook } from "../../memorax-code-adapter-common/src/hooks/capture-cwd-hook.mjs";
+import { markSupplementalReminderAfterCompact } from "../../memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs";
+import { isRepoMemoryJobWorker } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+const options = {
+  adapterDir: "claude-code",
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  runtime: "claude-code",
+  sessionIdField: "claudeSessionId",
+  sessionKeyPrefix: "claude",
+};
+
+const input = await runCaptureCwdHook(options);
+markSupplementalReminderAfterCompact(options, input);

package/lib/memorax-code-claude-adapter/runtime-hooks/ensure-backend.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  runEnsureBackendHook,
+  stringValue,
+} from "../../memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs";
+
+const DEBUG = process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1";
+
+try {
+  await runEnsureBackendHook({
+    ensureBackendValue: process.env.MEMORAX_CODE_CLAUDE_ENSURE_BACKEND
+      ?? process.env.MEMORAX_CODE_CLAUDE_HOOK_ENSURE_BACKEND,
+    healthTimeoutValue: process.env.MEMORAX_CODE_CLAUDE_ENSURE_TIMEOUT_MS,
+    startTimeoutValue: process.env.MEMORAX_CODE_CLAUDE_START_TIMEOUT_MS,
+    memoraxCodeCommand: stringValue(process.env.MEMORAX_CODE_CLAUDE_LIFECYCLE_COMMAND)
+      ?? stringValue(process.env.MEMORAX_CODE_COMMAND),
+    pluginRoot: pluginRoot(),
+    resolveHomes: hookHomes,
+    buildStartArgs: startArgs,
+    debug,
+  });
+} catch (error) {
+  debug(error instanceof Error ? error.message : String(error));
+}
+
+process.exit(0);
+
+function pluginRoot() {
+  return stringValue(process.env.CLAUDE_PLUGIN_ROOT)
+    ?? stringValue(process.env.PLUGIN_ROOT)
+    ?? dirname(dirname(fileURLToPath(import.meta.url)));
+}
+
+function hookHomes(input = {}) {
+  const memoraxCodeHome = stringValue(process.env.MEMORAX_CODE_HOME) ?? join(homedir(), ".memorax-code");
+  const claudeHome = stringValue(process.env.CLAUDE_CONFIG_DIR)
+    ?? stringValue(input.claude_home)
+    ?? stringValue(input.claudeHome)
+    ?? join(homedir(), ".claude");
+  return { memoraxCodeHome, claudeHome };
+}
+
+function startArgs(homes, recoveryArguments) {
+  return [
+    "start",
+    "--home",
+    homes.memoraxCodeHome,
+    "--claude-home",
+    homes.claudeHome,
+    ...recoveryArguments,
+  ];
+}
+
+function debug(message) {
+  if (DEBUG) console.error(message);
+}

package/lib/memorax-code-claude-adapter/runtime-hooks/memory-cli-session.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { appendFile } from "node:fs/promises";
+import { readStdinJson } from "../../memorax-code-adapter-common/src/config-utils.mjs";
+import { isRepoMemoryJobWorker } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+try {
+  const input = await readStdinJson();
+  const sessionId = stringValue(input.session_id) ?? stringValue(input.sessionId);
+  const envFile = stringValue(process.env.CLAUDE_ENV_FILE);
+  if (sessionId && envFile) {
+    await appendFile(envFile, [
+      "export MEMORAX_CODE_MEMORY_CLI_TRACE_CLIENT='claude'",
+      `export MEMORAX_CODE_MEMORY_CLI_TRACE_SESSION_ID=${shellSingleQuote(sessionId)}`,
+      "",
+    ].join("\n"), "utf8");
+  }
+} catch (error) {
+  if (process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+
+process.exit(0);
+
+function shellSingleQuote(value) {
+  return `'${value.replaceAll("'", "'\"'\"'")}'`;
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-claude-adapter/runtime-hooks/memory-skill-reminder.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  personalMemoryReminderContext,
+  runMemorySkillReminderHook,
+} from "../../memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs";
+import { resolveBackendConnection } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { isRepoMemoryJobWorker } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+import { buildRepoProcedureMemoryContext } from "../../memorax-code-adapter-common/src/repo-memory/repo-procedure-memory-context.mjs";
+import { buildRepoUserProfilePreferencesContext } from "../../memorax-code-adapter-common/src/repo-memory/repo-user-profile-context.mjs";
+
+const MAX_REMINDER_TRACE_TIMEOUT_MS = 1000;
+const MEMORY_SKILL_INVOCATION = "/memorax-code-claude-adapter:memorax-code";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+const personalMemoryContextOptions = {
+  adapterDir: "claude-code",
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  sessionKeyPrefix: "claude",
+};
+
+await runMemorySkillReminderHook({
+  additionalReminderContext: personalMemoryReminderContext(MEMORY_SKILL_INVOCATION),
+  adapterDir: "claude-code",
+  buildCadenceReminderContext: (hookInput) => buildRepoProcedureMemoryContext(hookInput, personalMemoryContextOptions),
+  buildPersonalMemoryContext: (hookInput) => buildRepoUserProfilePreferencesContext(hookInput, personalMemoryContextOptions),
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  memorySkillInvocation: MEMORY_SKILL_INVOCATION,
+  onReminder: recordReminder,
+  remindOnFirstTurn: true,
+  runtime: "claude-code",
+  supplementalReminderAfterCompact: true,
+});
+
+async function recordReminder(reminder) {
+  const promptId = reminder.turnId;
+  if (!promptId || !reminder.transcriptPath) return;
+  const connection = resolveBackendConnection();
+  const timeoutMs = Math.min(
+    parsePositiveInt(
+      process.env.MEMORAX_CODE_CLAUDE_MEMORY_HOOK_TIMEOUT_MS,
+      MAX_REMINDER_TRACE_TIMEOUT_MS,
+    ),
+    MAX_REMINDER_TRACE_TIMEOUT_MS,
+  );
+  const headers = { "content-type": "application/json", connection: "close" };
+  if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+  const response = await fetch(new URL("/memory/skill-reminder", connection.url), {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      version: 1,
+      client: "claude-code",
+      sessionId: reminder.sessionId,
+      promptId,
+      transcriptPath: reminder.transcriptPath,
+      cwd: reminder.cwd,
+      workspaceKind: reminder.workspaceKind,
+      content: reminder.content,
+      triggers: reminder.triggers,
+    }),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    await response.arrayBuffer().catch(() => undefined);
+    throw new Error(`Backend /memory/skill-reminder returned HTTP ${response.status}`);
+  }
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-claude-adapter/runtime-hooks/memory-turn.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { resolveBackendConnection } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { readStdinJson } from "../../memorax-code-adapter-common/src/config-utils.mjs";
+import { isRepoMemoryJobWorker } from "../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+const RETRIEVAL_BACKEND_TIMEOUT_MS = 12_000;
+const DEFAULT_BACKEND_TIMEOUT_MS = 5_000;
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+try {
+  const input = await readStdinJson();
+  const event = stringValue(input.hook_event_name) ?? stringValue(input.hookEventName);
+  const sessionId = stringValue(input.session_id) ?? stringValue(input.sessionId);
+  const promptId = stringValue(input.prompt_id) ?? stringValue(input.promptId);
+  const transcriptPath = stringValue(input.transcript_path) ?? stringValue(input.transcriptPath);
+  if (!sessionId || !promptId || !transcriptPath) process.exit(0);
+
+  if (event === "UserPromptSubmit") {
+    const prompt = stringValue(input.prompt);
+    if (!prompt) process.exit(0);
+    const response = await postMemoryService("/memory/turn-start", {
+      version: 1,
+      client: "claude-code",
+      sessionId,
+      promptId,
+      transcriptPath,
+      prompt,
+      cwd: stringValue(input.cwd),
+      workspaceKind: stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind),
+    });
+    const additionalContext = stringValue(response?.additionalContext);
+    if (additionalContext) {
+      process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext,
+        },
+      })}\n`);
+    }
+  } else if (event === "Stop") {
+    const lastAssistantMessage = stringValue(input.last_assistant_message) ?? stringValue(input.lastAssistantMessage);
+    if (!lastAssistantMessage) process.exit(0);
+    await postMemoryService("/memory/writeback", {
+      version: 1,
+      client: "claude-code",
+      sessionId,
+      promptId,
+      transcriptPath,
+      lastAssistantMessage,
+      cwd: stringValue(input.cwd),
+      workspaceKind: stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind),
+    });
+  }
+} catch (error) {
+  if (process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+
+process.exit(0);
+
+async function postMemoryService(path, body) {
+  const connection = resolveBackendConnection();
+  const timeoutMs = parsePositiveInt(
+    process.env.MEMORAX_CODE_CLAUDE_MEMORY_HOOK_TIMEOUT_MS,
+    path === "/memory/turn-start" ? RETRIEVAL_BACKEND_TIMEOUT_MS : DEFAULT_BACKEND_TIMEOUT_MS,
+  );
+  const headers = { "content-type": "application/json", connection: "close" };
+  if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+  const response = await fetch(new URL(path, connection.url), {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    await response.arrayBuffer().catch(() => undefined);
+    return undefined;
+  }
+  return await response.json().catch(() => undefined);
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}