@memorax/memorax-code 0.1.2 → 0.1.4

package/lib/memorax-code-backend/dist/codex-adapter-lifecycle.js

@@ -1,131 +1 @@
-import { createInterface } from "node:readline/promises";
-import { installCodexPlugin, isCodexPluginActive, isCodexPluginStaged, removeCodexPlugin, } from "./codex-plugin-install.js";
-const BACKEND_PREFIX = "[MemoraX Code Backend]:";
-const GREEN = "\x1b[32m";
-const RESET = "\x1b[0m";
-export async function enableCodexAdapterForStart(argv, serviceOptions, backendUrl) {
-    try {
-        let options = codexAdapterOptions(argv, serviceOptions, backendUrl);
-        const codexHome = typeof options.codexHome === "string" ? options.codexHome : undefined;
-        if (!isCodexPluginActive({ codexHome }) && !isCodexPluginStaged({ codexHome })) {
-            const installed = await maybeInstallCodexPluginForStart(argv);
-            if (installed) {
-                backendLog(green("Codex plugin source registered. Activate the MemoraX Code Codex Adapter plugin, then restart or refresh Codex."));
-            }
-            else if (installed === false) {
-                return codexPluginNotInstalled();
-            }
-        }
-        options = codexAdapterOptions(argv, serviceOptions, backendUrl);
-        if (!isCodexPluginActive({ codexHome })) {
-            return isCodexPluginStaged({ codexHome })
-                ? codexPluginActivationRequired()
-                : codexPluginNotInstalled();
-        }
-        return (await loadCodexAdapterConfig()).enableCodexAdapter(options);
-    }
-    catch (error) {
-        return { ok: false, action: "enable", error: error instanceof Error ? error.message : String(error) };
-    }
-}
-export async function readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl) {
-    try {
-        return (await loadCodexAdapterConfig()).readCodexAdapterStatus(codexAdapterOptions(argv, serviceOptions, backendUrl));
-    }
-    catch (error) {
-        return { ok: false, action: "status", error: error instanceof Error ? error.message : String(error) };
-    }
-}
-export async function disableCodexAdapterForLifecycle(argv, serviceOptions) {
-    try {
-        return (await loadCodexAdapterConfig()).disableCodexAdapter(codexAdapterOptions(argv, serviceOptions));
-    }
-    catch (error) {
-        return { ok: false, action: "disable", error: error instanceof Error ? error.message : String(error) };
-    }
-}
-export const codexAdapterLifecycle = {
-    status: ({ argv, serviceOptions, backendUrl }) => (readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl)),
-    prepareEnable: ({ argv, serviceOptions, backendUrl }) => (enableCodexAdapterForStart(argv, serviceOptions, backendUrl)),
-    disable: ({ argv, serviceOptions }) => (disableCodexAdapterForLifecycle(argv, serviceOptions)),
-    remove: ({ argv }) => removeCodexPlugin(codexPluginRemoveOptions(argv)),
-};
-function codexAdapterOptions(argv, serviceOptions, backendUrl) {
-    const codexHome = argValue(argv, "--codex-home");
-    return {
-        ...(codexHome ? { codexHome } : {}),
-        memoraxCodeHome: serviceOptions.home,
-        ...(backendUrl ? { backendUrl } : {}),
-    };
-}
-function codexPluginNotInstalled() {
-    return {
-        ok: true,
-        action: "enable",
-        skipped: true,
-        reason: "codex_plugin_not_installed",
-        message: "Codex plugin is not installed; run `memorax-code codex-plugin install`, then activate it and rerun `memorax-code start`.",
-    };
-}
-function codexPluginActivationRequired() {
-    return {
-        ok: true,
-        action: "enable",
-        skipped: true,
-        reason: "codex_plugin_activation_required",
-        message: "Codex plugin source is registered but not active; run `memorax-code codex-plugin activate --yes`, then rerun `memorax-code start`.",
-    };
-}
-async function maybeInstallCodexPluginForStart(argv) {
-    if (argv.includes("--json"))
-        return undefined;
-    if (argv.includes("--yes")) {
-        await installCodexPlugin(codexPluginInstallOptions(argv));
-        return true;
-    }
-    if (!canPromptOnStdin())
-        return undefined;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = await rl.question(`${BACKEND_PREFIX} Install MemoraX Code Codex Adapter plugin now? [y/N] `);
-        if (!process.stdout.isTTY)
-            process.stdout.write("\n");
-        if (!/^y(?:es)?$/i.test(answer.trim()))
-            return false;
-        await installCodexPlugin(codexPluginInstallOptions(argv));
-        return true;
-    }
-    finally {
-        rl.close();
-    }
-}
-function codexPluginInstallOptions(argv) {
-    return {
-        codexHome: argValue(argv, "--codex-home"),
-        marketplacePath: argValue(argv, "--marketplace-path"),
-        pluginSourcePath: argValue(argv, "--plugin-source-path"),
-        codexCommand: argValue(argv, "--codex-command"),
-    };
-}
-function codexPluginRemoveOptions(argv) {
-    return {
-        ...codexPluginInstallOptions(argv),
-        workspace: argValue(argv, "--workspace"),
-    };
-}
-function canPromptOnStdin() {
-    return process.stdin.isTTY === true;
-}
-function backendLog(message) {
-    console.log(`${BACKEND_PREFIX} ${message}`);
-}
-function green(value) {
-    return `${GREEN}${value}${RESET}`;
-}
-function argValue(argv, name) {
-    const index = argv.indexOf(name);
-    return index >= 0 ? argv[index + 1] : undefined;
-}
-async function loadCodexAdapterConfig() {
-    return await import(new URL("../../memorax-code-codex-adapter/src/config.mjs", import.meta.url).href);
-}
+export * from "./clients/codex/lifecycle.js";

