@memorax/memorax-code 0.1.10 → 0.1.12

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

@@ -0,0 +1,302 @@
+import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
+import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.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 { traceContextFromTraeHookBody } from "../../trace/context.js";
+import { markCurrentTraceTurnOutcome, recordTraceEvent, traceTurnEventId, writeCurrentTraceTurn, } from "../../trace/store.js";
+const TRAE_MEMORY_TURN_CLIENT = "trae";
+export function createTraeMemoryHookRuntime(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 automaticWritebackRuntime = options.turnCoordinator
+        ? undefined
+        : options.automaticWriteback
+            ? { enqueue: options.automaticWriteback }
+            : createAutomaticMemoryWritebackRuntime({
+                diagnosticLogger: options.diagnosticLogger,
+                queueQuotaNotice: pendingQuotaNotice.queue,
+            });
+    const turnCoordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({
+        automaticWriteback: automaticWritebackRuntime.enqueue,
+        now,
+        ttlMs: options.ttlMs,
+        maxEntries: options.maxEntries,
+        cleanupIntervalMs: options.cleanupIntervalMs,
+    });
+    const ownsTurnCoordinator = options.turnCoordinator === undefined;
+    const repositoryMemorySession = options.repositoryMemorySession ?? createRepositoryMemorySessionRuntime({
+        onScopeUpgrade: automaticWritebackRuntime?.discardForScopeUpgrade,
+    });
+    const ownsRepositoryMemorySession = options.repositoryMemorySession === undefined;
+    const retrievalTurns = new Set();
+    const interruptedTurns = new Set();
+    const activeTurns = new Map();
+    const turnStartOperations = new Map();
+    const runtimeTurnLimit = positiveInteger(options.maxEntries, 256);
+    const runtime = {
+        async recordTurnStart(command) {
+            turnCoordinator.pruneExpired();
+            const commandKey = traeRuntimeTurnKey(command.sessionId, command.turnId);
+            if (interruptedTurns.has(commandKey))
+                return { ok: true };
+            const previous = activeTurns.get(command.sessionId) ?? turnCoordinator.latestTurn({
+                client: TRAE_MEMORY_TURN_CLIENT,
+                sessionId: command.sessionId,
+                excludeClientTurnId: command.turnId,
+            });
+            if (previous && previous.clientTurnId !== command.turnId) {
+                await interruptPreviousTurn(turnCoordinator, previous, options, now);
+                rememberBounded(interruptedTurns, traeRuntimeTurnKey(previous.sessionId, previous.clientTurnId), runtimeTurnLimit);
+            }
+            const createdAt = now();
+            const traceContext = traceContextFromTraeHookBody(command, new Date(createdAt).toISOString());
+            const repositoryMemory = await resolveHookRepositoryMemory(command, options, repositoryMemorySession);
+            const repoMemoryWorktree = resolvedRepoMemoryWorktree(repositoryMemory);
+            const turn = turnCoordinator.recordTurnStart({
+                client: TRAE_MEMORY_TURN_CLIENT,
+                sessionId: command.sessionId,
+                clientTurnId: command.turnId,
+                cwd: command.cwd,
+                workspaceKind: command.workspaceKind,
+                createdAt,
+                traceContext,
+                repositoryMemory,
+            });
+            activeTurns.delete(command.sessionId);
+            activeTurns.set(command.sessionId, turn);
+            while (activeTurns.size > runtimeTurnLimit) {
+                const oldestSessionId = activeTurns.keys().next().value;
+                if (typeof oldestSessionId !== "string")
+                    break;
+                activeTurns.delete(oldestSessionId);
+            }
+            await recordTraceBestEffort("trae_memory.turn_start_event", recordTraceEvent({
+                eventId: traceTurnEventId(traceContext, "turn_start"),
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "turn_start",
+                source: "trae-hook",
+                operation: "query",
+                ok: true,
+                request: { prompt: command.prompt, cwd: command.cwd },
+            }), options.diagnosticLogger);
+            await recordTraceBestEffort("trae_memory.current_turn_write", writeCurrentTraceTurn(traceContext, {
+                client: "trae",
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                now: () => new Date(now()),
+            }), options.diagnosticLogger);
+            const retrievalKey = JSON.stringify([command.sessionId, command.turnId]);
+            if (retrievalTurns.has(retrievalKey)) {
+                return { ok: true, ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}) };
+            }
+            retrievalTurns.add(retrievalKey);
+            trimBounded(retrievalTurns, runtimeTurnLimit);
+            const pendingUserNotice = repositoryMemory.ok
+                ? await pendingQuotaNotice.claim(repositoryMemory.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: "trae_hook_retrieval",
+                query: command.prompt,
+                repositoryMemory,
+                sessionKey: command.sessionId,
+                traceContext,
+            });
+            const userNotice = [pendingUserNotice, retrieval.userNotice].filter(Boolean).join("\n");
+            return {
+                ok: true,
+                ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
+                ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+                ...(userNotice ? { userNotice } : {}),
+            };
+        },
+        async writeback(command) {
+            turnCoordinator.pruneExpired();
+            const commandKey = traeRuntimeTurnKey(command.sessionId, command.turnId);
+            const activeTurn = activeTurns.get(command.sessionId);
+            if (interruptedTurns.has(commandKey)
+                || (activeTurn && activeTurn.clientTurnId !== command.turnId)) {
+                rememberBounded(interruptedTurns, commandKey, runtimeTurnLimit);
+                return { ok: true, scheduled: false, reason: "interrupted" };
+            }
+            const key = traeTurnKey(command.sessionId, command.turnId);
+            const entry = turnCoordinator.getTurn(key) ?? activeTurn;
+            const traceContext = entry?.traceContext ?? traceContextFromTraeHookBody(command);
+            const repositoryMemory = await resolveHookRepositoryMemory(command, options, repositoryMemorySession);
+            await recordCompletedTurn(traceContext, command, options, now);
+            const completed = await turnCoordinator.completeMaterializedTurn({
+                key,
+                metadata: entry,
+                resolveRepositoryMemory: async () => repositoryMemory,
+                userText: command.prompt,
+                assistantText: command.lastAssistantMessage,
+                writeback: {
+                    client: "trae",
+                    sessionKey: command.sessionId,
+                    env: options.env ?? process.env,
+                    fetchImpl: options.fetchImpl,
+                    memoryObservability: options.memoryObservability,
+                    memoryObservabilitySource: "trae_hook_writeback",
+                    traceContext,
+                },
+            });
+            await recordMaterializedTurn(traceContext, command, options);
+            if (activeTurn?.clientTurnId === command.turnId)
+                activeTurns.delete(command.sessionId);
+            options.diagnosticLogger?.("trae_memory.writeback", {
+                scheduled: completed.scheduled,
+                ...(!completed.scheduled ? { reason: completed.reason } : {}),
+                sessionId: command.sessionId,
+                turnId: command.turnId,
+                metadataDisposition: completed.metadataDisposition,
+            });
+            return completed.scheduled
+                ? { ok: true, scheduled: true }
+                : { ok: true, scheduled: false, reason: completed.reason };
+        },
+        size() {
+            return turnCoordinator.size(TRAE_MEMORY_TURN_CLIENT);
+        },
+        close() {
+            retrievalTurns.clear();
+            interruptedTurns.clear();
+            activeTurns.clear();
+            turnStartOperations.clear();
+            if (ownsTurnCoordinator)
+                turnCoordinator.close();
+            if (ownsRepositoryMemorySession)
+                repositoryMemorySession.close();
+            automaticWritebackRuntime?.close?.();
+            if (ownsPendingQuotaNotice)
+                pendingQuotaNotice.close();
+        },
+    };
+    return {
+        ...runtime,
+        recordTurnStart(command) {
+            return queueSessionTurnStart(turnStartOperations, command.sessionId, () => runtime.recordTurnStart(command));
+        },
+    };
+}
+async function interruptPreviousTurn(coordinator, previous, options, now) {
+    await recordTraceBestEffort("trae_memory.interrupted_turn_end", recordTraceEvent({
+        eventId: traceTurnEventId(previous.traceContext, "turn_end"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext: previous.traceContext,
+        type: "turn_end",
+        source: "trae-hook",
+        operation: "writeback",
+        ok: true,
+        outcome: "interrupted",
+    }), options.diagnosticLogger);
+    await recordTraceBestEffort("trae_memory.interrupted_current_turn", markCurrentTraceTurnOutcome(previous.traceContext, "interrupted", {
+        client: "trae",
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        now: () => new Date(now()),
+    }), options.diagnosticLogger);
+    coordinator.discardTurn(previous, "interrupted");
+}
+async function recordCompletedTurn(traceContext, command, options, now) {
+    await recordTraceBestEffort("trae_memory.turn_end", recordTraceEvent({
+        eventId: traceTurnEventId(traceContext, "turn_end"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_end",
+        source: "trae-hook",
+        operation: "writeback",
+        ok: true,
+        outcome: "completed",
+        response: { assistant: command.lastAssistantMessage },
+    }), options.diagnosticLogger);
+    await recordTraceBestEffort("trae_memory.current_turn_close", markCurrentTraceTurnOutcome(traceContext, "completed", {
+        client: "trae",
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        now: () => new Date(now()),
+    }), options.diagnosticLogger);
+}
+async function recordMaterializedTurn(traceContext, command, options) {
+    await recordTraceBestEffort("trae_memory.turn_materialized", recordTraceEvent({
+        eventId: traceTurnEventId(traceContext, "turn_materialized"),
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_materialized",
+        source: "trae-hook",
+        operation: "writeback",
+        ok: true,
+        request: { prompt: command.prompt },
+        response: { assistant: command.lastAssistantMessage },
+    }), options.diagnosticLogger);
+}
+async function resolveHookRepositoryMemory(command, options, repository) {
+    return await repository.resolve({
+        client: "trae",
+        sessionId: command.sessionId,
+        workspaceRoot: command.cwd,
+        workspaceKind: command.workspaceKind,
+        memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME,
+        env: options.env,
+    });
+}
+function traeTurnKey(sessionId, turnId) {
+    return { client: "trae", sessionId, clientTurnId: turnId };
+}
+function traeRuntimeTurnKey(sessionId, turnId) {
+    return JSON.stringify([sessionId, turnId]);
+}
+function rememberBounded(values, value, limit) {
+    values.add(value);
+    trimBounded(values, limit);
+}
+function trimBounded(values, limit) {
+    while (values.size > limit) {
+        const oldest = values.values().next().value;
+        if (typeof oldest !== "string")
+            return;
+        values.delete(oldest);
+    }
+}
+async function recordTraceBestEffort(label, promise, diagnosticLogger) {
+    try {
+        await promise;
+    }
+    catch (error) {
+        diagnosticLogger?.("trae_trace.write_failed", {
+            label,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function queueSessionTurnStart(operations, sessionId, operation) {
+    const previous = operations.get(sessionId) ?? Promise.resolve();
+    const queued = previous
+        .catch(() => undefined)
+        .then(operation);
+    operations.set(sessionId, queued);
+    const clear = () => {
+        if (operations.get(sessionId) === queued)
+            operations.delete(sessionId);
+    };
+    void queued.then(clear, clear);
+    return queued;
+}
+function positiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

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

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

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

@@ -74,6 +74,10 @@ export function renderDefaultMemoraxCodeConfig() {
         "enabled = true # Enable local CodeBuddy session memory trace collection.",
         "capture_content = true # Store content in local CodeBuddy trace events.",
         "",
+        "[trace.trae]",
+        "enabled = true # Enable local Trae session memory trace collection.",
+        "capture_content = true # Store content in local Trae trace events.",
+        "",
     ].join("\n");
 }
 export async function seedMissingMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
@@ -151,6 +155,7 @@ function normalizeMemoraxCodeConfig(value) {
     const traceDsh = recordValue(trace?.dsh);
     const traceOpenCode = recordValue(trace?.opencode);
     const traceCodeBuddy = recordValue(trace?.codebuddy);
+    const traceTrae = recordValue(trace?.trae);
     return (prune({
         clients: prune({
             codex: booleanField(clients, "codex"),
@@ -158,6 +163,7 @@ function normalizeMemoraxCodeConfig(value) {
             dsh: booleanField(clients, "dsh"),
             opencode: booleanField(clients, "opencode"),
             codebuddy: booleanField(clients, "codebuddy"),
+            trae: booleanField(clients, "trae"),
         }),
         memorax: prune({
             endpoint: stringField(memorax, "endpoint"),
@@ -243,6 +249,13 @@ function normalizeMemoraxCodeConfig(value) {
                 max_event_chars: numberField(traceCodeBuddy, "max_event_chars"),
                 max_file_bytes: numberField(traceCodeBuddy, "max_file_bytes"),
             }),
+            trae: prune({
+                enabled: booleanField(traceTrae, "enabled"),
+                capture_content: booleanField(traceTrae, "capture_content"),
+                retention_days: numberField(traceTrae, "retention_days"),
+                max_event_chars: numberField(traceTrae, "max_event_chars"),
+                max_file_bytes: numberField(traceTrae, "max_file_bytes"),
+            }),
         }),
     }) ?? {});
 }
@@ -255,7 +268,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", "codebuddy"]) {
+        for (const field of ["codex", "claude", "dsh", "opencode", "codebuddy", "trae"]) {
             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

@@ -30,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] [--codebuddy-home DIR]",
+            "[--codex-home DIR] [--claude-home DIR] [--dsh-home DIR] [--opencode-config-dir DIR] [--codebuddy-home DIR] [--trae-home DIR]",
             "[--dsh-command CMD] [--dsh-adapter-root DIR] [--memorax-code-command CMD]",
-            "[--clients codex|claude|dsh|opencode|codebuddy|CLIENT,...|all|none]",
+            "[--clients codex|claude|dsh|opencode|codebuddy|trae|CLIENT,...|all|none]",
             "[--json]",
             "[--marketplace-path FILE] [--plugin-source-path DIR] [--claude-command CMD] [--help]",
             "[--yes]",
@@ -212,6 +212,7 @@ async function startRawBackendServer(state, host, port, argv) {
             dshAdapterRoot: argValue(argv, "--dsh-adapter-root"),
             openCodeConfigDir: argValue(argv, "--opencode-config-dir"),
             codeBuddyHome: argValue(argv, "--codebuddy-home"),
+            traeHome: argValue(argv, "--trae-home"),
             codexCommand: argValue(argv, "--codex-command"),
             claudeCommand: argValue(argv, "--claude-command"),
             dshCommand: argValue(argv, "--dsh-command"),
@@ -523,6 +524,8 @@ function printMemoraxCodeStatus(report) {
         backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
     if (report.codebuddyAdapter)
         backendLog(`CodeBuddy adapter: ${adapterStatusLine(report.codebuddyAdapter)}`);
+    if (report.traeAdapter)
+        backendLog(`Trae adapter: ${adapterStatusLine(report.traeAdapter)}`);
     if (!suppressBackendGuidance()) {
         for (const line of statusGuidance(report))
             backendLog(line);
@@ -626,6 +629,8 @@ function printLifecycleResult(report) {
         backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
     if (report.codebuddyAdapter)
         backendLog(`CodeBuddy adapter: ${adapterStatusLine(report.codebuddyAdapter)}`);
+    if (report.traeAdapter)
+        backendLog(`Trae adapter: ${adapterStatusLine(report.traeAdapter)}`);
     if (report.codexPlugin) {
         const removed = report.codexPlugin.removedPaths.length;
         const marketplace = report.codexPlugin.marketplaceChanged ? " marketplace=updated" : " marketplace=unchanged";
@@ -795,6 +800,9 @@ function statusGuidance(report) {
         }
         return [
             green("MemoraX Code is ready; sessions with the stable plugin shell use the active Hook runtime on their next user prompt."),
+            ...(report.traeAdapter?.globalHooksActivationRequired
+                ? ["Trae requires one manual step: open Trae Settings and enable Global Hooks, then start a new Trae session."]
+                : []),
             ...(optionalDshUnavailable
                 ? [`DSH integration is unavailable: ${report.dshAdapter?.reason ?? "not available"}.`]
                 : []),
@@ -841,6 +849,12 @@ function statusGuidance(report) {
             "Run `memorax-code start`, then restart or refresh OpenCode.",
         ];
     }
+    if (report.traeAdapter && !isAdapterReady(report.traeAdapter)) {
+        return [
+            red("Trae adapter is not enabled."),
+            "Run `memorax-code start --clients trae`, then enable Global Hooks in Trae Settings if this is the first setup.",
+        ];
+    }
     return [
         red("MemoraX Code needs attention."),
         "Run `memorax-code status` and `memorax-code logs` for details.",
@@ -884,9 +898,11 @@ function adapterStatusLine(report) {
     const skillStatus = report.codexSkills?.status
         ?? report.claudeSkills?.status
         ?? report.opencodeSkills?.status
-        ?? report.codebuddySkills?.status;
+        ?? report.codebuddySkills?.status
+        ?? report.traeSkills?.status;
     const skills = skillStatus ? ` skills=${skillStatus}` : "";
-    const hooks = report.codebuddyHooks?.status ? ` hook-runtime=${report.codebuddyHooks.status}` : "";
+    const hookStatus = report.codebuddyHooks?.status ?? report.traeHooks?.status;
+    const hooks = hookStatus ? ` hook-runtime=${hookStatus}` : "";
     const changed = report.changed === true ? " changed" : "";
     const integration = report.integration ?? report.state?.integration ?? "hooks";
     return `${enabled ? "ok" : "not enabled"} integration=${integration}${skills}${hooks}${changed}`;
@@ -897,6 +913,8 @@ function selectedLifecycleClientNames(report) {
         report.claudeAdapter ? "Claude Code" : undefined,
         report.dshAdapter ? "DSH" : undefined,
         report.opencodeAdapter ? "OpenCode" : undefined,
+        report.codebuddyAdapter ? "CodeBuddy/WorkBuddy" : undefined,
+        report.traeAdapter ? "Trae" : undefined,
     ].filter((name) => name !== undefined);
 }
 function lifecycleClientName(report) {

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

@@ -12,6 +12,8 @@ export function readActiveManagedClients(memoraxCodeHome) {
             return undefined;
         if (value.codebuddy !== undefined && typeof value.codebuddy !== "boolean")
             return undefined;
+        if (value.trae !== undefined && typeof value.trae !== "boolean")
+            return undefined;
         if (value.dsh !== undefined && typeof value.dsh !== "boolean")
             return undefined;
         return {
@@ -22,6 +24,7 @@ export function readActiveManagedClients(memoraxCodeHome) {
             dsh: value.dsh === true,
             opencode: value.opencode === true,
             ...(value.codebuddy === true ? { codebuddy: true } : {}),
+            ...(value.trae === true ? { trae: true } : {}),
         };
     }
     catch {

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

@@ -9,14 +9,17 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
     const dshProfileLifecycle = await loadDshProfileLifecycle();
     const openCodePluginInstaller = await loadOpenCodePluginInstaller();
     const codeBuddyPluginInstaller = await loadCodeBuddyPluginInstaller();
+    const traePluginInstaller = await loadTraePluginInstaller();
     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"));
     const claudeHome = options.claudeHome ?? stringField(claudeState, "claudeHome");
+    const traeState = await readJsonRecord(join(memoraxCodeHome, "adapters", "trae", "state.json"));
+    const traeHome = options.traeHome ?? stringField(traeState, "traeHome");
     return async () => {
         try {
             return await withBackendLifecycleLock({ home: memoraxCodeHome }, async () => {
-                const [codexPlugin, claudePlugin, dshPlugin, opencodePlugin, codebuddyPlugin] = await Promise.all([
+                const [codexPlugin, claudePlugin, dshPlugin, opencodePlugin, codebuddyPlugin, traePlugin] = await Promise.all([
                     cleanupCodexAfterBackendRemoval({
                         memoraxCodeHome,
                         homeDir: home,
@@ -52,15 +55,20 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
                         ...(options.codeBuddyHome ? { codeBuddyHome: options.codeBuddyHome } : {}),
                     }))
                         .catch((error) => removalFailure("codebuddy-plugin-remove", error)),
+                    traePluginInstaller.removeTraeAdapterInstallation({
+                        memoraxCodeHome,
+                        ...(traeHome ? { traeHome } : {}),
+                    }).catch((error) => removalFailure("trae-adapter-remove", error)),
                 ]);
                 return {
-                    ok: codexPlugin.ok && claudePlugin.ok && dshPlugin.ok && opencodePlugin.ok && codebuddyPlugin.ok,
+                    ok: codexPlugin.ok && claudePlugin.ok && dshPlugin.ok && opencodePlugin.ok && codebuddyPlugin.ok && traePlugin.ok,
                     action: "client-plugin-removal-cleanup",
                     codexPlugin,
                     claudePlugin,
                     dshPlugin,
                     opencodePlugin,
                     codebuddyPlugin,
+                    traePlugin,
                 };
             });
         }
@@ -74,6 +82,7 @@ export async function prepareClientPluginRemovalCleanup(options = {}) {
                 dshPlugin: failure,
                 opencodePlugin: failure,
                 codebuddyPlugin: failure,
+                traePlugin: failure,
             };
         }
     };
@@ -87,6 +96,9 @@ async function loadOpenCodePluginInstaller() {
 async function loadCodeBuddyPluginInstaller() {
     return await import(new URL("../../../memorax-code-codebuddy-adapter/src/config.mjs", import.meta.url).href);
 }
+async function loadTraePluginInstaller() {
+    return await import(new URL("../../../memorax-code-trae-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, codebuddy: true });
+const allClients = Object.freeze({ codex: true, claude: true, dsh: true, opencode: true, codebuddy: true, trae: true });
 export function resolveManagedClients(argv, config = {}) {
     const explicit = argValue(argv, "--clients");
     if (explicit !== undefined)
@@ -13,6 +13,7 @@ export function resolveManagedClients(argv, config = {}) {
             dsh: config.clients.dsh !== false,
             opencode: config.clients.opencode === true,
             ...(config.clients.codebuddy === true ? { codebuddy: true } : {}),
+            ...(config.clients.trae === true ? { trae: true } : {}),
         };
     }
     return { codex: true, claude: true, dsh: true, opencode: true };
@@ -24,8 +25,8 @@ 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" && name !== "codebuddy"))) {
-        throw new Error(`invalid --clients value: ${value}; expected a comma-separated subset of codex, claude, dsh, opencode, codebuddy, or all or none`);
+    if (names.length === 0 || names.some((name) => (name !== "codex" && name !== "claude" && name !== "dsh" && name !== "opencode" && name !== "codebuddy" && name !== "trae"))) {
+        throw new Error(`invalid --clients value: ${value}; expected a comma-separated subset of codex, claude, dsh, opencode, codebuddy, trae, or all or none`);
     }
     return {
         codex: names.includes("codex"),
@@ -33,6 +34,7 @@ export function parseManagedClients(value) {
         dsh: names.includes("dsh"),
         opencode: names.includes("opencode"),
         ...(names.includes("codebuddy") ? { codebuddy: true } : {}),
+        ...(names.includes("trae") ? { trae: true } : {}),
     };
 }
 export function loadManagedClientsConfig(memoraxCodeHome) {