@memorax/memorax-code 0.1.9 → 0.1.10

package/lib/memorax-code-backend/dist/lifecycle/automatic-update-scheduler.js

@@ -0,0 +1,133 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { AUTOMATIC_UPDATE_RETRY_INTERVAL_MS, readAutomaticUpdateState, } from "../../../memorax-code-adapter-common/src/automatic-update-state.mjs";
+import { readSetupCompletionRecord, } from "../../../memorax-code-adapter-common/src/setup-completion.mjs";
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+export function startBackendAutomaticUpdateScheduler(options, runtime = {}) {
+    const env = options.env ?? process.env;
+    if (automaticUpdateDisabled(env.MEMORAX_CODE_AUTO_UPDATE))
+        return undefined;
+    const packageRoot = nonEmptyString(options.packageRoot);
+    const installedVersion = nonEmptyString(options.packageVersion);
+    if (!packageRoot || !installedVersion)
+        return undefined;
+    const memoraxCodeHome = resolve(options.memoraxCodeHome);
+    const memoraxCodeCommand = join(resolve(packageRoot), "bin", "memorax-code.mjs");
+    if (!(runtime.existsSync ?? existsSync)(memoraxCodeCommand))
+        return undefined;
+    const readCompletion = runtime.readSetupCompletionRecord ?? readSetupCompletionRecord;
+    const readUpdateState = runtime.readAutomaticUpdateState ?? readAutomaticUpdateState;
+    const spawnProcess = runtime.spawnProcess ?? spawn;
+    const now = runtime.now ?? Date.now;
+    const setTimer = runtime.setTimeout
+        ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    const clearTimer = runtime.clearTimeout
+        ?? ((handle) => clearTimeout(handle));
+    let closed = false;
+    let childRunning = false;
+    let timer;
+    let suppressImmediate = env.MEMORAX_CODE_AUTOMATIC_UPDATE_PROCESS === "1";
+    const debug = (message) => options.debug?.(message);
+    const scheduleAfter = (delayMs) => {
+        if (closed)
+            return;
+        if (timer !== undefined)
+            clearTimer(timer);
+        timer = setTimer(() => {
+            timer = undefined;
+            reconcile();
+        }, Math.max(1, Math.min(MAX_TIMER_DELAY_MS, Math.trunc(delayMs))));
+        timer.unref?.();
+    };
+    const scheduleRetry = () => scheduleAfter(AUTOMATIC_UPDATE_RETRY_INTERVAL_MS);
+    const launch = () => {
+        let child;
+        try {
+            child = spawnProcess(process.execPath, [memoraxCodeCommand, "update", "--automatic", "--home", memoraxCodeHome], {
+                detached: true,
+                env: {
+                    ...env,
+                    MEMORAX_CODE_AUTOMATIC_UPDATE_PROCESS: "1",
+                    MEMORAX_CODE_HOME: memoraxCodeHome,
+                },
+                stdio: "ignore",
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            debug(`MemoraX Code automatic update could not start: ${errorMessage(error)}`);
+            scheduleRetry();
+            return;
+        }
+        childRunning = true;
+        let settled = false;
+        const finish = (successful) => {
+            if (settled)
+                return;
+            settled = true;
+            childRunning = false;
+            if (!closed)
+                reconcile(!successful);
+        };
+        child.once("error", (error) => {
+            debug(`MemoraX Code automatic update could not start: ${error.message}`);
+            finish(false);
+        });
+        child.once("close", (code, signal) => finish(signal === null && code === 0));
+        child.unref();
+    };
+    function reconcile(deferDue = false) {
+        if (closed || childRunning)
+            return;
+        const suppressDue = suppressImmediate;
+        suppressImmediate = false;
+        try {
+            const completion = readCompletion(memoraxCodeHome);
+            const state = readUpdateState(memoraxCodeHome);
+            const nowMs = Number(now());
+            if (!Number.isFinite(nowMs))
+                throw new TypeError("automatic update scheduler clock is invalid");
+            if (completion.status !== "valid") {
+                scheduleRetry();
+                return;
+            }
+            if (state.status === "valid" && state.record.installedVersion === installedVersion) {
+                const remainingMs = Date.parse(state.record.nextCheckAt) - nowMs;
+                if (remainingMs > 0) {
+                    scheduleAfter(remainingMs);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            debug(`MemoraX Code automatic update scheduling failed: ${errorMessage(error)}`);
+            scheduleRetry();
+            return;
+        }
+        if (suppressDue || deferDue)
+            scheduleRetry();
+        else
+            launch();
+    }
+    reconcile();
+    return {
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            if (timer !== undefined)
+                clearTimer(timer);
+            timer = undefined;
+        },
+    };
+}
+function automaticUpdateDisabled(value) {
+    return ["0", "false", "no", "off", "disabled"].includes(String(value ?? "").trim().toLowerCase());
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/memorax-code-backend/dist/lifecycle/client-plugin-removal.js

@@ -8,6 +8,7 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
     const claudePluginInstaller = await loadClaudePluginInstaller();
     const dshProfileLifecycle = await loadDshProfileLifecycle();
     const openCodePluginInstaller = await loadOpenCodePluginInstaller();
+    const codeBuddyPluginInstaller = await loadCodeBuddyPluginInstaller();
     const home = resolveHome(options.homeDir);
     const memoraxCodeHome = resolve(options.memoraxCodeHome ?? process.env.MEMORAX_CODE_HOME ?? join(home, ".memorax-code"));
     const claudeState = await readJsonRecord(join(memoraxCodeHome, "adapters", "claude-code", "state.json"));
@@ -15,7 +16,7 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
     return async () => {
         try {
             return await withBackendLifecycleLock({ home: memoraxCodeHome }, async () => {
-                const [codexPlugin, claudePlugin, dshPlugin, opencodePlugin] = await Promise.all([
+                const [codexPlugin, claudePlugin, dshPlugin, opencodePlugin, codebuddyPlugin] = await Promise.all([
                     cleanupCodexAfterBackendRemoval({
                         memoraxCodeHome,
                         homeDir: home,
@@ -45,14 +46,21 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
                             : {}),
                     }))
                         .catch((error) => removalFailure("opencode-plugin-remove", error)),
+                    Promise.resolve()
+                        .then(() => codeBuddyPluginInstaller.removeCodeBuddyPluginInstallation({
+                        memoraxCodeHome,
+                        ...(options.codeBuddyHome ? { codeBuddyHome: options.codeBuddyHome } : {}),
+                    }))
+                        .catch((error) => removalFailure("codebuddy-plugin-remove", error)),
                 ]);
                 return {
-                    ok: codexPlugin.ok && claudePlugin.ok && dshPlugin.ok && opencodePlugin.ok,
+                    ok: codexPlugin.ok && claudePlugin.ok && dshPlugin.ok && opencodePlugin.ok && codebuddyPlugin.ok,
                     action: "client-plugin-removal-cleanup",
                     codexPlugin,
                     claudePlugin,
                     dshPlugin,
                     opencodePlugin,
+                    codebuddyPlugin,
                 };
             });
         }
@@ -65,6 +73,7 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
                 claudePlugin: failure,
                 dshPlugin: failure,
                 opencodePlugin: failure,
+                codebuddyPlugin: failure,
             };
         }
     };
@@ -75,6 +84,9 @@ async function loadClaudePluginInstaller() {
 async function loadOpenCodePluginInstaller() {
     return await import(new URL("../../../memorax-code-opencode-adapter/src/plugin-install.mjs", import.meta.url).href);
 }
+async function loadCodeBuddyPluginInstaller() {
+    return await import(new URL("../../../memorax-code-codebuddy-adapter/src/config.mjs", import.meta.url).href);
+}
 async function loadDshProfileLifecycle() {
     return await import(new URL("../../../memorax-code-dsh-adapter/src/profile-lifecycle.mjs", import.meta.url).href);
 }

package/lib/memorax-code-backend/dist/lifecycle/client-selection.js

@@ -1,5 +1,5 @@
 import { loadLifecycleMemoraxCodeConfig } from "../config/memorax-code.js";
-const allClients = Object.freeze({ codex: true, claude: true, dsh: true, opencode: true });
+const allClients = Object.freeze({ codex: true, claude: true, dsh: true, opencode: true, codebuddy: true });
 export function resolveManagedClients(argv, config = {}) {
     const explicit = argValue(argv, "--clients");
     if (explicit !== undefined)
@@ -12,9 +12,10 @@ export function resolveManagedClients(argv, config = {}) {
             // automatic local-Harness discovery enabled for existing installations.
             dsh: config.clients.dsh !== false,
             opencode: config.clients.opencode === true,
+            ...(config.clients.codebuddy === true ? { codebuddy: true } : {}),
         };
     }
-    return allClients;
+    return { codex: true, claude: true, dsh: true, opencode: true };
 }
 export function parseManagedClients(value) {
     const normalized = value.trim().toLowerCase();
@@ -23,14 +24,15 @@ export function parseManagedClients(value) {
     if (normalized === "none")
         return { codex: false, claude: false, dsh: false, opencode: false };
     const names = normalized.split(",").map((name) => name.trim()).filter(Boolean);
-    if (names.length === 0 || names.some((name) => (name !== "codex" && name !== "claude" && name !== "dsh" && name !== "opencode"))) {
-        throw new Error(`invalid --clients value: ${value}; expected a comma-separated subset of codex, claude, dsh, opencode, or all or none`);
+    if (names.length === 0 || names.some((name) => (name !== "codex" && name !== "claude" && name !== "dsh" && name !== "opencode" && name !== "codebuddy"))) {
+        throw new Error(`invalid --clients value: ${value}; expected a comma-separated subset of codex, claude, dsh, opencode, codebuddy, or all or none`);
     }
     return {
         codex: names.includes("codex"),
         claude: names.includes("claude"),
         dsh: names.includes("dsh"),
         opencode: names.includes("opencode"),
+        ...(names.includes("codebuddy") ? { codebuddy: true } : {}),
     };
 }
 export function loadManagedClientsConfig(memoraxCodeHome) {

package/lib/memorax-code-backend/dist/lifecycle/orchestrator.js

@@ -17,6 +17,7 @@ import { codexAdapterLifecycle } from "../clients/codex/lifecycle.js";
 import { claudeAdapterLifecycle } from "../clients/claude/lifecycle.js";
 import { collectDshAdapterLifecycleStatus, withDshAdapterLifecycleLock, } from "../clients/dsh/lifecycle.js";
 import { openCodeAdapterLifecycle } from "../clients/opencode/lifecycle.js";
+import { codeBuddyAdapterLifecycle } from "../clients/codebuddy/lifecycle.js";
 const PACKAGE_REPLACEMENT_ENV = "MEMORAX_CODE_PACKAGE_REPLACEMENT";
 const DSH_OPTIONAL_ENV = "MEMORAX_CODE_DSH_ADAPTER_OPTIONAL";
 const DSH_RECOVERY_ENV = "MEMORAX_CODE_DSH_ADAPTER_RECOVERY";
@@ -58,15 +59,20 @@ export async function collectMemoraxCodeStatus(backendUrl, backendToken, service
     const opencodeAdapter = clients.opencode
         ? await openCodeAdapterLifecycle.status({ argv, serviceOptions, backendUrl })
         : undefined;
+    const codebuddyAdapter = clients.codebuddy
+        ? await codeBuddyAdapterLifecycle.status({ argv, serviceOptions, backendUrl })
+        : undefined;
     const codexReady = codexAdapter ? isAdapterReady(codexAdapter) : true;
     const claudeReady = claudeAdapter ? isAdapterReady(claudeAdapter) : true;
     const dshReady = dshAdapter ? isAdapterReady(dshAdapter) : true;
     const opencodeReady = opencodeAdapter ? isAdapterReady(opencodeAdapter) : true;
+    const codebuddyReady = codebuddyAdapter ? isAdapterReady(codebuddyAdapter) : true;
     const optionalDshUnavailable = isOptionalUnavailableDshAdapter(dshAdapter);
     return {
         ok: backend.ok
             && codexReady
             && opencodeReady
+            && codebuddyReady
             && (isOptionalUnconfiguredClaudeAdapter(claudeAdapter, codexAdapter) || claudeReady)
             && (optionalDshUnavailable || dshReady),
         action: "status",
@@ -76,6 +82,7 @@ export async function collectMemoraxCodeStatus(backendUrl, backendToken, service
         ...(claudeAdapter ? { claudeAdapter } : {}),
         ...(dshAdapter ? { dshAdapter } : {}),
         ...(opencodeAdapter ? { opencodeAdapter } : {}),
+        ...(codebuddyAdapter ? { codebuddyAdapter } : {}),
     };
 }
 export async function startMemoraxCodeService(serviceOptions, argv, commitReadyState) {
@@ -193,10 +200,14 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
     const deselectedOpenCode = previousClients?.opencode && !clients.opencode
         ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
         : undefined;
+    const deselectedCodeBuddy = previousClients?.codebuddy && !clients.codebuddy
+        ? await codeBuddyAdapterLifecycle.disable({ argv, serviceOptions })
+        : undefined;
     if (deselectedCodex?.ok === false
         || deselectedClaude?.ok === false
         || deselectedDsh?.ok === false
-        || deselectedOpenCode?.ok === false) {
+        || deselectedOpenCode?.ok === false
+        || deselectedCodeBuddy?.ok === false) {
         const recovery = await recoverPreparationFailure("adapter_disable_failed");
         return {
             ok: false,
@@ -208,6 +219,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
                 ? { dshAdapter: recovery.dshAdapter ?? deselectedDsh }
                 : {}),
             ...(deselectedOpenCode ? { opencodeAdapter: deselectedOpenCode } : {}),
+            ...(deselectedCodeBuddy ? { codebuddyAdapter: deselectedCodeBuddy } : {}),
         };
     }
     // The marker is a conservative cleanup scope, not a readiness signal. Persist
@@ -247,6 +259,9 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
     const opencodeAdapter = clients.opencode
         ? await openCodeAdapterLifecycle.prepareEnable({ argv, serviceOptions, backendUrl })
         : undefined;
+    const codebuddyAdapter = clients.codebuddy
+        ? await codeBuddyAdapterLifecycle.prepareEnable({ argv, serviceOptions, backendUrl })
+        : undefined;
     if (opencodeAdapter?.ok === false) {
         const recovery = await recoverPreparationFailure("opencode_adapter_enable_failed");
         return {
@@ -257,6 +272,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
             ...(claudeAdapter ? { claudeAdapter } : {}),
             ...(recovery.dshAdapter ? { dshAdapter: recovery.dshAdapter } : {}),
             opencodeAdapter,
+            ...(codebuddyAdapter ? { codebuddyAdapter } : {}),
         };
     }
     const preparedDshAdapter = markOptionalDshAdapter(quiescedDsh?.ok === false
@@ -274,6 +290,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
             ...(claudeAdapter ? { claudeAdapter } : {}),
             dshAdapter: recovery.dshAdapter ?? preparedDshAdapter,
             ...(opencodeAdapter ? { opencodeAdapter } : {}),
+            ...(codebuddyAdapter ? { codebuddyAdapter } : {}),
         };
     }
     const backend = await startBackendService(serviceOptions);
@@ -284,6 +301,9 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
         const disabledOpenCode = opencodeAdapter
             ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
             : undefined;
+        const disabledCodeBuddy = codebuddyAdapter
+            ? await codeBuddyAdapterLifecycle.disable({ argv, serviceOptions })
+            : undefined;
         return {
             ok: false,
             action: "start",
@@ -292,6 +312,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
             ...(claudeAdapter ? { claudeAdapter } : {}),
             ...(preparedDshAdapter ? { dshAdapter: preparedDshAdapter } : {}),
             ...(disabledOpenCode ? { opencodeAdapter: disabledOpenCode } : {}),
+            ...(disabledCodeBuddy ? { codebuddyAdapter: disabledCodeBuddy } : {}),
         };
     }
     const dshAdapter = markOptionalDshAdapter(preparedDshAdapter?.installed === true
@@ -308,6 +329,7 @@ async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memorax
         ...(claudeAdapter ? { claudeAdapter } : {}),
         ...(dshAdapter ? { dshAdapter } : {}),
         ...(opencodeAdapter ? { opencodeAdapter } : {}),
+        ...(codebuddyAdapter ? { codebuddyAdapter } : {}),
     };
 }
 function expectedBackendUrl(serviceOptions) {
@@ -350,13 +372,15 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycl
             claude: activeClients.claude && !clients.claude,
             dsh: activeClients.dsh && !clients.dsh,
             opencode: activeClients.opencode && !clients.opencode,
+            codebuddy: activeClients.codebuddy && !clients.codebuddy,
         }
         : undefined;
     const hasRemainingClients = remaining?.codex === true
         || remaining?.claude === true
         || remaining?.dsh === true
-        || remaining?.opencode === true;
-    const backendOnlyStop = !clients.codex && !clients.claude && !clients.dsh && !clients.opencode;
+        || remaining?.opencode === true
+        || remaining?.codebuddy === true;
+    const backendOnlyStop = !clients.codex && !clients.claude && !clients.dsh && !clients.opencode && !clients.codebuddy;
     const packageReplacement = isPackageReplacement();
     const needsBackendStop = packageReplacement || backendOnlyStop || !hasRemainingClients;
     const quiescedDsh = clients.dsh && dshLifecycle
@@ -405,10 +429,14 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycl
     const opencodeAdapter = clients.opencode
         ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
         : undefined;
+    const codebuddyAdapter = clients.codebuddy
+        ? await codeBuddyAdapterLifecycle.disable({ argv, serviceOptions })
+        : undefined;
     const adaptersOk = codexAdapter?.ok !== false
         && claudeAdapter?.ok !== false
         && dshAdapter?.ok !== false
-        && opencodeAdapter?.ok !== false;
+        && opencodeAdapter?.ok !== false
+        && codebuddyAdapter?.ok !== false;
     const backend = stoppedBackend
         ?? (adaptersOk
             ? preservedBackendResult(serviceOptions, "active_clients_remaining")
@@ -417,7 +445,8 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycl
         && codexAdapter?.ok !== false
         && claudeAdapter?.ok !== false
         && dshAdapter?.ok !== false
-        && opencodeAdapter?.ok !== false;
+        && opencodeAdapter?.ok !== false
+        && codebuddyAdapter?.ok !== false;
     return {
         report: {
             ok,
@@ -427,6 +456,7 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycl
             ...(claudeAdapter ? { claudeAdapter } : {}),
             ...(dshAdapter ? { dshAdapter } : {}),
             ...(opencodeAdapter ? { opencodeAdapter } : {}),
+            ...(codebuddyAdapter ? { codebuddyAdapter } : {}),
         },
         remainingClients: packageReplacement
             ? activeClients
@@ -535,10 +565,14 @@ async function executeMemoraxCodeUninstall(serviceOptions, argv, context, dshLif
     const opencodePlugin = clients.opencode
         ? await openCodeAdapterLifecycle.remove({ argv, serviceOptions })
         : undefined;
+    const codebuddyPlugin = clients.codebuddy
+        ? await codeBuddyAdapterLifecycle.remove({ argv, serviceOptions })
+        : undefined;
     const pluginCleanupOk = codexPlugin?.ok !== false
         && claudePlugin?.ok !== false
         && dshPlugin?.ok !== false
-        && opencodePlugin?.ok !== false;
+        && opencodePlugin?.ok !== false
+        && codebuddyPlugin?.ok !== false;
     const npmPackageRemoval = !pluginCleanupOk
         ? skippedNpmPackageRemoval("plugin_cleanup_failed")
         : canRemoveSharedPackage
@@ -562,11 +596,13 @@ async function executeMemoraxCodeUninstall(serviceOptions, argv, context, dshLif
         ...(claudeAdapter ? { claudeAdapter } : {}),
         ...(dshAdapter ? { dshAdapter } : {}),
         ...(opencodeAdapter ? { opencodeAdapter } : {}),
+        ...(codebuddyPlugin ? { codebuddyPlugin } : {}),
         npmPackageRemoval,
         removesPlugin: codexPlugin?.ok === true
             || claudePlugin?.ok === true
             || (dshPlugin?.ok === true && dshPlugin.skipped !== true)
-            || opencodePlugin?.ok === true,
+            || opencodePlugin?.ok === true
+            || codebuddyPlugin?.ok === true,
         removesUserState: false,
     };
 }
@@ -691,7 +727,8 @@ function includesManagedClients(selection, required) {
     return (!required.codex || selection.codex)
         && (!required.claude || selection.claude)
         && (!required.dsh || selection.dsh)
-        && (!required.opencode || selection.opencode);
+        && (!required.opencode || selection.opencode)
+        && (!required.codebuddy || selection.codebuddy === true);
 }
 function isPackageReplacement() {
     return truthyEnv(process.env[PACKAGE_REPLACEMENT_ENV]);
@@ -819,7 +856,9 @@ export function isAdapterReady(report) {
         && report.backendUrlMatches !== false
         && report.codexSkills?.ok !== false
         && report.claudeSkills?.ok !== false
-        && report.opencodeSkills?.ok !== false;
+        && report.opencodeSkills?.ok !== false
+        && report.codebuddyHooks?.ok !== false
+        && report.codebuddySkills?.ok !== false;
 }
 export function isOptionalUnavailableDshAdapter(report) {
     return Boolean(report?.optional === true && !isAdapterReady(report));

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

@@ -238,9 +238,9 @@ async function resolveMemoryCliRepositoryMemory(options) {
 }
 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."
+        ? "Start a new Codex, Claude Code, WorkBuddy, 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."
+            ? "Start a new Codex, Claude Code, WorkBuddy, 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,
@@ -336,6 +336,8 @@ function traceClientLabel(client) {
         return "DSH";
     if (client === "opencode")
         return "OpenCode";
+    if (client === "codebuddy")
+        return "WorkBuddy";
     return client === "codex" ? "Codex" : "coding agent";
 }
 function memoryAddContentOptions(args) {

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

@@ -1,4 +1,5 @@
 import { isRecord } from "../shared/record.js";
+import { codeBuddyPromptDigest, parseCodeBuddyTurnId } from "../clients/codebuddy/turn-id.js";
 export const MEMORY_HOOK_COMMAND_VERSION = 1;
 export const INVALID_MEMORY_HOOK_COMMAND = "invalid memory Hook command";
 const BASE_COMMAND_KEYS = [
@@ -13,6 +14,7 @@ const TURN_START_KEYS = {
     "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"]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "prompt", "transcriptPath"]),
 };
 const WRITEBACK_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "lastAssistantMessage", "transcriptPath"]),
@@ -39,12 +41,14 @@ const WRITEBACK_KEYS = {
         "sessionHeader",
         "events",
     ]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "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"]),
     dsh: new Set(["version", "client", "sessionId", "turn", "cwd", "content", "triggers"]),
     opencode: new Set([...BASE_COMMAND_KEYS, "userMessageId", "content", "triggers"]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "transcriptPath", "content", "triggers"]),
 };
 export function parseTurnStartCommand(value) {
     if (!isRecord(value))
@@ -102,6 +106,13 @@ export function parseTurnStartCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId, prompt))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, prompt, transcriptPath } };
+    }
     const promptId = requiredStringField(value, "promptId");
     const transcriptPath = requiredStringField(value, "transcriptPath");
     if (!promptId || !transcriptPath)
