@memorax/memorax-code 0.1.1 → 0.1.3

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

@@ -3,17 +3,22 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { BackendConnectionAuthorityError } from "../../memorax-code-adapter-common/src/backend-connection.mjs";
-import { RuntimeRecordError } from "../../memorax-code-adapter-common/src/runtime-record.mjs";
-import { runBackendStatus } from "./backend-status.js";
-import { readBackendServiceState, preflightBackendServiceStart, startBackendService, stopBackendService, } from "./service.js";
-import { backendServiceHome, BackendLifecycleLockError, withBackendLifecycleLock, } from "./backend-lifecycle-lock.js";
-import { seedMissingMemoraxCodeConfig } from "./memorax-config.js";
-import { runProcessWithWindowsNpm } from "./windows-cli-invocation.js";
+import { BackendConnectionAuthorityError } from "../../../memorax-code-adapter-common/src/backend-connection.mjs";
+import { RuntimeRecordError } from "../../../memorax-code-adapter-common/src/runtime-record.mjs";
+import { runBackendStatus } from "./backend/status.js";
+import { readBackendServiceState, preflightBackendServiceStart, startBackendService, stopBackendService, } from "./backend/service.js";
+import { backendServiceHome, BackendLifecycleLockError, withBackendLifecycleLock, } from "./lock.js";
+import { seedMissingMemoraxCodeConfig } from "../provider/memorax/config.js";
+import { runProcessWithWindowsNpm } from "../shared/windows-cli-invocation.js";
 import { loadManagedClientsConfig, resolveManagedClients } from "./client-selection.js";