package/lib/memorax-code-backend/dist/{memorax-code-config.js → config/memorax-code.js}

@@ -3,8 +3,8 @@ import { writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parse } from "smol-toml";
-import { ensurePrivateConfigDirectory } from "../../memorax-code-adapter-common/src/memorax-code-config-file.mjs";
-import { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, } from "../../memorax-code-adapter-common/src/memorax-defaults.mjs";
+import { ensurePrivateConfigDirectory } from "../../../memorax-code-adapter-common/src/memorax-code-config-file.mjs";
+import { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, } from "../../../memorax-code-adapter-common/src/memorax-defaults.mjs";
 export function defaultMemoraxCodeHome(env = process.env) {
     return env.MEMORAX_CODE_HOME?.trim() || join(homedir(), ".memorax-code");
 }
@@ -22,6 +22,8 @@ export function renderDefaultMemoraxCodeConfig() {
         "[clients]",
         "codex = true",
         "claude = true",
+        "dsh = true",
+        "opencode = true",
         "",
         "# MemoraX remote-memory connection. Credentials may also come from the environment.",
         "[memorax]",
@@ -41,7 +43,7 @@ export function renderDefaultMemoraxCodeConfig() {
         "[memory.add]",
         `output_language = "${MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE}" # Language for newly generated MemoraX memories.`,
         "",
-        "# Controls how often Codex and Claude Code native client sessions see the MemoraX Code skill reminder.",
+        "# Controls how often supported native client sessions see the MemoraX Code skill reminder.",
         "[memory.skill_reminder]",
         "interval_turns = 5 # Show the MemoraX Code skill reminder every N native client turns, starting on the first turn.",
         "",
@@ -60,6 +62,14 @@ export function renderDefaultMemoraxCodeConfig() {
         "enabled = true # Enable local Claude session memory trace collection.",
         "capture_content = true # Store content in local Claude trace events.",
         "",
+        "[trace.dsh]",
+        "enabled = true # Enable local DSH session memory trace collection.",
+        "capture_content = true # Store content in local DSH trace events.",
+        "",
+        "[trace.opencode]",
+        "enabled = true # Enable local OpenCode session memory trace collection.",
+        "capture_content = true # Store content in local OpenCode trace events.",
+        "",
     ].join("\n");
 }
 export async function seedMissingMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
@@ -134,10 +144,14 @@ function normalizeMemoraxCodeConfig(value) {
     const repoUpdate = recordValue(memory?.repo_update);
     const traceCodex = recordValue(trace?.codex);
     const traceClaude = recordValue(trace?.claude);
+    const traceDsh = recordValue(trace?.dsh);
+    const traceOpenCode = recordValue(trace?.opencode);
     return (prune({
         clients: prune({
             codex: booleanField(clients, "codex"),
             claude: booleanField(clients, "claude"),
+            dsh: booleanField(clients, "dsh"),
+            opencode: booleanField(clients, "opencode"),
         }),
         memorax: prune({
             endpoint: stringField(memorax, "endpoint"),
@@ -202,6 +216,20 @@ function normalizeMemoraxCodeConfig(value) {
                 max_event_chars: numberField(traceClaude, "max_event_chars"),
                 max_file_bytes: numberField(traceClaude, "max_file_bytes"),
             }),
+            dsh: prune({
+                enabled: booleanField(traceDsh, "enabled"),
+                capture_content: booleanField(traceDsh, "capture_content"),
+                retention_days: numberField(traceDsh, "retention_days"),
+                max_event_chars: numberField(traceDsh, "max_event_chars"),
+                max_file_bytes: numberField(traceDsh, "max_file_bytes"),
+            }),
+            opencode: prune({
+                enabled: booleanField(traceOpenCode, "enabled"),
+                capture_content: booleanField(traceOpenCode, "capture_content"),
+                retention_days: numberField(traceOpenCode, "retention_days"),
+                max_event_chars: numberField(traceOpenCode, "max_event_chars"),
+                max_file_bytes: numberField(traceOpenCode, "max_file_bytes"),
+            }),
         }),
     }) ?? {});
 }
