@memorax/memorax-code 0.1.8 → 0.1.10

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

@@ -8,7 +8,8 @@ import { createBackendServer } from "../app/backend-server.js";
 import { backendDebug } from "../shared/debug-log.js";
 import { prepareClientPluginRemovalCleanup } from "../lifecycle/client-plugin-removal.js";
 import { resolveBackendInstallWatchdogConfig, startBackendInstallWatchdog, } from "../lifecycle/install-watchdog.js";
-import { activateCodexPlugin, installCodexPlugin } from "../clients/codex/plugin-install.js";
+import { startBackendAutomaticUpdateScheduler, } from "../lifecycle/automatic-update-scheduler.js";
+import { activateCodexPlugin, inspectCodexPluginRegistration, installCodexPlugin, } from "../clients/codex/plugin-install.js";
 import { inspectCodexPluginHooks, trustCodexPluginHooks } from "../clients/codex/plugin-hooks.js";
 import { collectMemoraxCodeStatus, isAdapterReady, isOptionalUnavailableDshAdapter, isOptionalUnconfiguredClaudeAdapter, restartMemoraxCodeService, startMemoraxCodeService, stopMemoraxCodeService, uninstallMemoraxCodeService, } from "../lifecycle/orchestrator.js";
 import { backendEnv } from "../config/backend-env.js";
@@ -29,9 +30,9 @@ export function runBackendCli(argv = process.argv) {
             `Usage: ${usageName} [${commands}] [--backend-url URL] [--backend-token TOKEN] [--home DIR]`,
             "[--host HOST] [--port PORT] [--rotate] [--show]",
             "[--codex-command CMD]",
-            "[--codex-home DIR] [--claude-home DIR] [--dsh-home DIR] [--opencode-config-dir DIR]",
+            "[--codex-home DIR] [--claude-home DIR] [--dsh-home DIR] [--opencode-config-dir DIR] [--codebuddy-home DIR]",
             "[--dsh-command CMD] [--dsh-adapter-root DIR] [--memorax-code-command CMD]",
-            "[--clients codex|claude|dsh|opencode|CLIENT,...|all|none]",
+            "[--clients codex|claude|dsh|opencode|codebuddy|CLIENT,...|all|none]",
             "[--json]",
             "[--marketplace-path FILE] [--plugin-source-path DIR] [--claude-command CMD] [--help]",
             "[--yes]",
@@ -210,12 +211,14 @@ async function startRawBackendServer(state, host, port, argv) {
             dshHome: argValue(argv, "--dsh-home"),
             dshAdapterRoot: argValue(argv, "--dsh-adapter-root"),
             openCodeConfigDir: argValue(argv, "--opencode-config-dir"),
+            codeBuddyHome: argValue(argv, "--codebuddy-home"),
             codexCommand: argValue(argv, "--codex-command"),
             claudeCommand: argValue(argv, "--claude-command"),
             dshCommand: argValue(argv, "--dsh-command"),
         })
         : undefined;
     const server = createBackendServer(state);
+    let automaticUpdateScheduler;
     let installRemovalStarted = false;
     const installWatchdog = startBackendInstallWatchdog(installWatchdogConfig, async (event) => {
         if (installRemovalStarted)
@@ -245,7 +248,10 @@ async function startRawBackendServer(state, host, port, argv) {
         });
     });
     installBackendShutdownControls(server, state);
-    server.once("close", () => installWatchdog?.close());
+    server.once("close", () => {
+        automaticUpdateScheduler?.close();
+        installWatchdog?.close();
+    });
     server.on("error", (error) => {
         if (error.code === "EADDRINUSE") {
             console.error(`memorax-code-backend failed to listen on http://${host}:${port}: address already in use`);
@@ -258,6 +264,15 @@ async function startRawBackendServer(state, host, port, argv) {
     });
     server.listen(port, host, () => {
         console.log(`memorax-code-backend listening on http://${host}:${port}`);
+        if (backendEnv("INSTANCE_ID")) {
+            automaticUpdateScheduler = startBackendAutomaticUpdateScheduler({
+                env: process.env,
+                memoraxCodeHome: state.sessionHome,
+                packageRoot: process.env.MEMORAX_CODE_NPM_PACKAGE_ROOT,
+                packageVersion: process.env.MEMORAX_CODE_NPM_PACKAGE_VERSION,
+                debug: (message) => backendDebug("automatic_update.scheduler_failed", { message }),
+            });
+        }
     });
 }
 function installBackendShutdownControls(server, state) {
@@ -382,6 +397,13 @@ async function runCodexPluginCommand(argv) {
             yes: argv.includes("--yes"),
         });
     }
