@memorax/memorax-code 0.1.8 → 0.1.10

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/clients/codex/rollout-turn.js

@@ -32,6 +32,8 @@ export function codexRolloutTurnFromJsonLines(transcript, input) {
     if (!codexRolloutSessionMatches(scan, input.sessionId)) {
         return { ok: false, reason: "transcript_session_mismatch" };
     }
+    if (scan.turnMetadataMismatch)
+        return { ok: false, reason: "turn_metadata_mismatch" };
     if (!scan.targetSeen)
         return { ok: false, reason: "turn_not_found" };
     if (!scan.userPrompt)
@@ -48,6 +50,8 @@ export function codexInterruptedRolloutTurnFromJsonLines(transcript, input) {
     if (!codexRolloutSessionMatches(scan, input.sessionId)) {
         return { ok: false, reason: "transcript_session_mismatch" };
     }
+    if (scan.turnMetadataMismatch)
+        return { ok: false, reason: "turn_metadata_mismatch" };
     if (!scan.targetSeen)
         return { ok: false, reason: "turn_not_found" };
     if (!scan.userPrompt)
@@ -74,9 +78,12 @@ function scanCodexRolloutTurn(transcript, targetTurnId) {
     let targetBoundarySeen = false;
     let activeTurnId;
     let targetSeen = false;
+    let turnMetadataMismatch = false;
     let userPrompt;
     let assistantReply;
     const visibleAssistantMessages = [];
+    let responseItemUserPrompt;
+    let responseItemAssistantReply;
     let interrupted = false;
     let interruptedAt;
     let rolledBack = false;
@@ -145,6 +152,26 @@ function scanCodexRolloutTurn(transcript, targetTurnId) {
                 const activities = activityCandidatesFromResponseItem(payload);
                 if (activities.length > 0)
                     targetActivityGroups.push(activities);
+                if (stringValue(payload.type) === "message") {
+                    const role = stringValue(payload.role);
+                    const message = responseItemMessageText(payload.content, role);
+                    const authoritativeMessage = role === "user"
+                        || (role === "assistant" && payload.phase === "final_answer");
+                    if (authoritativeMessage && message) {
+                        const responseTurnId = responseItemTurnId(payload);
+                        if (responseTurnId && responseTurnId !== activeTurnId) {
+                            turnMetadataMismatch = true;
+                            continue;
+                        }
+                        if (role === "user") {
+                            userMessageTurnIds.add(activeTurnId);
+                            responseItemUserPrompt = message;
+                        }
+                        else {
+                            responseItemAssistantReply = message;
+                        }
+                    }
+                }
             }
             continue;
         }
@@ -231,8 +258,9 @@ function scanCodexRolloutTurn(transcript, targetTurnId) {
         ambiguousSessionMetadata,
         composite,
         targetSeen,
-        userPrompt,
-        assistantReply,
+        turnMetadataMismatch,
+        userPrompt: responseItemUserPrompt ?? userPrompt,
+        assistantReply: responseItemAssistantReply ?? assistantReply,
         visibleAssistantMessages,
         interrupted,
         interruptedAt,
@@ -245,6 +273,28 @@ function scanCodexRolloutTurn(transcript, targetTurnId) {
         userMessageTurnIds,
     };
 }
+function responseItemTurnId(payload) {
+    const metadata = isRecord(payload.internal_chat_message_metadata_passthrough)
+        ? payload.internal_chat_message_metadata_passthrough
+        : undefined;
+    return metadata
+        ? stringValue(metadata.turn_id) ?? stringValue(metadata.turnId)
+        : undefined;
+}
+function responseItemMessageText(value, role) {
+    if (!Array.isArray(value))
+        return undefined;
+    const expectedType = role === "user" ? "input_text" : role === "assistant" ? "output_text" : undefined;
+    if (!expectedType)
+        return undefined;
+    const parts = value.flatMap((item) => {
+        if (!isRecord(item) || stringValue(item.type) !== expectedType)
+            return [];
+        const text = nonBlankString(item.text);
+        return text ? [text] : [];
+    });
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
 function codexRolloutSessionMatches(scan, sessionId) {
     return scan.authoritySessionId === sessionId && !scan.ambiguousSessionMetadata;
 }

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`);
             }