@@ -214,7 +242,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"]) {
+        for (const field of ["codex", "claude", "dsh", "opencode"]) {
             if (clients[field] !== undefined && typeof clients[field] !== "boolean") {
                 throw invalidLifecycleConfig(path, `clients.${field} must be a boolean`);
             }

package/lib/memorax-code-backend/dist/{server-cli.js → entrypoints/backend-cli.js}

@@ -1,20 +1,20 @@
 import { basename, resolve } from "node:path";
-import { backendServiceEndpoint, backendServiceLogs, isProcessAlive, readBackendServiceState, readBackendToken, writeBackendToken, } from "./service.js";
-import { BackendConnectionAuthorityError, resolveBackendConnection, } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
-import { RuntimeRecordError, } from "../../memorax-code-adapter-common/src/runtime-record.mjs";
-import { activateClientHookRuntimeGeneration, CLIENT_HOOK_RUNTIME_ABI, } from "../../memorax-code-adapter-common/src/hooks/hook-runtime-generation.mjs";
-import { createBackendState } from "./backend-state.js";
-import { createBackendServer } from "./server.js";
-import { backendDebug } from "./debug-log.js";
-import { prepareClientPluginRemovalCleanup } from "./client-plugin-removal.js";
-import { resolveBackendInstallWatchdogConfig, startBackendInstallWatchdog, } from "./install-watchdog.js";
-import { activateCodexPlugin, installCodexPlugin } from "./codex-plugin-install.js";
-import { inspectCodexPluginHooks, trustCodexPluginHooks } from "./codex-plugin-hooks.js";
-import { collectMemoraxCodeStatus, isAdapterReady, isOptionalUnconfiguredClaudeAdapter, restartMemoraxCodeService, startMemoraxCodeService, stopMemoraxCodeService, uninstallMemoraxCodeService, } from "./memorax-code-lifecycle.js";
-import { backendEnv } from "./backend-env.js";
-import { backendServiceHome, BackendLifecycleLockError, withBackendLifecycleLock, } from "./backend-lifecycle-lock.js";
-import { startBackendShutdownRequestWatcher, } from "./backend-shutdown-request.js";
-import { runtimeRecordDurabilityWarning } from "./backend-service-result.js";
+import { backendServiceEndpoint, backendServiceLogs, isProcessAlive, readBackendServiceState, readBackendToken, writeBackendToken, } from "../lifecycle/backend/service.js";
+import { BackendConnectionAuthorityError, resolveBackendConnection, } from "../../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { RuntimeRecordError, } from "../../../memorax-code-adapter-common/src/runtime-record.mjs";
+import { activateClientHookRuntimeGeneration, CLIENT_HOOK_RUNTIME_ABI, } from "../../../memorax-code-adapter-common/src/hooks/hook-runtime-generation.mjs";
+import { createBackendState } from "../app/state.js";
+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 { 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";
+import { backendServiceHome, BackendLifecycleLockError, withBackendLifecycleLock, } from "../lifecycle/lock.js";
+import { startBackendShutdownRequestWatcher, } from "../lifecycle/backend/shutdown-request.js";
+import { runtimeRecordDurabilityWarning } from "../lifecycle/backend/result.js";
 // Keep process-facing CLI orchestration outside the HTTP server module.
 // This preserves server.ts as the importable route factory used by tests and tools.
 export function runBackendCli(argv = process.argv) {
@@ -29,8 +29,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]",
-            "[--clients codex|claude|codex,claude|all|none]",
+            "[--codex-home DIR] [--claude-home DIR] [--dsh-home DIR] [--opencode-config-dir DIR]",
+            "[--dsh-command CMD] [--dsh-adapter-root DIR] [--memorax-code-command CMD]",
+            "[--clients codex|claude|dsh|opencode|CLIENT,...|all|none]",
             "[--json]",
             "[--marketplace-path FILE] [--plugin-source-path DIR] [--claude-command CMD] [--help]",
             "[--yes]",
@@ -206,8 +207,12 @@ async function startRawBackendServer(state, host, port, argv) {
             memoraxCodeHome: state.sessionHome,
             codexHome: argValue(argv, "--codex-home"),
             claudeHome: argValue(argv, "--claude-home"),
+            dshHome: argValue(argv, "--dsh-home"),
+            dshAdapterRoot: argValue(argv, "--dsh-adapter-root"),
+            openCodeConfigDir: argValue(argv, "--opencode-config-dir"),
             codexCommand: argValue(argv, "--codex-command"),
             claudeCommand: argValue(argv, "--claude-command"),
+            dshCommand: argValue(argv, "--dsh-command"),
         })
         : undefined;
     const server = createBackendServer(state);
@@ -227,6 +232,10 @@ async function startRawBackendServer(state, host, port, argv) {
                 codexReason: "reason" in cleanup.codexPlugin ? cleanup.codexPlugin.reason : undefined,
                 claudeOk: cleanup.claudePlugin.ok,
                 claudeReason: cleanup.claudePlugin.reason,
+                dshOk: cleanup.dshPlugin.ok,
+                dshReason: cleanup.dshPlugin.reason,
+                opencodeOk: cleanup.opencodePlugin.ok,
+                opencodeReason: cleanup.opencodePlugin.reason,
             });
         }
         server.close(() => {
@@ -476,6 +485,10 @@ function printMemoraxCodeStatus(report) {
     }
     if (report.claudeAdapter)
         backendLog(`Claude adapter: ${claudeAdapterStatusLine(report.claudeAdapter, report.codexAdapter)}`);
+    if (report.dshAdapter)
+        backendLog(`DSH adapter: ${dshAdapterStatusLine(report.dshAdapter)}`);
+    if (report.opencodeAdapter)
+        backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
     if (!suppressBackendGuidance()) {
         for (const line of statusGuidance(report))
             backendLog(line);
@@ -573,6 +586,10 @@ function printLifecycleResult(report) {
         backendLog(`Codex adapter: ${adapterStatusLine(report.codexAdapter)}`);
     if (report.claudeAdapter)
         backendLog(`Claude adapter: ${adapterStatusLine(report.claudeAdapter)}`);
+    if (report.dshAdapter)
+        backendLog(`DSH adapter: ${dshAdapterStatusLine(report.dshAdapter)}`);
+    if (report.opencodeAdapter)
+        backendLog(`OpenCode adapter: ${adapterStatusLine(report.opencodeAdapter)}`);
     if (report.codexPlugin) {
         const removed = report.codexPlugin.removedPaths.length;
         const marketplace = report.codexPlugin.marketplaceChanged ? " marketplace=updated" : " marketplace=unchanged";
@@ -628,17 +645,37 @@ function lifecycleGuidance(report) {
                 "Run `memorax-code logs` for details, then retry `memorax-code start`.",
             ];
         }
-        if (!report.codexAdapter && !report.claudeAdapter) {
+        if (!report.codexAdapter && !report.claudeAdapter && !report.dshAdapter && !report.opencodeAdapter) {
             return [
                 green("Backend is running."),
                 "Adapters were not changed for this command.",
             ];
         }
-        if ((!report.codexAdapter || isAdapterReady(report.codexAdapter)) && (!report.claudeAdapter || isAdapterReady(report.claudeAdapter))) {
+        const optionalDshSkipped = isOptionalUnavailableDshAdapter(report.dshAdapter);
+        if ((!report.codexAdapter || isAdapterReady(report.codexAdapter))
+            && (!report.claudeAdapter || isAdapterReady(report.claudeAdapter))
+            && (!report.dshAdapter
+                || isAdapterReady(report.dshAdapter)
+                || optionalDshSkipped)
+            && (!report.opencodeAdapter || isAdapterReady(report.opencodeAdapter))) {
             return [
-                green("Backend is running and adapters are enabled."),
-                green("Existing sessions with the stable plugin shell select the active Hook runtime on their next user prompt."),
-                "Restart or refresh a client only if its plugin shell was installed, changed, or newly enabled, or MemoraX Code is not active on the next prompt.",
+                green(optionalDshSkipped
+                    && !report.codexAdapter
+                    && !report.claudeAdapter
+                    && !report.opencodeAdapter
+                    ? "Backend is running; the optional DSH integration was skipped."
+                    : "Backend is running and available client integrations are enabled."),
+                ...(optionalDshSkipped
+                    ? [`DSH integration was skipped: ${report.dshAdapter?.reason ?? "not available"}.`]
+                    : []),
+                ...(report.codexAdapter || report.claudeAdapter || report.opencodeAdapter
+                    ? [
+                        green("Existing sessions with the stable plugin shell select the active runtime on their next user prompt."),
+                        "Restart or refresh a client only if its plugin shell changed or MemoraX Code is not active on the next prompt.",
+                    ]
+                    : optionalDshSkipped
+                        ? []
+                        : [green("New DSH sessions can use MemoraX Code through the active Profile integration.")]),
             ];
         }
         return [
@@ -647,11 +684,17 @@ function lifecycleGuidance(report) {
         ];
     }
     if (report.action === "stop") {
+        const backendKeptRunning = report.backend?.skipped === true
+            && report.backend.reason === "active_clients_remaining";
         return report.ok
             ? [
-                green("Backend is stopped."),
+                green(backendKeptRunning
+                    ? "Backend remains running for the other active client integrations."
+                    : "Backend is stopped."),
                 ...(report.codexAdapter ? [green("Codex Hook integration is stopped; provider config was not changed.")] : []),
                 ...(report.claudeAdapter ? [green("Claude Code Hook integration is stopped; provider config was not changed.")] : []),
+                ...(report.dshAdapter ? [green("DSH Profile integration is stopped.")] : []),
+                ...(report.opencodeAdapter ? [green("OpenCode plugin integration is stopped; provider config was not changed.")] : []),
             ]
             : [
                 red("Backend did not stop cleanly."),
@@ -662,7 +705,7 @@ function lifecycleGuidance(report) {
         return report.ok
             ? [
                 green("Backend restarted."),
-                green("Existing sessions with the stable plugin shell use the active Hook runtime on their next user prompt."),
+                green("Available client integrations were reconciled with the restarted Backend."),
                 "Restart or refresh a client only if MemoraX Code is not active on the next prompt.",
             ]
             : [
@@ -677,15 +720,12 @@ function lifecycleGuidance(report) {
                 "Run `memorax-code status` and `memorax-code logs` before retrying.",
             ];
         }
-        const clientName = report.codexAdapter && report.claudeAdapter
-            ? "Codex and Claude Code"
-            : report.codexAdapter
-                ? "Codex"
-                : report.claudeAdapter
-                    ? "Claude Code"
-                    : undefined;
+        const clientName = lifecycleClientName(report);
         const npmPackageRemoved = report.npmPackageRemoval?.ok === true
             && report.npmPackageRemoval.skipped !== true;
+        const removalNoun = report.dshAdapter
+            ? `client integration${selectedLifecycleClientNames(report).length === 1 ? "" : "s"}`
+            : `adapter plugin${selectedLifecycleClientNames(report).length === 1 ? "" : "s"}`;
         return [
             ...(npmPackageRemoved
                 ? [green("MemoraX Code has been uninstalled from this npm installation.")]
@@ -693,9 +733,7 @@ function lifecycleGuidance(report) {
                     ? [green(`MemoraX Code has been uninstalled from ${clientName}.`)]
                     : []),
             ...(clientName
-                ? [green(report.codexAdapter && report.claudeAdapter
-                        ? "Restart or refresh Codex and Claude Code so they drop the removed adapter plugins."
-                        : `Restart or refresh ${clientName} so it drops the removed adapter plugin.`)]
+                ? [green(`Restart or refresh ${clientName} so it drops the removed ${removalNoun}.`)]
                 : []),
         ];
     }
@@ -703,8 +741,27 @@ function lifecycleGuidance(report) {
 }
 function statusGuidance(report) {
     if (report.ok) {
+        const optionalDshSkipped = isOptionalUnavailableDshAdapter(report.dshAdapter);
+        if (report.dshAdapter
+            && !report.codexAdapter
+            && !report.claudeAdapter
+            && !report.opencodeAdapter) {
+            if (optionalDshSkipped) {
+                return [
+                    green("Backend is running; the optional DSH integration was skipped."),
+                    `DSH integration was skipped: ${report.dshAdapter.reason ?? "not available"}.`,
+                ];
+            }
+            return [
+                green("MemoraX Code is ready for new DSH sessions."),
+                "Restart or refresh DSH only if its Profile integration changed or MemoraX Code is not active on the next prompt.",
+            ];
+        }
         return [
             green("MemoraX Code is ready; sessions with the stable plugin shell use the active Hook runtime on their next user prompt."),
+            ...(optionalDshSkipped
+                ? [`DSH integration was skipped: ${report.dshAdapter?.reason ?? "not available"}.`]
+                : []),
             "Restart or refresh a client only if its plugin shell was installed, changed, or newly enabled, or MemoraX Code is not active on the next prompt.",
         ];
     }
@@ -734,6 +791,20 @@ function statusGuidance(report) {
             "Run `memorax-code start`, then restart or refresh Claude Code.",
         ];
     }
+    if (report.dshAdapter
+        && !isAdapterReady(report.dshAdapter)
+        && !isOptionalUnavailableDshAdapter(report.dshAdapter)) {
+        return [
+            red("DSH adapter is not enabled."),
+            "Run `memorax-code start`, then retry `memorax-code status`.",
+        ];
+    }
+    if (report.opencodeAdapter && !isAdapterReady(report.opencodeAdapter)) {
+        return [
+            red("OpenCode adapter is not enabled."),
+            "Run `memorax-code start`, then restart or refresh OpenCode.",
+        ];
+    }
     return [
         red("MemoraX Code needs attention."),
         "Run `memorax-code status` and `memorax-code logs` for details.",
@@ -774,10 +845,29 @@ function adapterStatusLine(report) {
         return `not ok endpoint_mismatch configured=${report.configuredBackendUrl ?? "missing"} expected=${report.expectedBackendUrl ?? "unknown"}`;
     }
     const enabled = isAdapterReady(report);
-    const skillStatus = report.codexSkills?.status ?? report.claudeSkills?.status;
+    const skillStatus = report.codexSkills?.status
+        ?? report.claudeSkills?.status
+        ?? report.opencodeSkills?.status;
     const skills = skillStatus ? ` skills=${skillStatus}` : "";
     const changed = report.changed === true ? " changed" : "";
-    return `${enabled ? "ok" : "not enabled"} integration=hooks${skills}${changed}`;
+    const integration = report.integration ?? report.state?.integration ?? "hooks";
+    return `${enabled ? "ok" : "not enabled"} integration=${integration}${skills}${changed}`;
+}
+function selectedLifecycleClientNames(report) {
+    return [
+        report.codexAdapter ? "Codex" : undefined,
+        report.claudeAdapter ? "Claude Code" : undefined,
+        report.dshAdapter ? "DSH" : undefined,
+        report.opencodeAdapter ? "OpenCode" : undefined,
+    ].filter((name) => name !== undefined);
+}
+function lifecycleClientName(report) {
+    const names = selectedLifecycleClientNames(report);
+    if (names.length < 2)
+        return names[0];
+    if (names.length === 2)
+        return `${names[0]} and ${names[1]}`;
+    return `${names.slice(0, -1).join(", ")}, and ${names.at(-1)}`;
 }
 function claudeAdapterStatusLine(report, codexAdapter) {
     if (isOptionalUnconfiguredClaudeAdapter(report, codexAdapter)) {
@@ -785,6 +875,16 @@ function claudeAdapterStatusLine(report, codexAdapter) {
     }
     return adapterStatusLine(report);
 }
+function dshAdapterStatusLine(report) {
+    if (isOptionalUnavailableDshAdapter(report)) {
+        return `skipped ${report.reason ?? "not-detected"}`;
+    }
+    const version = report.version ?? report.dshVersion;
+    const tested = version && report.dshVersionTested !== undefined
+        ? ` version=${version} tested=${report.dshVersionTested}`
+        : "";
+    return `${adapterStatusLine(report)}${tested}`;
+}
 function argValue(argv, name) {
     const index = argv.indexOf(name);
     if (index >= 0)

package/lib/memorax-code-backend/dist/jsonl-append.js

@@ -1,75 +1 @@
-import { open } from "node:fs/promises";
-const JSONL_TAIL_SCAN_CHUNK_BYTES = 8 * 1024;
-const pathOperations = new Map();
-export async function appendRepairingJsonl(path, text) {
-    await serializePath(path, async () => {
-        const handle = await open(path, "a+", 0o600);
-        try {
-            const { rollbackSize, separator } = await prepareTailForAppend(handle);
-            try {
-                await handle.writeFile(`${separator}${text}`, "utf8");
-            }
-            catch (error) {
-                await handle.truncate(rollbackSize).catch(() => undefined);
-                throw error;
-            }
-        }
-        finally {
-            await handle.close();
-        }
-    });
-}
-async function serializePath(path, operation) {
-    const previous = pathOperations.get(path) ?? Promise.resolve();
-    const current = previous.catch(() => undefined).then(operation);
-    pathOperations.set(path, current);
-    try {
-        return await current;
-    }
-    finally {
-        if (pathOperations.get(path) === current)
-            pathOperations.delete(path);
-    }
-}
-async function prepareTailForAppend(handle) {
-    const size = (await handle.stat()).size;
-    if (size === 0)
-        return { rollbackSize: 0, separator: "" };
-    const lastByte = Buffer.allocUnsafe(1);
-    await readExactAt(handle, lastByte, size - 1);
-    if (lastByte[0] === 0x0a)
-        return { rollbackSize: size, separator: "" };
-    const tailStart = await jsonlTailStart(handle, size);
-    const tail = Buffer.allocUnsafe(size - tailStart);
-    await readExactAt(handle, tail, tailStart);
-    try {
-        JSON.parse(tail.toString("utf8"));
-        return { rollbackSize: size, separator: "\n" };
-    }
-    catch {
-        await handle.truncate(tailStart);
-        return { rollbackSize: tailStart, separator: "" };
-    }
-}
-async function jsonlTailStart(handle, size) {
-    let end = size;
-    while (end > 0) {
-        const start = Math.max(0, end - JSONL_TAIL_SCAN_CHUNK_BYTES);
-        const buffer = Buffer.allocUnsafe(end - start);
-        await readExactAt(handle, buffer, start);
-        const newline = buffer.lastIndexOf(0x0a);
-        if (newline >= 0)
-            return start + newline + 1;
-        end = start;
-    }
-    return 0;
-}
-async function readExactAt(handle, buffer, position) {
-    let offset = 0;
-    while (offset < buffer.length) {
-        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
-        if (bytesRead === 0)
-            throw new Error("failed to read JSONL tail");
-        offset += bytesRead;
-    }
-}
+export * from "./shared/jsonl-append.js";

package/lib/memorax-code-backend/dist/{active-client-selection.js → lifecycle/active-clients.js}

@@ -8,7 +8,18 @@ export function readActiveManagedClients(memoraxCodeHome) {
         const value = JSON.parse(readFileSync(path, "utf8"));
         if (typeof value.codex !== "boolean" || typeof value.claude !== "boolean")
             return undefined;
-        return { codex: value.codex, claude: value.claude };
+        if (value.opencode !== undefined && typeof value.opencode !== "boolean")
+            return undefined;
+        if (value.dsh !== undefined && typeof value.dsh !== "boolean")
+            return undefined;
+        return {
+            codex: value.codex,
+            claude: value.claude,
+            // Records written before DSH became a Backend participant cannot claim
+            // that the Backend was serving DSH.
+            dsh: value.dsh === true,
+            opencode: value.opencode === true,
+        };
     }
     catch {
         return undefined;

package/lib/memorax-code-backend/dist/{backend-service-cleanup.js → lifecycle/backend/cleanup.js}

@@ -1,4 +1,4 @@
-import { removeBackendServiceStateIfOwnedAtPath, } from "./backend-service-record.js";
+import { removeBackendServiceStateIfOwnedAtPath, } from "./record.js";
 export function clearBackendServiceState(path, state, action, prefix = "failed to clear Backend service state") {
     const result = removeBackendServiceStateIfOwnedAtPath(path, state);
     if (result.disposition === "removed"

package/lib/memorax-code-backend/dist/{backend-service-record.js → lifecycle/backend/record.js}

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { linkSync, readFileSync, rmSync, statSync, unlinkSync } from "node:fs";
-import { readJsonRuntimeRecord, RuntimeRecordError, writePrivateJsonRecord, } from "../../memorax-code-adapter-common/src/runtime-record.mjs";
+import { readJsonRuntimeRecord, RuntimeRecordError, writePrivateJsonRecord, } from "../../../../memorax-code-adapter-common/src/runtime-record.mjs";
 export const BACKEND_SERVICE_RECORD_VERSION = 1;
 const BACKEND_SERVICE_RECORD_KEYS = new Set([
     "version",

package/lib/memorax-code-backend/dist/{backend-service-result.js → lifecycle/backend/result.js}

@@ -1,5 +1,5 @@
-import { BackendConnectionAuthorityError } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
-import { RuntimeRecordError, } from "../../memorax-code-adapter-common/src/runtime-record.mjs";
+import { BackendConnectionAuthorityError } from "../../../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { RuntimeRecordError, } from "../../../../memorax-code-adapter-common/src/runtime-record.mjs";
 export function runtimeRecordServiceFailure(action, error) {
     return {
         ok: false,