+    if (subcommand === "registration") {
+        return await inspectCodexPluginRegistration({
+            codexHome: argValue(argv, "--codex-home"),
+            codexCommand: argValue(argv, "--codex-command"),
+            workspace: argValue(argv, "--workspace"),
+        });
+    }
     if (subcommand === "hooks") {
         return await inspectCodexPluginHooks({
             codexHome: argValue(argv, "--codex-home"),
@@ -427,6 +449,15 @@ function printCodexPluginInstallResult(report) {
         console.log("backend: not started");
         return;
     }
+    if (report.action === "codex-plugin-registration") {
+        console.log(`codex home: ${report.codexHome}`);
+        console.log(`registered: ${report.registered ? "yes" : "no"}`);
+        console.log(`enabled: ${report.enabled ? "yes" : "no"}`);
+        if (report.version)
+            console.log(`version: ${report.version}`);
+        console.log("backend: not started");
+        return;
+    }
     const install = report.action === "codex-plugin-activate" ? report.install : report;
     console.log(`codex home: ${install.codexHome}`);
     console.log(`plugin source: ${install.pluginSourcePath}`);
@@ -490,6 +521,8 @@ function printMemoraxCodeStatus(report) {
         backendLog(`DSH adapter: ${dshAdapterStatusLine(report.dshAdapter)}`);
     if (report.opencodeAdapter)
         backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
+    if (report.codebuddyAdapter)
+        backendLog(`CodeBuddy adapter: ${adapterStatusLine(report.codebuddyAdapter)}`);
     if (!suppressBackendGuidance()) {
         for (const line of statusGuidance(report))
             backendLog(line);
@@ -591,6 +624,8 @@ function printLifecycleResult(report) {
         backendLog(`DSH adapter: ${dshAdapterStatusLine(report.dshAdapter)}`);
     if (report.opencodeAdapter)
         backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
+    if (report.codebuddyAdapter)
+        backendLog(`CodeBuddy adapter: ${adapterStatusLine(report.codebuddyAdapter)}`);
     if (report.codexPlugin) {
         const removed = report.codexPlugin.removedPaths.length;
         const marketplace = report.codexPlugin.marketplaceChanged ? " marketplace=updated" : " marketplace=unchanged";
@@ -848,11 +883,13 @@ function adapterStatusLine(report) {
     const enabled = isAdapterReady(report);
     const skillStatus = report.codexSkills?.status
         ?? report.claudeSkills?.status
-        ?? report.opencodeSkills?.status;
+        ?? report.opencodeSkills?.status
+        ?? report.codebuddySkills?.status;
     const skills = skillStatus ? ` skills=${skillStatus}` : "";
+    const hooks = report.codebuddyHooks?.status ? ` hook-runtime=${report.codebuddyHooks.status}` : "";
     const changed = report.changed === true ? " changed" : "";
     const integration = report.integration ?? report.state?.integration ?? "hooks";
-    return `${enabled ? "ok" : "not enabled"} integration=${integration}${skills}${changed}`;
+    return `${enabled ? "ok" : "not enabled"} integration=${integration}${skills}${hooks}${changed}`;
 }
 function selectedLifecycleClientNames(report) {
     return [

package/lib/memorax-code-backend/dist/lifecycle/active-clients.js

@@ -10,6 +10,8 @@ export function readActiveManagedClients(memoraxCodeHome) {
             return undefined;
         if (value.opencode !== undefined && typeof value.opencode !== "boolean")
             return undefined;
+        if (value.codebuddy !== undefined && typeof value.codebuddy !== "boolean")
+            return undefined;
         if (value.dsh !== undefined && typeof value.dsh !== "boolean")
             return undefined;
         return {
@@ -19,6 +21,7 @@ export function readActiveManagedClients(memoraxCodeHome) {
             // that the Backend was serving DSH.
             dsh: value.dsh === true,
             opencode: value.opencode === true,
+            ...(value.codebuddy === true ? { codebuddy: true } : {}),
         };
     }
     catch {

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) {