@@ -166,6 +177,13 @@ export function parseWritebackCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, transcriptPath } };
+    }
     const lastAssistantMessage = requiredStringField(value, "lastAssistantMessage");
     if (!lastAssistantMessage)
         return invalidCommand();
@@ -241,6 +259,13 @@ export function parseSkillReminderCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, transcriptPath, content, triggers } };
+    }
     const transcriptPath = requiredStringField(value, "transcriptPath");
     if (!transcriptPath)
         return invalidCommand();
@@ -284,7 +309,8 @@ function parseCommandBase(value, allowedKeys) {
     if (client !== "codex"
         && client !== "claude-code"
         && client !== "opencode"
-        && client !== "dsh")
+        && client !== "dsh"
+        && client !== "codebuddy")
         return undefined;
     const clientKeys = allowedKeys[client];
     if (!clientKeys || Object.keys(value).some((key) => !clientKeys.has(key)))
@@ -342,6 +368,10 @@ function optionalStringField(value, key) {
     const field = requiredStringField(value, key);
     return field ? { ok: true, value: field } : { ok: false };
 }
+function validCodeBuddyTurnId(turnId, sessionId, prompt) {
+    const identity = parseCodeBuddyTurnId({ sessionId, turnId });
+    return Boolean(identity && (prompt === undefined || identity.promptDigest === codeBuddyPromptDigest(prompt)));
+}
 function invalidCommand() {
     return { ok: false, error: INVALID_MEMORY_HOOK_COMMAND };
 }

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