-import { clearActiveManagedClients, readActiveManagedClients, writeActiveManagedClients } from "./active-client-selection.js";
-import { codexAdapterLifecycle } from "./codex-adapter-lifecycle.js";
-import { claudeAdapterLifecycle } from "./claude-adapter-lifecycle.js";
+import { clearActiveManagedClients, readActiveManagedClients, writeActiveManagedClients } from "./active-clients.js";
+import { codexAdapterLifecycle } from "../clients/codex/lifecycle.js";
+import { claudeAdapterLifecycle } from "../clients/claude/lifecycle.js";
+import { collectDshAdapterLifecycleStatus, withDshAdapterLifecycleLock, } from "../clients/dsh/lifecycle.js";
+import { openCodeAdapterLifecycle } from "../clients/opencode/lifecycle.js";
+const PACKAGE_REPLACEMENT_ENV = "MEMORAX_CODE_PACKAGE_REPLACEMENT";
+const DSH_RECOVERY_ENV = "MEMORAX_CODE_DSH_ADAPTER_RECOVERY";
+const DSH_RECOVERY_REVISION_ENV = "MEMORAX_CODE_DSH_ADAPTER_EXPECTED_REVISION";
 export async function collectMemoraxCodeStatus(backendUrl, backendToken, serviceOptions, argv) {
     const clients = managedClientsFor(argv, serviceOptions, { preferActive: true });
     let serviceState;
@@ -45,22 +50,34 @@ export async function collectMemoraxCodeStatus(backendUrl, backendToken, service
     const claudeAdapter = clients.claude
         ? await claudeAdapterLifecycle.status({ argv, serviceOptions, backendUrl })
         : undefined;
+    const dshAdapter = clients.dsh
+        ? await collectDshAdapterLifecycleStatus({ argv, serviceOptions, backendUrl })
+        : undefined;
+    const opencodeAdapter = clients.opencode
+        ? await openCodeAdapterLifecycle.status({ argv, serviceOptions, backendUrl })
+        : undefined;
     const codexReady = codexAdapter ? isAdapterReady(codexAdapter) : true;
     const claudeReady = claudeAdapter ? isAdapterReady(claudeAdapter) : true;
+    const dshReady = dshAdapter ? isAdapterReady(dshAdapter) : true;
+    const opencodeReady = opencodeAdapter ? isAdapterReady(opencodeAdapter) : true;
     return {
         ok: backend.ok
             && codexReady
-            && (isOptionalUnconfiguredClaudeAdapter(claudeAdapter, codexAdapter) || claudeReady),
+            && opencodeReady
+            && (isOptionalUnconfiguredClaudeAdapter(claudeAdapter, codexAdapter) || claudeReady)
+            && (isOptionalUnavailableDshAdapter(dshAdapter) || dshReady),
         action: "status",
         backend,
         ...(codexAdapter ? { codexAdapter } : {}),
         ...(claudeAdapter ? { claudeAdapter } : {}),
+        ...(dshAdapter ? { dshAdapter } : {}),
+        ...(opencodeAdapter ? { opencodeAdapter } : {}),
     };
 }
 export async function startMemoraxCodeService(serviceOptions, argv, commitReadyState) {
     return withMemoraxCodeLifecycleLock("start", serviceOptions, async () => {
         const report = await startMemoraxCodeServiceLocked(serviceOptions, argv);
-        if (report.ok)
+        if (report.ok && report.backend?.ok)
             await commitReadyState?.(report);
         return report;
     });
@@ -88,16 +105,70 @@ async function startMemoraxCodeServiceLocked(serviceOptions, argv) {
         return { ok: false, action: "start", backend: serviceStateFailure };
     }
     const config = loadManagedClientsConfig(memoraxCodeHome);
-    const clients = resolveManagedClients(argv, config);
+    const requestedClients = resolveManagedClients(argv, config);
+    const clients = isDshAdapterRecovery()
+        ? { ...requestedClients, dsh: true }
+        : requestedClients;
     const previousClients = readActiveManagedClients(memoraxCodeHome);
+    const context = { argv, serviceOptions };
+    if (clients.dsh || previousClients?.dsh || isDshAdapterRecovery()) {
+        try {
+            return await withDshAdapterLifecycleLock(context, (dshLifecycle) => (executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memoraxCodeHome, clients, previousClients, dshLifecycle)));
+        }
+        catch (error) {
+            return dshLifecycleFailure("start", error);
+        }
+    }
+    return executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memoraxCodeHome, clients, previousClients);
+}
+async function executeMemoraxCodeStart(serviceOptions, argv, backendUrl, memoraxCodeHome, clients, previousClients, dshLifecycle) {
+    const lifecycleContext = { argv, serviceOptions };
+    const lifecycleBackendContext = { ...lifecycleContext, backendUrl };
+    if (isDshAdapterRecovery() && dshLifecycle) {
+        const status = await dshLifecycle.status(lifecycleBackendContext);
+        const expectedRevision = nonEmptyString(process.env[DSH_RECOVERY_REVISION_ENV])
+            ? process.env[DSH_RECOVERY_REVISION_ENV]
+            : undefined;
+        if (!expectedRevision
+            || status.ok !== true
+            || status.enabled !== true
+            || status.revision !== expectedRevision) {
+            return {
+                ok: true,
+                action: "start",
+                reason: "dsh_recovery_not_authorized",
+                dshAdapter: {
+                    ...status,
+                    skipped: true,
+                    reason: "dsh_recovery_not_authorized",
+                },
+            };
+        }
+    }
+    const quiescedDsh = dshLifecycle && (clients.dsh || previousClients?.dsh)
+        ? await dshLifecycle.quiesce?.(lifecycleContext)
+        : undefined;
+    if (quiescedDsh?.ok === false) {
+        return {
+            ok: false,
+            action: "start",
+            backend: preservedBackendResult(serviceOptions, "dsh_adapter_quiesce_failed", "start"),
+            dshAdapter: quiescedDsh,
+        };
+    }
+    const recoverPreparationFailure = (reason) => recoverStartPreparationFailure(serviceOptions, reason, dshLifecycle, lifecycleBackendContext, quiescedDsh);
     // A failed Backend ownership check must leave the active client generation
     // and its conservative cleanup marker untouched.
     const stopped = await stopBackendService(serviceOptions);
     if (!stopped.ok) {
+        const restoredDsh = await reactivatePreviouslyEnabledDsh(dshLifecycle, lifecycleContext, quiescedDsh);
         return {
             ok: false,
             action: "start",
             backend: { ...stopped, action: "start" },
+            ...(restoredDsh || quiescedDsh
+                ? { dshAdapter: restoredDsh ?? quiescedDsh }
+                : {}),
         };
     }
     const deselectedCodex = previousClients?.codex && !clients.codex
@@ -106,13 +177,27 @@ async function startMemoraxCodeServiceLocked(serviceOptions, argv) {
     const deselectedClaude = previousClients?.claude && !clients.claude
         ? await claudeAdapterLifecycle.disable({ argv, serviceOptions })
         : undefined;
-    if (deselectedCodex?.ok === false || deselectedClaude?.ok === false) {
+    const deselectedDsh = previousClients?.dsh && !clients.dsh && dshLifecycle
+        ? await dshLifecycle.disable({ argv, serviceOptions })
+        : undefined;
+    const deselectedOpenCode = previousClients?.opencode && !clients.opencode
+        ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
+        : undefined;
+    if (deselectedCodex?.ok === false
+        || deselectedClaude?.ok === false
+        || deselectedDsh?.ok === false
+        || deselectedOpenCode?.ok === false) {
+        const recovery = await recoverPreparationFailure("adapter_disable_failed");
         return {
             ok: false,
             action: "start",
-            backend: await recoverBackendAfterStartPreparationFailure(serviceOptions, "adapter_disable_failed"),
+            backend: recovery.backend,
             ...(deselectedCodex ? { codexAdapter: deselectedCodex } : {}),
             ...(deselectedClaude ? { claudeAdapter: deselectedClaude } : {}),
+            ...(recovery.dshAdapter || deselectedDsh
+                ? { dshAdapter: recovery.dshAdapter ?? deselectedDsh }
+                : {}),
+            ...(deselectedOpenCode ? { opencodeAdapter: deselectedOpenCode } : {}),
         };
     }
     // The marker is a conservative cleanup scope, not a readiness signal. Persist
@@ -123,51 +208,95 @@ async function startMemoraxCodeServiceLocked(serviceOptions, argv) {
         await seedMissingMemoraxCodeConfig(memoraxCodeHomeForService(serviceOptions));
     }
     catch (error) {
+        const recovery = await recoverPreparationFailure("lifecycle_state_prepare_failed");
         return {
             ok: false,
             action: "start",
             reason: "lifecycle_state_prepare_failed",
             message: error instanceof Error ? error.message : String(error),
-            backend: await recoverBackendAfterStartPreparationFailure(serviceOptions, "lifecycle_state_prepare_failed"),
+            backend: recovery.backend,
+            ...(recovery.dshAdapter ? { dshAdapter: recovery.dshAdapter } : {}),
         };
     }
     const codexAdapter = clients.codex
         ? await codexAdapterLifecycle.prepareEnable({ argv, serviceOptions, backendUrl })
         : undefined;
     if (codexAdapter?.ok === false) {
+        const recovery = await recoverPreparationFailure("codex_adapter_enable_failed");
         return {
             ok: false,
             action: "start",
-            backend: await recoverBackendAfterStartPreparationFailure(serviceOptions, "codex_adapter_enable_failed"),
+            backend: recovery.backend,
             codexAdapter,
+            ...(recovery.dshAdapter ? { dshAdapter: recovery.dshAdapter } : {}),
         };
     }
     const claudeAdapter = clients.claude
         ? await claudeAdapterLifecycle.prepareEnable({ argv, serviceOptions, backendUrl })
         : undefined;
+    const opencodeAdapter = clients.opencode
+        ? await openCodeAdapterLifecycle.prepareEnable({ argv, serviceOptions, backendUrl })
+        : undefined;
+    if (opencodeAdapter?.ok === false) {
+        const recovery = await recoverPreparationFailure("opencode_adapter_enable_failed");
+        return {
+            ok: false,
+            action: "start",
+            backend: recovery.backend,
+            ...(codexAdapter ? { codexAdapter } : {}),
+            ...(claudeAdapter ? { claudeAdapter } : {}),
+            ...(recovery.dshAdapter ? { dshAdapter: recovery.dshAdapter } : {}),
+            opencodeAdapter,
+        };
+    }
+    const preparedDshAdapter = clients.dsh && dshLifecycle
+        ? await dshLifecycle.prepareEnable(lifecycleBackendContext)
+        : undefined;
+    if (preparedDshAdapter?.ok === false) {
+        const recovery = await recoverPreparationFailure("dsh_adapter_enable_failed");
+        return {
+            ok: false,
+            action: "start",
+            backend: recovery.backend,
+            ...(codexAdapter ? { codexAdapter } : {}),
+            ...(claudeAdapter ? { claudeAdapter } : {}),
+            dshAdapter: recovery.dshAdapter ?? preparedDshAdapter,
+            ...(opencodeAdapter ? { opencodeAdapter } : {}),
+        };
+    }
     const backendStartOptions = {
         ...serviceOptions,
         claudeProjectsRoot: claudeProjectsRootForStart(argv, claudeAdapter),
     };
     const backend = await startBackendService(backendStartOptions);
     if (!backend.ok) {
-        const disabled = codexAdapter
+        const disabledCodex = codexAdapter
             ? await codexAdapterLifecycle.disable({ argv, serviceOptions })
             : undefined;
+        const disabledOpenCode = opencodeAdapter
+            ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
+            : undefined;
         return {
             ok: false,
             action: "start",
             backend,
-            ...(disabled ? { codexAdapter: disabled } : {}),
+            ...(disabledCodex ? { codexAdapter: disabledCodex } : {}),
             ...(claudeAdapter ? { claudeAdapter } : {}),
+            ...(preparedDshAdapter ? { dshAdapter: preparedDshAdapter } : {}),
+            ...(disabledOpenCode ? { opencodeAdapter: disabledOpenCode } : {}),
         };
     }
+    const dshAdapter = preparedDshAdapter?.installed === true
+        ? await dshLifecycle?.activate?.(lifecycleBackendContext)
+        : preparedDshAdapter;
     return {
-        ok: claudeAdapter?.ok !== false,
+        ok: claudeAdapter?.ok !== false && dshAdapter?.ok !== false,
         action: "start",
         backend,
         ...(codexAdapter ? { codexAdapter } : {}),
         ...(claudeAdapter ? { claudeAdapter } : {}),
+        ...(dshAdapter ? { dshAdapter } : {}),
+        ...(opencodeAdapter ? { opencodeAdapter } : {}),
     };
 }
 function claudeProjectsRootForStart(argv, claudeAdapter) {
@@ -187,12 +316,20 @@ export async function stopMemoraxCodeService(serviceOptions, argv) {
 }
 async function stopMemoraxCodeServiceLocked(serviceOptions, argv) {
     const context = memoraxCodeStopContext(serviceOptions, argv);
-    const execution = await executeMemoraxCodeStop(serviceOptions, argv, context);
+    let execution;
+    try {
+        execution = context.clients.dsh
+            ? await withDshAdapterLifecycleLock({ argv, serviceOptions }, (dshLifecycle) => (executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycle)))
+            : await executeMemoraxCodeStop(serviceOptions, argv, context);
+    }
+    catch (error) {
+        return dshLifecycleFailure("stop", error);
+    }
     if (execution.report.ok)
         commitActiveManagedClients(context.memoraxCodeHome, execution.remainingClients);
     return execution.report;
 }
-async function executeMemoraxCodeStop(serviceOptions, argv, context) {
+async function executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycle) {
     const { activeClients, clients } = context;
     const serviceStateFailure = backendServiceStatePreflight(serviceOptions, "stop");
     if (serviceStateFailure) {
@@ -209,22 +346,47 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context) {
         ? {
             codex: activeClients.codex && !clients.codex,
             claude: activeClients.claude && !clients.claude,
+            dsh: activeClients.dsh && !clients.dsh,
+            opencode: activeClients.opencode && !clients.opencode,
         }
         : undefined;
-    const hasRemainingClients = remaining?.codex === true || remaining?.claude === true;
-    const backendOnlyStop = !clients.codex && !clients.claude;
-    const needsBackendStop = backendOnlyStop || !hasRemainingClients;
-    // A true partial stop keeps the shared Backend for remaining clients. Every
-    // other stop establishes Backend shutdown before mutating client state.
+    const hasRemainingClients = remaining?.codex === true
+        || remaining?.claude === true
+        || remaining?.dsh === true
+        || remaining?.opencode === true;
+    const backendOnlyStop = !clients.codex && !clients.claude && !clients.dsh && !clients.opencode;
+    const packageReplacement = isPackageReplacement();
+    const needsBackendStop = packageReplacement || backendOnlyStop || !hasRemainingClients;
+    const quiescedDsh = clients.dsh && dshLifecycle
+        ? await dshLifecycle.quiesce?.({ argv, serviceOptions })
+        : undefined;
+    if (quiescedDsh?.ok === false) {
+        return {
+            report: {
+                ok: false,
+                action: "stop",
+                backend: preservedBackendResult(serviceOptions, "dsh_adapter_quiesce_failed"),
+                dshAdapter: quiescedDsh,
+            },
+            remainingClients: activeClients,
+        };
+    }
+    // A true partial stop keeps the shared Backend for remaining clients. DSH
+    // publishes its inert sentinel first; every other adapter is disabled only
+    // after an accepted Backend shutdown.
     const stoppedBackend = needsBackendStop
         ? await stopBackendService(serviceOptions)
         : undefined;
     if (stoppedBackend?.ok === false) {
+        const restoredDsh = await reactivatePreviouslyEnabledDsh(dshLifecycle, { argv, serviceOptions }, quiescedDsh);
         return {
             report: {
                 ok: false,
                 action: "stop",
                 backend: stoppedBackend,
+                ...(restoredDsh || quiescedDsh
+                    ? { dshAdapter: restoredDsh ?? quiescedDsh }
+                    : {}),
             },
             remainingClients: activeClients,
         };
@@ -235,12 +397,25 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context) {
     const claudeAdapter = clients.claude
         ? await claudeAdapterLifecycle.disable({ argv, serviceOptions })
         : undefined;
-    const adaptersOk = codexAdapter?.ok !== false && claudeAdapter?.ok !== false;
+    const dshAdapter = clients.dsh && dshLifecycle
+        ? await dshLifecycle.disable({ argv, serviceOptions })
+        : undefined;
+    const opencodeAdapter = clients.opencode
+        ? await openCodeAdapterLifecycle.disable({ argv, serviceOptions })
+        : undefined;
+    const adaptersOk = codexAdapter?.ok !== false
+        && claudeAdapter?.ok !== false
+        && dshAdapter?.ok !== false
+        && opencodeAdapter?.ok !== false;
     const backend = stoppedBackend
         ?? (adaptersOk
             ? preservedBackendResult(serviceOptions, "active_clients_remaining")
             : preservedBackendResult(serviceOptions, "adapter_disable_failed"));
-    const ok = backend.ok && codexAdapter?.ok !== false && claudeAdapter?.ok !== false;
+    const ok = backend.ok
+        && codexAdapter?.ok !== false
+        && claudeAdapter?.ok !== false
+        && dshAdapter?.ok !== false
+        && opencodeAdapter?.ok !== false;
     return {
         report: {
             ok,
@@ -248,6 +423,8 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context) {
             backend,
             ...(codexAdapter ? { codexAdapter } : {}),
             ...(claudeAdapter ? { claudeAdapter } : {}),
+            ...(dshAdapter ? { dshAdapter } : {}),
+            ...(opencodeAdapter ? { opencodeAdapter } : {}),
         },
         remainingClients: remaining && hasRemainingClients ? remaining : undefined,
     };
@@ -255,7 +432,7 @@ async function executeMemoraxCodeStop(serviceOptions, argv, context) {
 export async function restartMemoraxCodeService(serviceOptions, argv, commitReadyState) {
     return withMemoraxCodeLifecycleLock("restart", serviceOptions, async () => {
         const report = await restartMemoraxCodeServiceLocked(serviceOptions, argv);
-        if (report.ok)
+        if (report.ok && report.backend?.ok)
             await commitReadyState?.(report);
         return report;
     });
@@ -284,11 +461,22 @@ export async function uninstallMemoraxCodeService(serviceOptions, argv) {
 }
 async function uninstallMemoraxCodeServiceLocked(serviceOptions, argv) {
     const context = memoraxCodeStopContext(serviceOptions, argv);
+    if (context.clients.dsh) {
+        try {
+            return await withDshAdapterLifecycleLock({ argv, serviceOptions }, (dshLifecycle) => (executeMemoraxCodeUninstall(serviceOptions, argv, context, dshLifecycle)));
+        }
+        catch (error) {
+            return dshLifecycleFailure("uninstall", error);
+        }
+    }
+    return executeMemoraxCodeUninstall(serviceOptions, argv, context);
+}
+async function executeMemoraxCodeUninstall(serviceOptions, argv, context, dshLifecycle) {
     const { activeClients, clients, memoraxCodeHome } = context;
-    const configuredClients = managedClientsFor([], serviceOptions);
+    const configuredClients = configuredClientsForPackageRemoval(serviceOptions);
     const canRemoveSharedPackage = includesManagedClients(clients, configuredClients)
         && (!activeClients || includesManagedClients(clients, activeClients));
-    const stopExecution = await executeMemoraxCodeStop(serviceOptions, argv, context);
+    const stopExecution = await executeMemoraxCodeStop(serviceOptions, argv, context, dshLifecycle);
     const stopped = stopExecution.report;
     if (!stopped.ok) {
         return {
@@ -305,8 +493,16 @@ async function uninstallMemoraxCodeServiceLocked(serviceOptions, argv) {
     const claudePlugin = clients.claude
         ? await claudeAdapterLifecycle.remove({ argv, serviceOptions })
         : undefined;
+    const dshPlugin = clients.dsh && dshLifecycle
+        ? await dshLifecycle.remove({ argv, serviceOptions })
+        : undefined;
+    const opencodePlugin = clients.opencode
+        ? await openCodeAdapterLifecycle.remove({ argv, serviceOptions })
+        : undefined;
     const pluginCleanupOk = codexPlugin?.ok !== false
-        && claudePlugin?.ok !== false;
+        && claudePlugin?.ok !== false
+        && dshPlugin?.ok !== false
+        && opencodePlugin?.ok !== false;
     const npmPackageRemoval = !pluginCleanupOk
         ? skippedNpmPackageRemoval("plugin_cleanup_failed")
         : canRemoveSharedPackage
@@ -315,6 +511,10 @@ async function uninstallMemoraxCodeServiceLocked(serviceOptions, argv) {
     const claudeAdapter = stopped.claudeAdapter && claudePlugin
         ? { ...stopped.claudeAdapter, pluginRemove: claudePlugin }
         : stopped.claudeAdapter;
+    const dshAdapter = dshPlugin ?? stopped.dshAdapter;
+    const opencodeAdapter = stopped.opencodeAdapter && opencodePlugin
+        ? { ...stopped.opencodeAdapter, pluginRemove: opencodePlugin }
+        : stopped.opencodeAdapter;
     const ok = pluginCleanupOk && npmPackageRemoval.ok !== false;
     if (ok)
         commitActiveManagedClients(memoraxCodeHome, stopExecution.remainingClients);
@@ -324,8 +524,13 @@ async function uninstallMemoraxCodeServiceLocked(serviceOptions, argv) {
         action: "uninstall",
         ...(codexPlugin ? { codexPlugin } : {}),
         ...(claudeAdapter ? { claudeAdapter } : {}),
+        ...(dshAdapter ? { dshAdapter } : {}),
+        ...(opencodeAdapter ? { opencodeAdapter } : {}),
         npmPackageRemoval,
-        removesPlugin: codexPlugin?.ok === true || claudePlugin?.ok === true,
+        removesPlugin: codexPlugin?.ok === true
+            || claudePlugin?.ok === true
+            || (dshPlugin?.ok === true && dshPlugin.skipped !== true)
+            || opencodePlugin?.ok === true,
         removesUserState: false,
     };
 }
@@ -403,12 +608,25 @@ function managedClientsFor(argv, serviceOptions, options = {}) {
     }
     return resolveManagedClients(argv, loadManagedClientsConfig(memoraxCodeHome));
 }
+function configuredClientsForPackageRemoval(serviceOptions) {
+    const memoraxCodeHome = memoraxCodeHomeForService(serviceOptions);
+    const config = loadManagedClientsConfig(memoraxCodeHome);
+    const configured = resolveManagedClients([], config);
+    const legacyDshSelection = config.clients !== undefined
+        && config.clients.dsh === undefined;
+    const ownsDshIntegration = existsSync(join(memoraxCodeHome, "adapters", "dsh", "state.json"));
+    return legacyDshSelection && !ownsDshIntegration
+        ? { ...configured, dsh: false }
+        : configured;
+}
 function memoraxCodeStopContext(serviceOptions, argv) {
     const memoraxCodeHome = memoraxCodeHomeForService(serviceOptions);
     return {
         memoraxCodeHome,
         activeClients: readActiveManagedClients(memoraxCodeHome),
-        clients: managedClientsFor(argv, serviceOptions, { preferActive: true }),
+        clients: isPackageReplacement()
+            ? { codex: false, claude: false, dsh: true, opencode: false }
+            : managedClientsFor(argv, serviceOptions, { preferActive: true }),
     };
 }
 function commitActiveManagedClients(memoraxCodeHome, clients) {
@@ -425,7 +643,19 @@ function argValue(argv, name) {
     return index >= 0 ? argv[index + 1] : undefined;
 }
 function includesManagedClients(selection, required) {
-    return (!required.codex || selection.codex) && (!required.claude || selection.claude);
+    return (!required.codex || selection.codex)
+        && (!required.claude || selection.claude)
+        && (!required.dsh || selection.dsh)
+        && (!required.opencode || selection.opencode);
+}
+function isPackageReplacement() {
+    return truthyEnv(process.env[PACKAGE_REPLACEMENT_ENV]);
+}
+function isDshAdapterRecovery() {
+    return truthyEnv(process.env[DSH_RECOVERY_ENV]);
+}
+function truthyEnv(value) {
+    return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
 }
 function preservedBackendResult(serviceOptions, reason, action = "stop") {
     const state = readBackendServiceState(serviceOptions);
@@ -457,6 +687,41 @@ async function recoverBackendAfterStartPreparationFailure(serviceOptions, reason
         };
     }
 }
+async function recoverStartPreparationFailure(serviceOptions, reason, dshLifecycle, context, quiescedDsh) {
+    const backend = await recoverBackendAfterStartPreparationFailure(serviceOptions, reason);
+    const dshAdapter = backend.ok
+        ? await restorePreviouslyEnabledDsh(dshLifecycle, context, quiescedDsh)
+        : undefined;
+    return { backend, ...(dshAdapter ? { dshAdapter } : {}) };
+}
+async function restorePreviouslyEnabledDsh(dshLifecycle, context, quiescedDsh) {
+    const activated = await reactivatePreviouslyEnabledDsh(dshLifecycle, context, quiescedDsh);
+    if (activated?.ok !== false
+        && activated?.enabled === true
+        && sameDshProfileSet(activated.profiles, quiescedDsh?.profiles))
+        return activated;
+    if (!dshLifecycle || quiescedDsh?.previouslyEnabled !== true)
+        return undefined;
+    const prepared = await dshLifecycle.prepareEnable(context);
+    if (prepared.ok === false || prepared.installed !== true)
+        return prepared;
+    return await dshLifecycle.activate?.(context) ?? prepared;
+}
+function sameDshProfileSet(actual, expected) {
+    if (!actual?.every(nonEmptyString) || !expected?.every(nonEmptyString))
+        return false;
+    const actualNames = new Set(actual);
+    const expectedNames = new Set(expected);
+    return actualNames.size === actual.length
+        && expectedNames.size === expected.length
+        && actualNames.size === expectedNames.size
+        && [...actualNames].every((name) => expectedNames.has(name));
+}
+async function reactivatePreviouslyEnabledDsh(dshLifecycle, context, quiescedDsh) {
+    if (!dshLifecycle || quiescedDsh?.previouslyEnabled !== true)
+        return undefined;
+    return await dshLifecycle.activate?.(context);
+}
 function backendServiceStatePreflight(serviceOptions, action) {
     try {
         readBackendServiceState(serviceOptions);
@@ -501,14 +766,22 @@ async function withMemoraxCodeLifecycleLock(action, serviceOptions, operation) {
     }
 }
 export function isAdapterReady(report) {
-    const hookIntegration = report.integration === "hooks" || report.state?.integration === "hooks";
-    return hookIntegration
+    const integration = report.integration ?? report.state?.integration;
+    return (integration === "hooks" || integration === "plugin")
         && report.ok !== false
         && report.installed === true
         && report.enabled === true
         && report.backendUrlMatches !== false
         && report.codexSkills?.ok !== false
-        && report.claudeSkills?.ok !== false;
+        && report.claudeSkills?.ok !== false
+        && report.opencodeSkills?.ok !== false;
+}
+export function isOptionalUnavailableDshAdapter(report) {
+    return Boolean(report
+        && report.ok !== false
+        && report.skipped === true
+        && report.managed !== true
+        && report.reason === "no_existing_profiles");
 }
 export function isOptionalUnconfiguredClaudeAdapter(report, codexAdapter) {
     return Boolean(report
@@ -521,3 +794,16 @@ export function isOptionalUnconfiguredClaudeAdapter(report, codexAdapter) {
 function nonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
+function dshLifecycleFailure(action, error) {
+    return {
+        ok: false,
+        action,
+        dshAdapter: {
+            ok: false,
+            action,
+            integration: "plugin",
+            runtime: "dsh",
+            error: error instanceof Error ? error.message : String(error),
+        },
+    };
+}

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

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
-import { runMemoryCli } from "./memory-cli.js";
+import { runMemoryCli } from "./memory/cli.js";
 runMemoryCli(process.argv.slice(2)).then((result) => {
     if (!process.argv.includes("--json") && result.ok && result.action === "memory.search") {
+        if (result.userNotice)
+            console.warn(`Warning: ${result.userNotice}`);
         console.log(result.answer?.trim() || "No memory context returned.");
     }
     else {

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

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { runBackendCli } from "./server-cli.js";
+import { runBackendCli } from "./entrypoints/backend-cli.js";
 runBackendCli(process.argv);

package/lib/memorax-code-backend/dist/{automatic-memory-retrieval.js → memory/automatic-retrieval.js}

@@ -1,6 +1,6 @@
-import { invokeMemoraxMemoryProvider } from "./memorax-adapter.js";
-import { memoryRetrievalEnabled, startupRetrieveTimeoutMs, } from "./memorax-config.js";
-import { isRecord } from "./utils.js";
+import { invokeMemoraxMemoryProvider } from "../provider/memorax/adapter.js";
+import { memoryRetrievalEnabled, startupRetrieveTimeoutMs, } from "../provider/memorax/config.js";
+import { isRecord } from "../shared/record.js";
 const AUTOMATIC_MEMORY_CONTEXT_MAX_CHARS = 9_000;
 export async function retrieveAutomaticMemoryContext(options) {
     const startedAt = Date.now();