@memorax/memorax-code 0.1.9 → 0.1.11

package/lib/memorax-code-backend/dist/clients/codebuddy/memory-hook-runtime.js

@@ -0,0 +1,250 @@
+import { readCodeBuddyInterruptedTranscriptTurn, readCodeBuddyTranscriptTurn, } from "./jsonl-history.js";
+import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { createAutomaticMemoryWritebackRuntime } from "../../memory/automatic-writeback.js";
+import { claimQuotaNotice, createPendingQuotaNoticeRuntime, } from "../../memory/quota-notice.js";
+import { createMemoryTurnCoordinator } from "../../memory/turn-coordinator.js";
+import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree } from "../../memory/repository-session.js";
+import { traceContextFromCodeBuddyHookBody } from "../../trace/context.js";
+import { markCurrentCodeBuddyTurnOutcome, readOpenTraceTurn, recordCodeBuddyTraceEvent, traceTurnEventId, writeCurrentCodeBuddyTurn, } from "../../trace/store.js";
+export function createCodeBuddyMemoryHookRuntime(options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const pendingQuotaNotice = options.pendingQuotaNotice ?? createPendingQuotaNoticeRuntime({
+        claimQuotaNotice: options.claimQuotaNotice,
+        diagnosticLogger: options.diagnosticLogger,
+        env: options.env,
+    });
+    const ownsPendingQuotaNotice = options.pendingQuotaNotice === undefined;
+    const automatic = options.turnCoordinator ? undefined : options.automaticWriteback ? { enqueue: options.automaticWriteback, discardForScopeUpgrade: () => 0, drain: async () => undefined, close: () => undefined } : createAutomaticMemoryWritebackRuntime({ diagnosticLogger: options.diagnosticLogger, queueQuotaNotice: pendingQuotaNotice.queue });
+    const coordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({ automaticWriteback: automatic.enqueue, now, ttlMs: options.ttlMs, maxEntries: options.maxEntries, cleanupIntervalMs: options.cleanupIntervalMs });
+    const repository = options.repositoryMemorySession ?? createRepositoryMemorySessionRuntime({ onScopeUpgrade: automatic?.discardForScopeUpgrade });
+    return {
+        async recordTurnStart(command) {
+            await reconcilePreviousInterruptedTurn(coordinator, command, options, now);
+            const memory = await resolveRepository(command, options, repository);
+            const traceContext = traceContextFromCodeBuddyHookBody(command, new Date(now()).toISOString());
+            coordinator.recordTurnStart({ client: "codebuddy", sessionId: command.sessionId, clientTurnId: command.turnId, cwd: command.cwd, workspaceKind: command.workspaceKind, transcriptPath: command.transcriptPath, createdAt: now(), traceContext, repositoryMemory: memory });
+            await recordTraceBestEffort("codebuddy_memory_hook.turn_start_event", recordCodeBuddyTraceEvent({
+                eventId: traceTurnEventId(traceContext, "turn_start"),
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "turn_start",
+                source: "unknown",
+                operation: "query",
+                ok: true,
+                request: { prompt: command.prompt, cwd: command.cwd, transcriptPath: command.transcriptPath },
+            }), options.diagnosticLogger);
+            await recordTraceBestEffort("codebuddy_memory_hook.current_turn_write", writeCurrentCodeBuddyTurn(traceContext, {
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                now: () => new Date(now()),
+            }), options.diagnosticLogger);
+            const repoMemoryWorktree = resolvedRepoMemoryWorktree(memory);
+            const pendingUserNotice = memory.ok
+                ? await pendingQuotaNotice.claim(memory.memory.config)
+                : undefined;
+            const retrieval = await retrieveAutomaticMemoryContext({ diagnosticLogger: options.diagnosticLogger, claimQuotaNotice: options.claimQuotaNotice ?? claimQuotaNotice, env: options.env ?? process.env, fetchImpl: options.fetchImpl, memoryObservability: options.memoryObservability, memoryObservabilitySource: "codebuddy_hook_retrieval", query: command.prompt, repositoryMemory: memory, sessionKey: command.sessionId, traceContext: traceContextFromCodeBuddyHookBody(command) });
+            const userNotice = [pendingUserNotice, retrieval.userNotice].filter(Boolean).join("\n");
+            return { ok: true, ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}), ...(retrieval.context ? { additionalContext: retrieval.context } : {}), ...(userNotice ? { userNotice } : {}) };
+        },
+        async writeback(command) {
+            const entry = coordinator.getTurn({ client: "codebuddy", sessionId: command.sessionId, clientTurnId: command.turnId });
+            if (!command.sessionId)
+                return { ok: true, scheduled: false, reason: "missing_session_id" };
+            if (!command.turnId)
+                return { ok: true, scheduled: false, reason: "turn_id_missing" };
+            if (entry?.transcriptPath && entry.transcriptPath !== command.transcriptPath) {
+                await recordCodeBuddyTurnEnd(options, traceContextForWriteback(command, entry), undefined, "transcript_path_mismatch");
+                return { ok: true, scheduled: false, reason: "transcript_path_mismatch" };
+            }
+            const traceContext = traceContextForWriteback(command, entry);
+            const transcript = await readWithRetry({ transcriptPath: command.transcriptPath, sessionId: command.sessionId, turnId: command.turnId }, options);
+            if (!transcript.ok) {
+                await recordCodeBuddyTurnEnd(options, traceContext, undefined, transcript.reason);
+                return { ok: true, scheduled: false, reason: transcript.reason };
+            }
+            await recordCodeBuddyTurnEnd(options, traceContext, transcript.turn);
+            const memory = await resolveRepository({ ...command, cwd: command.cwd ?? entry?.cwd, workspaceKind: command.workspaceKind ?? entry?.workspaceKind }, options, repository);
+            const completed = await coordinator.completeMaterializedTurn({ key: { client: "codebuddy", sessionId: command.sessionId, clientTurnId: command.turnId }, metadata: entry, resolveRepositoryMemory: async () => memory, userText: transcript.turn.userPrompt, assistantText: transcript.turn.assistantReply, writeback: { client: "codebuddy", sessionKey: command.sessionId, env: options.env ?? process.env, fetchImpl: options.fetchImpl, memoryObservability: options.memoryObservability, memoryObservabilitySource: "codebuddy_hook_writeback", traceContext: traceContextFromCodeBuddyHookBody(command) } });
+            await recordCodeBuddyTurnMaterialization(options, traceContext, transcript.turn);
+            return completed.scheduled ? { ok: true, scheduled: true } : { ok: true, scheduled: false, reason: completed.reason };
+        },
+        size() { return coordinator.size("codebuddy"); },
+        close() { if (!options.turnCoordinator)
+            coordinator.close(); if (!options.repositoryMemorySession)
+            repository.close(); automatic?.close?.(); if (ownsPendingQuotaNotice)
+            pendingQuotaNotice.close(); },
+    };
+}
+async function resolveRepository(command, options, repository) {
+    return repository.resolve({ client: "codebuddy", sessionId: command.sessionId, workspaceRoot: command.cwd, workspaceKind: command.workspaceKind, memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME, env: options.env });
+}
+async function readWithRetry(input, options) {
+    const attempts = options.transcriptReadAttempts ?? 6;
+    let result = await readCodeBuddyTranscriptTurn(input);
+    for (let i = 1; i < attempts && !result.ok && ["transcript_unavailable", "turn_not_found", "user_prompt_missing", "assistant_message_missing"].includes(result.reason); i += 1) {
+        await new Promise((resolve) => setTimeout(resolve, options.transcriptRetryDelayMs ?? 100));
+        result = await readCodeBuddyTranscriptTurn(input);
+    }
+    return result;
+}
+function traceContextForWriteback(command, entry) {
+    return traceContextFromCodeBuddyHookBody({
+        ...command,
+        cwd: command.cwd ?? entry?.cwd,
+        workspaceKind: command.workspaceKind ?? entry?.workspaceKind,
+    }) ?? entry?.traceContext;
+}
+async function recordCodeBuddyTurnEnd(options, traceContext, turn, failureReason) {
+    const outcome = turn ? "completed" : failureReason === "assistant_message_missing" ? "interrupted" : undefined;
+    const recorded = await recordTraceBestEffort("codebuddy_memory_hook.turn_end_event", recordCodeBuddyTraceEvent({
+        eventId: traceTurnEventId(traceContext, "turn_end"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_end",
+        source: turn ? "codebuddy-hook" : "codebuddy-transcript",
+        operation: "reply",
+        ok: Boolean(turn),
+        ...(outcome ? { outcome } : {}),
+        ...(turn ? {
+            activities: turn.activities,
+            sessionTurnIndex: turn.sessionTurnIndex,
+            request: { prompt: turn.userPrompt },
+            response: { assistantMessage: turn.assistantReply },
+        } : {
+            error: failureReason,
+        }),
+    }), options.diagnosticLogger);
+    if (outcome) {
+        await recordTraceBestEffort("codebuddy_memory_hook.current_turn_close", markCurrentCodeBuddyTurnOutcome(traceContext, outcome, { memoraxCodeHome: options.memoraxCodeHome, env: options.env }), options.diagnosticLogger);
+    }
+    return recorded;
+}
+async function recordCodeBuddyTurnMaterialization(options, traceContext, turn) {
+    const originalEventId = traceTurnEventId(traceContext, "turn_end");
+    if (!originalEventId)
+        return;
+    await recordTraceBestEffort("codebuddy_memory_hook.turn_materialized_event", recordCodeBuddyTraceEvent({
+        eventId: traceTurnEventId(traceContext, "turn_materialized"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_materialized",
+        source: "codebuddy-transcript",
+        operation: "reply",
+        ok: true,
+        outcome: "completed",
+        activities: turn.activities,
+        sessionTurnIndex: turn.sessionTurnIndex,
+        request: { original_event_id: originalEventId, prompt: turn.userPrompt },
+        response: { assistantMessage: turn.assistantReply },
+    }), options.diagnosticLogger);
+}
+async function reconcilePreviousInterruptedTurn(coordinator, currentTurn, options, now) {
+    const candidate = await previousInterruptedTurnCandidate(coordinator, currentTurn, options, now);
+    if (!candidate)
+        return;
+    const transcript = await readCodeBuddyInterruptedTranscriptTurn({
+        transcriptPath: candidate.transcriptPath,
+        sessionId: candidate.sessionId,
+        turnId: candidate.turnId,
+    });
+    if (!transcript.ok)
+        return;
+    await recordCodeBuddyInterruptedTurnEnd(options, candidate.traceContext, transcript.turn);
+    coordinator.discardTurn({
+        client: "codebuddy",
+        sessionId: candidate.sessionId,
+        clientTurnId: candidate.turnId,
+    }, "interrupted");
+    options.diagnosticLogger?.("codebuddy_memory_hook.interrupted_turn_reconciled", {
+        sessionId: candidate.sessionId,
+        turnId: candidate.turnId,
+        assistantChars: transcript.turn.assistantReply.length,
+        activityCount: transcript.turn.activities.length,
+        sessionTurnIndex: transcript.turn.sessionTurnIndex,
+    });
+}
+async function previousInterruptedTurnCandidate(coordinator, currentTurn, options, now) {
+    const open = await readOpenTraceTurn({
+        client: "codebuddy",
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        expectedSessionId: currentTurn.sessionId,
+        allowStale: true,
+        now: () => new Date(now()),
+    });
+    if (!open.ok && open.reason === "closed")
+        return undefined;
+    if (open.ok && open.traceContext.turnId && open.traceContext.turnId !== currentTurn.turnId) {
+        const turnId = open.traceContext.turnId;
+        const cached = coordinator.getTurn({ client: "codebuddy", sessionId: currentTurn.sessionId, clientTurnId: turnId });
+        return {
+            sessionId: currentTurn.sessionId,
+            turnId,
+            transcriptPath: cached?.transcriptPath
+                ?? open.traceContext.transcriptPath
+                ?? currentTurn.transcriptPath,
+            traceContext: cached?.traceContext ?? open.traceContext,
+        };
+    }
+    const cached = coordinator.latestTurn({
+        client: "codebuddy",
+        sessionId: currentTurn.sessionId,
+        excludeClientTurnId: currentTurn.turnId,
+    });
+    if (!cached)
+        return undefined;
+    const transcriptPath = cached.transcriptPath ?? currentTurn.transcriptPath;
+    const traceContext = cached.traceContext ?? traceContextFromCodeBuddyHookBody({
+        sessionId: cached.sessionId,
+        turnId: cached.clientTurnId,
+        cwd: cached.cwd,
+        workspaceKind: cached.workspaceKind,
+        transcriptPath,
+    }, new Date(cached.createdAt).toISOString());
+    if (!traceContext)
+        return undefined;
+    return {
+        sessionId: cached.sessionId,
+        turnId: cached.clientTurnId,
+        transcriptPath,
+        traceContext,
+    };
+}
+async function recordCodeBuddyInterruptedTurnEnd(options, traceContext, turn) {
+    const recorded = await recordTraceBestEffort("codebuddy_memory_hook.interrupted_turn_end_event", recordCodeBuddyTraceEvent({
+        eventId: traceTurnEventId(traceContext, "turn_end"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_end",
+        source: "codebuddy-transcript",
+        operation: "reply",
+        ok: true,
+        outcome: "interrupted",
+        activities: turn.activities,
+        sessionTurnIndex: turn.sessionTurnIndex,
+        request: { prompt: turn.userPrompt },
+        response: { assistantMessage: turn.assistantReply },
+    }), options.diagnosticLogger);
+    if (!recorded || (!recorded.written && recorded.reason !== "duplicate_event"))
+        return;
+    await recordTraceBestEffort("codebuddy_memory_hook.interrupted_current_turn_close", markCurrentCodeBuddyTurnOutcome(traceContext, "interrupted", {
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+    }), options.diagnosticLogger);
+}
+async function recordTraceBestEffort(label, promise, diagnosticLogger) {
+    try {
+        return await promise;
+    }
+    catch (error) {
+        diagnosticLogger?.("codebuddy_trace.write_failed", {
+            label,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return undefined;
+    }
+}

package/lib/memorax-code-backend/dist/clients/codebuddy/turn-id.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+export function parseCodeBuddyTurnId(input) {
+    const prefix = `${input.sessionId}:`;
+    if (!input.turnId.startsWith(prefix))
+        return undefined;
+    const match = /^(0|[1-9]\d*):([0-9a-f]{64})$/.exec(input.turnId.slice(prefix.length));
+    if (!match)
+        return undefined;
+    const boundary = Number(match[1]);
+    if (!Number.isSafeInteger(boundary))
+        return undefined;
+    return { boundary, promptDigest: match[2] };
+}
+export function codeBuddyPromptDigest(prompt) {
+    return createHash("sha256").update(prompt.trim()).digest("hex");
+}

package/lib/memorax-code-backend/dist/clients/codex/plugin-install.js

@@ -11,7 +11,9 @@ import { confirmHookTrust, listMemoraxCodeHooks, trustCodexPluginHookSelection,
 import { resolveWindowsCliInvocation } from "../../shared/windows-cli-invocation.js";
 const PLUGIN_NAME = "memorax-code-codex-adapter";
 const CLI_MARKETPLACE_NAME = "memorax-code";
+const PLUGIN_ID = `${PLUGIN_NAME}@${CLI_MARKETPLACE_NAME}`;
 const ADAPTER_COMMON_NAME = "memorax-code-adapter-common";
+const PLUGIN_LIST_TIMEOUT_MS = 10_000;
 export async function installCodexPlugin(options = {}) {
     const home = resolveHome(options.homeDir);
     const codexHome = resolveCodexHome(options.codexHome, home);
@@ -124,14 +126,25 @@ export async function activateCodexPlugin(options = {}) {
     if (!existsSync(join(cliMarketplaceRoot, ".agents", "plugins", "marketplace.json"))) {
         await stageCodexCliMarketplace(install);
     }
+    const registrationBefore = await inspectCodexPluginRegistration({
+        ...options,
+        codexHome: install.codexHome,
+        codexCommand,
+        workspace,
+    });
     let marketplaceAdd;
     let pluginAdd;
-    if (install.registrationMode === "bootstrap") {
-        marketplaceAdd = await runCommand(codexCommand, ["plugin", "marketplace", "add", cliMarketplaceRoot, "--json"], { cwd: workspace, env });
-        if (!marketplaceAdd.ok) {
-            throw new Error(`codex plugin marketplace add failed: ${marketplaceAdd.stderr || marketplaceAdd.stdout || "unknown error"}`);
+    if (!registrationBefore.registered || !registrationBefore.enabled) {
+        if (registrationBefore.available) {
+            marketplaceAdd = skippedPluginCommand("marketplace_registration_preserved");
+        }
+        else {
+            marketplaceAdd = await runCommand(codexCommand, ["plugin", "marketplace", "add", cliMarketplaceRoot, "--json"], { cwd: workspace, env });
+            if (!marketplaceAdd.ok) {
+                throw new Error(`codex plugin marketplace add failed: ${marketplaceAdd.stderr || marketplaceAdd.stdout || "unknown error"}`);
+            }
         }
-        pluginAdd = await runCommand(codexCommand, ["plugin", "add", `${PLUGIN_NAME}@${CLI_MARKETPLACE_NAME}`, "--json"], { cwd: workspace, env });
+        pluginAdd = await runCommand(codexCommand, ["plugin", "add", PLUGIN_ID, "--json"], { cwd: workspace, env });
         if (!pluginAdd.ok) {
             throw new Error(`codex plugin add failed: ${pluginAdd.stderr || pluginAdd.stdout || "unknown error"}`);
         }
@@ -140,6 +153,19 @@ export async function activateCodexPlugin(options = {}) {
         marketplaceAdd = skippedPluginCommand("versioned_installation_preserved");
         pluginAdd = skippedPluginCommand("versioned_installation_preserved");
     }
+    const registration = await inspectCodexPluginRegistration({
+        ...options,
+        codexHome: install.codexHome,
+        codexCommand,
+        workspace,
+    });
+    const expectedVersion = stringField(await readJsonRecord(join(install.pluginSourcePath, ".codex-plugin", "plugin.json")), "version");
+    if (!registration.registered || !registration.enabled) {
+        throw new Error("Codex plugin registration was not enabled after activation");
+    }
+    if (!expectedVersion || registration.version !== expectedVersion) {
+        throw new Error(`Codex plugin registration version does not match ${expectedVersion ?? "the installed plugin"}`);
+    }
     await removePersonalMarketplaceEntry(bootstrapMarketplacePath);
     const hooks = await listMemoraxCodeHooks(codexCommand, workspace, env);
     if (hooks.length === 0) {
@@ -163,12 +189,37 @@ export async function activateCodexPlugin(options = {}) {
         workspace,
         marketplaceAdd,
         pluginAdd,
+        registrationBefore,
+        registration,
         hooks,
         trustedHooks: hooks.length,
         configPath,
         startsBackend: false,
     };
 }
+export async function inspectCodexPluginRegistration(options = {}) {
+    const home = resolveHome(options.homeDir);
+    const codexHome = resolveCodexHome(options.codexHome, home);
+    const codexCommand = options.codexCommand ?? process.env.CODEX_CLI_PATH ?? "codex";
+    const workspace = resolve(options.workspace ?? process.cwd());
+    const result = await runCommand(codexCommand, ["plugin", "list", "--available", "--json"], {
+        cwd: workspace,
+        env: { ...process.env, HOME: home, CODEX_HOME: codexHome },
+        timeoutMs: PLUGIN_LIST_TIMEOUT_MS,
+    });
+    if (!result.ok) {
+        throw new Error(`codex plugin list failed: ${result.stderr || result.stdout || "unknown error"}`);
+    }
+    const state = parseCodexPluginList(result.stdout);
+    return {
+        ok: true,
+        action: "codex-plugin-registration",
+        codexHome,
+        codexCommand,
+        workspace,
+        ...state,
+    };
+}
 export async function removeCodexPlugin(options = {}) {
     const home = resolveHome(options.homeDir);
     const codexHome = resolveCodexHome(options.codexHome, home);
@@ -368,10 +419,12 @@ function mjsFiles(root) {
 }
 async function writePluginMetadata(pluginSourcePath, codexCommand) {
     const normalizedCodexCommand = nonEmpty(codexCommand);
+    const npmExecPath = nonEmpty(process.env.MEMORAX_CODE_NPM_EXEC_PATH);
     const metadata = {
         version: 1,
         memoraxCodeCommand: process.argv[1],
         ...(normalizedCodexCommand ? { codexCommand: normalizedCodexCommand } : {}),
+        ...(npmExecPath ? { npmExecPath } : {}),
         writtenAt: new Date().toISOString(),
     };
     await writeFile(join(pluginSourcePath, ".memorax-code-package.json"), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
@@ -447,6 +500,55 @@ async function readMarketplace(marketplacePath) {
 function skippedPluginCommand(reason) {
     return { ok: true, stdout: "", stderr: "", skipped: true, reason };
 }
+function parseCodexPluginList(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("codex plugin list returned invalid JSON");
+    }
+    if (!isRecord(parsed) || !Array.isArray(parsed.installed) || !Array.isArray(parsed.available)) {
+        throw new Error("codex plugin list returned an invalid registry payload");
+    }
+    const installed = matchingPluginEntry(parsed.installed, "installed");
+    const available = matchingPluginEntry(parsed.available, "available");
+    if (!installed) {
+        return {
+            available: available !== undefined,
+            registered: false,
+            enabled: false,
+        };
+    }
+    const version = typeof installed.version === "string" ? nonEmpty(installed.version) : undefined;
+    if (installed.installed !== true
+        || typeof installed.enabled !== "boolean"
+        || !version) {
+        throw new Error("codex plugin list returned an invalid MemoraX Code registration");
+    }
+    return {
+        available: true,
+        registered: true,
+        enabled: installed.enabled,
+        version,
+    };
+}
+function matchingPluginEntry(entries, collection) {
+    const matches = entries.filter((entry) => isRecord(entry) && (entry.pluginId === PLUGIN_ID
+        || (entry.name === PLUGIN_NAME && entry.marketplaceName === CLI_MARKETPLACE_NAME)));
+    if (matches.length > 1) {
+        throw new Error(`codex plugin list returned duplicate MemoraX Code ${collection} entries`);
+    }
+    const entry = matches[0];
+    if (!entry)
+        return undefined;
+    if (entry.pluginId !== PLUGIN_ID
+        || entry.name !== PLUGIN_NAME
+        || entry.marketplaceName !== CLI_MARKETPLACE_NAME) {
+        throw new Error(`codex plugin list returned an invalid MemoraX Code ${collection} entry`);
+    }
+    return entry;
+}
 function pluginEntry(sourcePath) {
     return {
         name: PLUGIN_NAME,
@@ -495,13 +597,33 @@ function runCommand(command, args, options) {
         });
         let stdout = "";
         let stderr = "";
+        let settled = false;
+        let timeout;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            resolveResult(result);
+        };
+        if (options.timeoutMs) {
+            timeout = setTimeout(() => {
+                child.kill();
+                finish({
+                    ok: false,
+                    stdout,
+                    stderr: stderr || `command timed out after ${options.timeoutMs}ms`,
+                });
+            }, options.timeoutMs);
+        }
         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 });
+            finish({ ok: false, stdout, stderr: stderr || error.message });
         });
         child.on("close", (code) => {
-            resolveResult({ ok: code === 0, stdout, stderr });
+            finish({ ok: code === 0, stdout, stderr });
         });
     });
 }

package/lib/memorax-code-backend/dist/config/memorax-code.js

@@ -70,6 +70,10 @@ export function renderDefaultMemoraxCodeConfig() {
         "enabled = true # Enable local OpenCode session memory trace collection.",
         "capture_content = true # Store content in local OpenCode trace events.",
         "",
+        "[trace.codebuddy]",
+        "enabled = true # Enable local CodeBuddy session memory trace collection.",
+        "capture_content = true # Store content in local CodeBuddy trace events.",
+        "",
     ].join("\n");
 }
 export async function seedMissingMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
@@ -146,12 +150,14 @@ function normalizeMemoraxCodeConfig(value) {
     const traceClaude = recordValue(trace?.claude);
     const traceDsh = recordValue(trace?.dsh);
     const traceOpenCode = recordValue(trace?.opencode);
+    const traceCodeBuddy = recordValue(trace?.codebuddy);
     return (prune({
         clients: prune({
             codex: booleanField(clients, "codex"),
             claude: booleanField(clients, "claude"),
             dsh: booleanField(clients, "dsh"),
             opencode: booleanField(clients, "opencode"),
+            codebuddy: booleanField(clients, "codebuddy"),
         }),
         memorax: prune({
             endpoint: stringField(memorax, "endpoint"),
@@ -230,6 +236,13 @@ function normalizeMemoraxCodeConfig(value) {
                 max_event_chars: numberField(traceOpenCode, "max_event_chars"),
                 max_file_bytes: numberField(traceOpenCode, "max_file_bytes"),
             }),
+            codebuddy: prune({
+                enabled: booleanField(traceCodeBuddy, "enabled"),
+                capture_content: booleanField(traceCodeBuddy, "capture_content"),
+                retention_days: numberField(traceCodeBuddy, "retention_days"),
+                max_event_chars: numberField(traceCodeBuddy, "max_event_chars"),
+                max_file_bytes: numberField(traceCodeBuddy, "max_file_bytes"),
+            }),
         }),
     }) ?? {});
 }
@@ -242,7 +255,7 @@ function validateRawLifecycleConfig(value, path) {
         const clients = tableValue(rawClients);
         if (!clients)
             throw invalidLifecycleConfig(path, "clients must be a table");
-        for (const field of ["codex", "claude", "dsh", "opencode"]) {
+        for (const field of ["codex", "claude", "dsh", "opencode", "codebuddy"]) {
             if (clients[field] !== undefined && typeof clients[field] !== "boolean") {
                 throw invalidLifecycleConfig(path, `clients.${field} must be a boolean`);
             }

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 {