@@ -1,5 +1,5 @@
 import { parseSkillReminderCommand, } from "./hook-command.js";
-import { traceContextFromClaudeHookBody, traceContextFromDshSkillReminder, traceContextFromHookBody, traceContextFromOpenCodeHookBody, } from "../trace/context.js";
+import { traceContextFromClaudeHookBody, traceContextFromDshSkillReminder, traceContextFromHookBody, traceContextFromOpenCodeHookBody, traceContextFromCodeBuddyHookBody, } from "../trace/context.js";
 import { recordTraceEvent } from "../trace/store.js";
 export function createMemoryReminderTraceRecorder(options = {}) {
     return {
@@ -47,6 +47,8 @@ function traceContextForReminder(command) {
         return traceContextFromClaudeHookBody(command);
     if (command.client === "dsh")
         return traceContextFromDshSkillReminder(command);
+    if (command.client === "codebuddy")
+        return traceContextFromCodeBuddyHookBody(command);
     return traceContextFromOpenCodeHookBody(command);
 }
 function reminderSource(command) {
@@ -56,6 +58,8 @@ function reminderSource(command) {
         return "claude-hook";
     if (command.client === "dsh")
         return "dsh-cordis";
+    if (command.client === "codebuddy")
+        return "codebuddy-hook";
     return "opencode-plugin";
 }
 async function recordTraceBestEffort(label, promise, diagnosticLogger) {

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

@@ -3,6 +3,7 @@ import { createCodexMemoryHookRuntime, } from "../clients/codex/memory-hook-runt
 import { createClaudeMemoryHookRuntime, } from "../clients/claude/memory-hook-runtime.js";
 import { createDshMemoryHookRuntime, } from "../clients/dsh/memory-hook-runtime.js";
 import { createOpenCodeMemoryHookRuntime, } from "../clients/opencode/memory-hook-runtime.js";
+import { createCodeBuddyMemoryHookRuntime } from "../clients/codebuddy/memory-hook-runtime.js";
 import { createMemoryTurnCoordinator } from "./turn-coordinator.js";
 import { createRepositoryMemorySessionRuntime, } from "./repository-session.js";
 import { createPendingQuotaNoticeRuntime } from "./quota-notice.js";
@@ -49,6 +50,12 @@ export function createMemoryService(options = {}) {
         repositoryMemorySession,
         turnCoordinator,
     });
+    const codeBuddyHook = createCodeBuddyMemoryHookRuntime({
+        ...options,
+        pendingQuotaNotice,
+        repositoryMemorySession,
+        turnCoordinator,
+    });
     let closed = false;
     return {
         async recordTurnStart(command) {
@@ -61,6 +68,8 @@ export function createMemoryService(options = {}) {
                     return await openCodeHook.recordTurnStart(command);
                 case "dsh":
                     return await dshHook.recordTurnStart(command);
+                case "codebuddy":
+                    return await codeBuddyHook.recordTurnStart(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -74,6 +83,8 @@ export function createMemoryService(options = {}) {
                     return await openCodeHook.writeback(command);
                 case "dsh":
                     return await dshHook.writeback(command);
+                case "codebuddy":
+                    return await codeBuddyHook.writeback(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -88,6 +99,7 @@ export function createMemoryService(options = {}) {
             claudeHook.close();
             openCodeHook.close();
             dshHook.close();
+            codeBuddyHook.close();
             turnCoordinator.close();
             repositoryMemorySession.close();
             automaticWriteback.close();

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

@@ -25,6 +25,9 @@ export function resolveWindowsCliInvocation(command, args, options = {}) {
     resolvedCommand ??= command;
     if (/\.(?:exe|com)$/i.test(resolvedCommand))
         return { command: resolvedCommand, args };
+    if (isBareCodeBuddyEntrypoint(resolvedCommand, pathApi) && fileExists(resolvedCommand)) {
+        return { command: options.nodePath ?? process.execPath, args: [resolvedCommand, ...args] };
+    }
     if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
         throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
     }
@@ -87,12 +90,18 @@ export function selectWindowsCommandCandidate(command, output) {
         .map((value) => value.trim())
         .filter(Boolean);
     const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
-        ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+        ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value))
+        ?? (path.win32.basename(command).toLowerCase() === "codebuddy"
+            ? candidates.find((value) => isBareCodeBuddyEntrypoint(value, path.win32))
+            : undefined);
     if (!selected) {
         throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
     }
     return selected;
 }
+function isBareCodeBuddyEntrypoint(value, pathApi) {
+    return pathApi.basename(value).toLowerCase() === "codebuddy" && pathApi.extname(value) === "";
+}
 export function resolveWindowsNpmInvocation(args, env, options = {}) {
     const platform = options.platform ?? process.platform;
     if (platform !== "win32")