diff --git a/package-lock.json b/package-lock.json
index 24f79db08f..768925bfa7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,6 +14,7 @@
                 "@deepnote/blocks": "^4.3.0",
                 "@deepnote/convert": "^3.2.0",
                 "@deepnote/database-integrations": "^1.4.3",
+                "@deepnote/runtime-core": "^0.2.0",
                 "@deepnote/sql-language-server": "^3.0.0",
                 "@enonic/fnv-plus": "^1.3.0",
                 "@jupyter-widgets/base": "^6.0.8",
@@ -1971,6 +1972,40 @@
                 "url": "https://github.com/sponsors/colinhacks"
             }
         },
+        "node_modules/@deepnote/runtime-core": {
+            "version": "0.2.0",
+            "resolved": "https://registry.npmjs.org/@deepnote/runtime-core/-/runtime-core-0.2.0.tgz",
+            "integrity": "sha512-wIgUOSROSyFpfFd+Mx/9GA3mHdyJ7aIqs4bejS0SUr5ogC+wo1xj+ZfwfEzMQRse9M8f5SKn8qj6zjnykKRTJg==",
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@deepnote/blocks": "4.3.0",
+                "@jupyterlab/nbformat": "^4.3.2",
+                "@jupyterlab/services": "^7.3.2",
+                "tcp-port-used": "^1.0.2",
+                "ws": "^8.18.0"
+            }
+        },
+        "node_modules/@deepnote/runtime-core/node_modules/ws": {
+            "version": "8.19.0",
+            "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+            "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=10.0.0"
+            },
+            "peerDependencies": {
+                "bufferutil": "^4.0.1",
+                "utf-8-validate": ">=5.0.2"
+            },
+            "peerDependenciesMeta": {
+                "bufferutil": {
+                    "optional": true
+                },
+                "utf-8-validate": {
+                    "optional": true
+                }
+            }
+        },
         "node_modules/@deepnote/sql-language-server": {
             "version": "3.0.0",
             "resolved": "https://registry.npmjs.org/@deepnote/sql-language-server/-/sql-language-server-3.0.0.tgz",
@@ -32560,6 +32595,26 @@
                 }
             }
         },
+        "@deepnote/runtime-core": {
+            "version": "0.2.0",
+            "resolved": "https://registry.npmjs.org/@deepnote/runtime-core/-/runtime-core-0.2.0.tgz",
+            "integrity": "sha512-wIgUOSROSyFpfFd+Mx/9GA3mHdyJ7aIqs4bejS0SUr5ogC+wo1xj+ZfwfEzMQRse9M8f5SKn8qj6zjnykKRTJg==",
+            "requires": {
+                "@deepnote/blocks": "4.3.0",
+                "@jupyterlab/nbformat": "^4.3.2",
+                "@jupyterlab/services": "^7.3.2",
+                "tcp-port-used": "^1.0.2",
+                "ws": "^8.18.0"
+            },
+            "dependencies": {
+                "ws": {
+                    "version": "8.19.0",
+                    "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+                    "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+                    "requires": {}
+                }
+            }
+        },
         "@deepnote/sql-language-server": {
             "version": "3.0.0",
             "resolved": "https://registry.npmjs.org/@deepnote/sql-language-server/-/sql-language-server-3.0.0.tgz",
diff --git a/package.json b/package.json
index aa2a4eda19..790cef3583 100644
--- a/package.json
+++ b/package.json
@@ -2676,6 +2676,7 @@
         "@deepnote/blocks": "^4.3.0",
         "@deepnote/convert": "^3.2.0",
         "@deepnote/database-integrations": "^1.4.3",
+        "@deepnote/runtime-core": "^0.2.0",
         "@deepnote/sql-language-server": "^3.0.0",
         "@enonic/fnv-plus": "^1.3.0",
         "@jupyter-widgets/base": "^6.0.8",
diff --git a/src/kernels/deepnote/deepnoteLspClientManager.node.vscode.test.ts b/src/kernels/deepnote/deepnoteLspClientManager.node.vscode.test.ts
index 5195d0a28b..31a6c85845 100644
--- a/src/kernels/deepnote/deepnoteLspClientManager.node.vscode.test.ts
+++ b/src/kernels/deepnote/deepnoteLspClientManager.node.vscode.test.ts
@@ -2,6 +2,7 @@ import { assert } from 'chai';
 import { Uri } from 'vscode';
 
 import { DeepnoteLspClientManager } from './deepnoteLspClientManager.node';
+import { createMockChildProcess } from './deepnoteTestHelpers.node';
 import { IDisposableRegistry } from '../../platform/common/types';
 import { PythonEnvironment } from '../../platform/pythonEnvironments/info';
 import * as path from '../../platform/vscode-path/path';
@@ -84,7 +85,8 @@ suite('DeepnoteLspClientManager Integration Tests', () => {
             url: 'http://localhost:8888',
             jupyterPort: 8888,
             lspPort: 8889,
-            token: 'test-token'
+            token: 'test-token',
+            process: createMockChildProcess()
         };
 
         // This will attempt to start LSP clients but may fail if pylsp isn't installed
@@ -135,7 +137,8 @@ suite('DeepnoteLspClientManager Integration Tests', () => {
             url: 'http://localhost:8888',
             jupyterPort: 8888,
             lspPort: 8889,
-            token: 'test-token'
+            token: 'test-token',
+            process: createMockChildProcess()
         };
 
         try {
@@ -166,7 +169,8 @@ suite('DeepnoteLspClientManager Integration Tests', () => {
             url: 'http://localhost:8888',
             jupyterPort: 8888,
             lspPort: 8889,
-            token: 'test-token'
+            token: 'test-token',
+            process: createMockChildProcess()
         };
 
         try {
diff --git a/src/kernels/deepnote/deepnoteServerStarter.node.ts b/src/kernels/deepnote/deepnoteServerStarter.node.ts
index fe41270e0f..112f7f0e09 100644
--- a/src/kernels/deepnote/deepnoteServerStarter.node.ts
+++ b/src/kernels/deepnote/deepnoteServerStarter.node.ts
@@ -1,29 +1,36 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
+/**
+ * @deepnote/runtime-core functions not currently exported that would be useful:
+ * - waitForServer(info, timeoutMs) — health-check polling on /api
+ * - createJsonWebSocketFactory() — forces JSON-only Jupyter WS protocol, potential stability improvement
+ * - ExecutionEngine.toPythonLiteral(value) — JS-to-Python literal conversion
+ */
 
 import * as fs from 'fs-extra';
 import { inject, injectable, named, optional } from 'inversify';
 import * as os from 'os';
 import { CancellationToken, l10n, Uri } from 'vscode';
+
+import { startServer, stopServer } from '@deepnote/runtime-core';
+
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
-import { Cancellation, raceCancellationError } from '../../platform/common/cancellation';
+import { Cancellation } from '../../platform/common/cancellation';
 import { STANDARD_OUTPUT_CHANNEL } from '../../platform/common/constants';
-import { IProcessServiceFactory, ObservableExecutionResult } from '../../platform/common/process/types.node';
-import { IAsyncDisposableRegistry, IDisposable, IHttpClient, IOutputChannel } from '../../platform/common/types';
+import { IProcessServiceFactory } from '../../platform/common/process/types.node';
+import { IAsyncDisposableRegistry, IDisposable, IOutputChannel } from '../../platform/common/types';
 import { sleep } from '../../platform/common/utils/async';
 import { generateUuid } from '../../platform/common/uuid';
-import { DeepnoteServerStartupError, DeepnoteServerTimeoutError } from '../../platform/errors/deepnoteKernelErrors';
+import { DeepnoteServerStartupError } from '../../platform/errors/deepnoteKernelErrors';
 import { logger } from '../../platform/logging';
 import { ISqlIntegrationEnvVarsProvider } from '../../platform/notebooks/deepnote/types';
 import { PythonEnvironment } from '../../platform/pythonEnvironments/info';
 import * as path from '../../platform/vscode-path/path';
-import { DEEPNOTE_DEFAULT_PORT, DeepnoteServerInfo, IDeepnoteServerStarter, IDeepnoteToolkitInstaller } from './types';
+import { DeepnoteServerInfo, IDeepnoteServerStarter, IDeepnoteToolkitInstaller } from './types';
 import { DeepnoteAgentSkillsManager } from './deepnoteAgentSkillsManager.node';
-import tcpPortUsed from 'tcp-port-used';
 
-/**
- * Lock file data structure for tracking server ownership
- */
+const MAX_OUTPUT_TRACKING_LENGTH = 5000;
+const SERVER_STARTUP_TIMEOUT_MS = 120_000;
+const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 3000;
+
 interface ServerLockFile {
     sessionId: string;
     pid: number;
@@ -42,65 +49,52 @@ type PendingOperation =
 
 interface ProjectContext {
     environmentId: string;
-    serverProcess: ObservableExecutionResult<string> | null;
     serverInfo: DeepnoteServerInfo | null;
 }
 
 /**
  * Starts and manages the deepnote-toolkit Jupyter server.
+ *
+ * Uses @deepnote/runtime-core's `startServer`/`stopServer` for the core server
+ * lifecycle (process spawn, port discovery, health checks, shutdown), and layers
+ * extension-specific concerns on top: lock files, orphan cleanup, SQL integration
+ * env vars, output channel logging, and multi-server concurrency control.
  */
 @injectable()
 export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtensionSyncActivationService {
-    private readonly serverProcesses: Map<string, ObservableExecutionResult<string>> = new Map();
-    private readonly serverInfos: Map<string, DeepnoteServerInfo> = new Map();
     private readonly disposablesByFile: Map<string, IDisposable[]> = new Map();
-    private readonly projectContexts: Map<string, ProjectContext> = new Map();
-    // Track in-flight operations per file to prevent concurrent start/stop
     private readonly pendingOperations: Map<string, PendingOperation> = new Map();
-    // Global lock for port allocation to prevent race conditions when multiple environments start concurrently
-    private portAllocationLock: Promise<void> = Promise.resolve();
-    // Unique session ID for this VS Code window instance
+    private readonly projectContexts: Map<string, ProjectContext> = new Map();
+    private readonly serverOutputByFile: Map<string, { stdout: string; stderr: string }> = new Map();
     private readonly sessionId: string = generateUuid();
-    // Directory for lock files
     private readonly lockFileDir: string = path.join(os.tmpdir(), 'vscode-deepnote-locks');
-    // Track server output for error reporting
-    private readonly serverOutputByFile: Map<string, { stdout: string; stderr: string }> = new Map();
 
     constructor(
         @inject(IProcessServiceFactory) private readonly processServiceFactory: IProcessServiceFactory,
         @inject(IDeepnoteToolkitInstaller) private readonly toolkitInstaller: IDeepnoteToolkitInstaller,
         @inject(DeepnoteAgentSkillsManager) private readonly agentSkillsManager: DeepnoteAgentSkillsManager,
         @inject(IOutputChannel) @named(STANDARD_OUTPUT_CHANNEL) private readonly outputChannel: IOutputChannel,
-        @inject(IHttpClient) private readonly httpClient: IHttpClient,
         @inject(IAsyncDisposableRegistry) asyncRegistry: IAsyncDisposableRegistry,
         @inject(ISqlIntegrationEnvVarsProvider)
         @optional()
         private readonly sqlIntegrationEnvVars?: ISqlIntegrationEnvVarsProvider
     ) {
-        // Register for disposal when the extension deactivates
         asyncRegistry.push(this);
     }
 
     public activate(): void {
-        // Ensure lock file directory exists
         this.initializeLockFileDirectory().catch((ex) => {
             logger.warn('Failed to initialize lock file directory', ex);
         });
 
-        // Clean up any orphaned deepnote-toolkit processes from previous sessions
         this.cleanupOrphanedProcesses().catch((ex) => {
             logger.warn('Failed to cleanup orphaned processes', ex);
         });
     }
 
     /**
-     * Environment-based method: Start a server for a kernel environment.
-     * @param interpreter The Python interpreter to use
-     * @param venvPath The path to the venv
-     * @param managedVenv Whether the venv is managed by this extension (created by us)
-     * @param environmentId The environment ID (used as key for server management)
-     * @param token Cancellation token
-     * @returns Server connection information
+     * Start a server for a kernel environment.
+     * Serializes concurrent operations on the same environment to prevent race conditions.
      */
     public async startServer(
         interpreter: PythonEnvironment,
@@ -112,12 +106,10 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         token?: CancellationToken
     ): Promise<DeepnoteServerInfo> {
         const fileKey = deepnoteFileUri.fsPath;
-        const serverKey = `${fileKey}-${environmentId}`;
 
-        // Wait for any pending operations on this environment to complete
-        let pendingOp = this.pendingOperations.get(serverKey);
+        let pendingOp = this.pendingOperations.get(fileKey);
         if (pendingOp) {
-            logger.info(`Waiting for pending operation on ${serverKey} to complete...`);
+            logger.info(`Waiting for pending operation on ${fileKey} to complete...`);
             try {
                 await pendingOp.promise;
             } catch {
@@ -125,44 +117,40 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
             }
         }
 
-        let existingContext = this.projectContexts.get(serverKey);
+        let existingContext = this.projectContexts.get(fileKey);
         if (existingContext != null) {
             const { environmentId: existingEnvironmentId, serverInfo: existingServerInfo } = existingContext;
 
             if (existingEnvironmentId === environmentId) {
                 if (existingServerInfo != null && (await this.isServerRunning(existingServerInfo))) {
-                    logger.info(`Deepnote server already running at ${existingServerInfo.url} for ${serverKey}`);
+                    logger.info(
+                        `Deepnote server already running at ${existingServerInfo.url} for ${fileKey} (environmentId ${environmentId})`
+                    );
                     return existingServerInfo;
                 }
 
-                // Start the operation if not already pending
-                pendingOp = this.pendingOperations.get(serverKey);
+                pendingOp = this.pendingOperations.get(fileKey);
 
                 if (pendingOp && pendingOp.type === 'start') {
-                    // TODO - check pending operation environment id ?
                     return await pendingOp.promise;
                 }
             } else {
-                // Stop the existing server
                 logger.info(
-                    `Stopping existing server for ${serverKey} with environmentId ${existingEnvironmentId} to start new one with environmentId ${environmentId}...`
+                    `Stopping existing server for ${fileKey} with environmentId ${existingEnvironmentId} to start new one with environmentId ${environmentId}...`
                 );
                 await this.stopServerForEnvironment(existingContext, deepnoteFileUri, token);
-                // TODO - Clear controllers for the notebook ?
+                existingContext.environmentId = environmentId;
             }
         } else {
-            const newContext = {
+            const newContext: ProjectContext = {
                 environmentId,
-                serverProcess: null,
                 serverInfo: null
             };
 
-            this.projectContexts.set(serverKey, newContext);
-
+            this.projectContexts.set(fileKey, newContext);
             existingContext = newContext;
         }
 
-        // Start the operation and track it
         const operation = {
             type: 'start' as const,
             promise: this.startServerForEnvironment(
@@ -176,34 +164,34 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                 token
             )
         };
-        this.pendingOperations.set(serverKey, operation);
+        this.pendingOperations.set(fileKey, operation);
 
         try {
             const result = await operation.promise;
 
-            // Update context with running server info
             existingContext.serverInfo = result;
             return result;
         } finally {
-            // Remove from pending operations when done
-            if (this.pendingOperations.get(serverKey) === operation) {
-                this.pendingOperations.delete(serverKey);
+            if (this.pendingOperations.get(fileKey) === operation) {
+                this.pendingOperations.delete(fileKey);
             }
         }
     }
 
     /**
-     * Environment-based method: Stop the server for a kernel environment.
-     * @param environmentId The environment ID
+     * Stop the deepnote-toolkit server for a kernel environment.
      */
-    // public async stopServer(environmentId: string, token?: CancellationToken): Promise<void> {
     public async stopServer(deepnoteFileUri: Uri, token?: CancellationToken): Promise<void> {
         Cancellation.throwIfCanceled(token);
 
         const fileKey = deepnoteFileUri.fsPath;
         const projectContext = this.projectContexts.get(fileKey) ?? null;
 
-        // Wait for any pending operations on this environment to complete
+        if (projectContext == null) {
+            logger.warn(`No project context found for ${fileKey}, skipping stop server...`);
+            return;
+        }
+
         const pendingOp = this.pendingOperations.get(fileKey);
         if (pendingOp) {
             logger.info(`Waiting for pending operation on ${fileKey} before stopping...`);
@@ -216,7 +204,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         Cancellation.throwIfCanceled(token);
 
-        // Start the stop operation and track it
         const operation = {
             type: 'stop' as const,
             promise: this.stopServerForEnvironment(projectContext, deepnoteFileUri, token)
@@ -226,7 +213,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         try {
             await operation.promise;
         } finally {
-            // Remove from pending operations when done
             if (this.pendingOperations.get(fileKey) === operation) {
                 this.pendingOperations.delete(fileKey);
             }
@@ -234,7 +220,13 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
     }
 
     /**
-     * Environment-based server start implementation.
+     * Core server start using @deepnote/runtime-core's `startServer`.
+     *
+     * Extension-specific layers:
+     * - Toolkit/venv installation (before start)
+     * - SQL integration env var injection (via ServerOptions.env)
+     * - Lock file creation (after start, using returned PID)
+     * - Output channel logging (via process stdout/stderr streams)
      */
     private async startServerForEnvironment(
         projectContext: ProjectContext,
@@ -247,11 +239,9 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         token?: CancellationToken
     ): Promise<DeepnoteServerInfo> {
         const fileKey = deepnoteFileUri.fsPath;
-        const serverKey = `${fileKey}-${environmentId}`;
 
         Cancellation.throwIfCanceled(token);
 
-        // Ensure toolkit is installed in venv and get venv's Python interpreter
         logger.info(`Ensuring deepnote-toolkit is installed in venv for environment ${environmentId}...`);
         const { pythonInterpreter: venvInterpreter } = await this.toolkitInstaller.ensureVenvAndToolkit(
             interpreter,
@@ -268,173 +258,60 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         Cancellation.throwIfCanceled(token);
 
-        // Allocate both ports with global lock to prevent race conditions
-        // Note: allocatePorts reserves both ports immediately in serverInfos
-        // const { jupyterPort, lspPort } = await this.allocatePorts(environmentId);
-        const { jupyterPort, lspPort } = await this.allocatePorts(serverKey);
+        logger.info(`Starting deepnote-toolkit server for ${fileKey} (environmentId ${environmentId})`);
+        this.outputChannel.appendLine(l10n.t('Starting Deepnote server...'));
 
-        logger.info(
-            `Starting deepnote-toolkit server on jupyter port ${jupyterPort} and lsp port ${lspPort} for ${serverKey} with environmentId ${environmentId}`
-        );
-        this.outputChannel.appendLine(
-            l10n.t('Starting Deepnote server on jupyter port {0} and lsp port {1}...', jupyterPort, lspPort)
-        );
-
-        // Start the server with venv's Python in PATH
-        const processService = await this.processServiceFactory.create(undefined);
-
-        // Set up environment to ensure the venv's Python is used for shell commands
-        const venvBinDir = path.dirname(venvInterpreter.uri.fsPath);
-        const env = { ...process.env };
-
-        // Prepend venv bin directory to PATH so shell commands use venv's Python
-        env.PATH = `${venvBinDir}${process.platform === 'win32' ? ';' : ':'}${env.PATH || ''}`;
-
-        // Also set VIRTUAL_ENV to indicate we're in a venv
-        env.VIRTUAL_ENV = venvPath.fsPath;
+        const extraEnv = await this.gatherSqlIntegrationEnvVars(deepnoteFileUri, environmentId, token);
 
-        // Enforce published pip constraints to prevent breaking Deepnote Toolkit's dependencies
-        env.DEEPNOTE_ENFORCE_PIP_CONSTRAINTS = 'true';
-
-        // Detached mode
-        env.DEEPNOTE_RUNTIME__RUNNING_IN_DETACHED_MODE = 'true';
+        // Initialize output tracking for error reporting
+        this.serverOutputByFile.set(fileKey, { stdout: '', stderr: '' });
 
-        // Detached mode ensures no requests are made to the backend (directly, or via proxy)
-        // as there is no backend running in the extension, therefore:
-        // 1. integration environment variables are injected here instead
-        // 2. post start hooks won't work / are not executed
-        env.DEEPNOTE_RUNTIME__RUNNING_IN_DETACHED_MODE = 'true';
+        let serverInfo: DeepnoteServerInfo | undefined;
+        try {
+            serverInfo = await startServer({
+                pythonEnv: venvPath.fsPath,
+                workingDirectory: path.dirname(deepnoteFileUri.fsPath),
+                startupTimeoutMs: SERVER_STARTUP_TIMEOUT_MS,
+                env: extraEnv
+            });
+        } catch (error) {
+            const capturedOutput = this.serverOutputByFile.get(fileKey);
+            this.serverOutputByFile.delete(fileKey);
 
-        // Inject SQL integration environment variables
-        if (this.sqlIntegrationEnvVars) {
-            logger.debug(
-                `DeepnoteServerStarter: Injecting SQL integration env vars for ${fileKey} with environmentId ${environmentId}`
+            throw new DeepnoteServerStartupError(
+                interpreter.uri.fsPath,
+                serverInfo?.jupyterPort ?? 0,
+                'unknown',
+                capturedOutput?.stdout || '',
+                capturedOutput?.stderr || '',
+                error instanceof Error ? error : new Error(`${error}`)
             );
-            try {
-                const sqlEnvVars = await this.sqlIntegrationEnvVars.getEnvironmentVariables(deepnoteFileUri, token);
-                // const sqlEnvVars = {}; // TODO: update how environment variables are retrieved
-                if (sqlEnvVars && Object.keys(sqlEnvVars).length > 0) {
-                    logger.debug(`DeepnoteServerStarter: Injecting ${Object.keys(sqlEnvVars).length} SQL env vars`);
-                    Object.assign(env, sqlEnvVars);
-                } else {
-                    logger.debug('DeepnoteServerStarter: No SQL integration env vars to inject');
-                }
-            } catch (error) {
-                logger.error('DeepnoteServerStarter: Failed to get SQL integration env vars', error.message);
-            }
-        } else {
-            logger.debug('DeepnoteServerStarter: SqlIntegrationEnvironmentVariablesProvider not available');
         }
 
-        // Remove PYTHONHOME if it exists (can interfere with venv)
-        delete env.PYTHONHOME;
-
-        const serverProcess = processService.execObservable(
-            venvInterpreter.uri.fsPath,
-            [
-                '-m',
-                'deepnote_toolkit',
-                'server',
-                '--jupyter-port',
-                jupyterPort.toString(),
-                '--ls-port',
-                lspPort.toString()
-            ],
-            { env, cwd: path.dirname(deepnoteFileUri.fsPath) }
-        );
-
-        projectContext.serverProcess = serverProcess;
+        projectContext.serverInfo = serverInfo;
 
-        this.serverProcesses.set(serverKey, serverProcess);
+        // Set up output channel logging from the server process
+        this.monitorServerOutput(fileKey, serverInfo);
 
-        // Track disposables for this environment
-        const disposables: IDisposable[] = [];
-        this.disposablesByFile.set(serverKey, disposables);
-
-        // Initialize output tracking for error reporting
-        this.serverOutputByFile.set(serverKey, { stdout: '', stderr: '' });
-
-        // Monitor server output
-        serverProcess.out.onDidChange(
-            (output) => {
-                const outputTracking = this.serverOutputByFile.get(serverKey);
-                if (output.source === 'stdout') {
-                    logger.trace(`Deepnote server (${serverKey}): ${output.out}`);
-                    this.outputChannel.appendLine(output.out);
-                    if (outputTracking) {
-                        // Keep last 5000 characters of output for error reporting
-                        outputTracking.stdout = (outputTracking.stdout + output.out).slice(-5000);
-                    }
-                } else if (output.source === 'stderr') {
-                    logger.warn(`Deepnote server stderr (${serverKey}): ${output.out}`);
-                    this.outputChannel.appendLine(output.out);
-                    if (outputTracking) {
-                        // Keep last 5000 characters of error output for error reporting
-                        outputTracking.stderr = (outputTracking.stderr + output.out).slice(-5000);
-                    }
-                }
-            },
-            this,
-            disposables
-        );
-
-        // Wait for server to be ready
-        const url = `http://localhost:${jupyterPort}`;
-        const serverInfo = { url, jupyterPort, lspPort };
-        this.serverInfos.set(serverKey, serverInfo);
-
-        // Write lock file for the server process
-        const serverPid = serverProcess.proc?.pid;
+        // Write lock file for orphan-cleanup tracking
+        const serverPid = serverInfo.process.pid;
         if (serverPid) {
             await this.writeLockFile(serverPid);
         } else {
-            logger.warn(`Could not get PID for server process for ${serverKey}`);
-        }
-
-        try {
-            const serverReady = await this.waitForServer(serverInfo, 120000, token);
-            if (!serverReady) {
-                const output = this.serverOutputByFile.get(serverKey);
-
-                throw new DeepnoteServerTimeoutError(serverInfo.url, 120000, output?.stderr || undefined);
-            }
-        } catch (error) {
-            if (error instanceof DeepnoteServerTimeoutError || error instanceof DeepnoteServerStartupError) {
-                // await this.stopServerImpl(deepnoteFileUri);
-                await this.stopServerForEnvironment(projectContext, deepnoteFileUri);
-                throw error;
-            }
-
-            // Capture output BEFORE cleaning up (stopServerImpl deletes it)
-            const output = this.serverOutputByFile.get(serverKey);
-            const capturedStdout = output?.stdout || '';
-            const capturedStderr = output?.stderr || '';
-
-            // Clean up leaked server before rethrowing
-            await this.stopServerForEnvironment(projectContext, deepnoteFileUri);
-
-            throw new DeepnoteServerStartupError(
-                interpreter.uri.fsPath,
-                serverInfo.jupyterPort,
-                'unknown',
-                capturedStdout,
-                capturedStderr,
-                error instanceof Error ? error : undefined
-            );
+            logger.warn(`Could not get PID for server process for ${fileKey}`);
         }
 
-        logger.info(`Deepnote server started successfully at ${url} for ${serverKey}`);
-        this.outputChannel.appendLine(l10n.t('✓ Deepnote server running at {0}', url));
+        logger.info(`Deepnote server started successfully at ${serverInfo.url} for ${fileKey}`);
+        this.outputChannel.appendLine(l10n.t('✓ Deepnote server running at {0}', serverInfo.url));
 
         return serverInfo;
     }
 
     /**
-     * Environment-based server stop implementation.
+     * Stop the server using @deepnote/runtime-core's `stopServer` (SIGTERM -> wait -> SIGKILL).
      */
-    // private async stopServerForEnvironment(environmentId: string, token?: CancellationToken): Promise<void> {
     private async stopServerForEnvironment(
-        projectContext: ProjectContext | null,
+        projectContext: ProjectContext,
         deepnoteFileUri: Uri,
         token?: CancellationToken
     ): Promise<void> {
@@ -442,23 +319,20 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         Cancellation.throwIfCanceled(token);
 
-        // const serverProcess = this.serverProcesses.get(fileKey);
-        const serverProcess = projectContext?.serverProcess;
+        const { serverInfo } = projectContext;
 
-        if (serverProcess) {
-            const serverPid = serverProcess.proc?.pid;
+        if (serverInfo) {
+            const serverPid = serverInfo.process.pid;
 
             try {
                 logger.info(`Stopping Deepnote server for ${fileKey}...`);
-                serverProcess.proc?.kill();
-                this.serverProcesses.delete(fileKey);
-                this.serverInfos.delete(fileKey);
-                this.serverOutputByFile.delete(fileKey);
+                await stopServer(serverInfo);
                 this.outputChannel.appendLine(l10n.t('Deepnote server stopped for {0}', fileKey));
             } catch (ex) {
                 logger.error('Error stopping Deepnote server', ex);
             } finally {
-                // Clean up lock file after stopping the server
+                projectContext.serverInfo = null;
+
                 if (serverPid) {
                     await this.deleteLockFile(serverPid);
                 }
@@ -467,6 +341,8 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         Cancellation.throwIfCanceled(token);
 
+        this.serverOutputByFile.delete(fileKey);
+
         const disposables = this.disposablesByFile.get(fileKey);
         if (disposables) {
             disposables.forEach((d) => d.dispose());
@@ -474,281 +350,141 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         }
     }
 
-    private async waitForServer(
-        serverInfo: DeepnoteServerInfo,
-        timeout: number,
-        token?: CancellationToken
-    ): Promise<boolean> {
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeout) {
-            Cancellation.throwIfCanceled(token);
-            if (await this.isServerRunning(serverInfo)) {
-                return true;
-            }
-            await raceCancellationError(token, sleep(500));
-        }
-        return false;
-    }
-
+    /**
+     * Check if a server is still running by probing its /api endpoint.
+     */
     private async isServerRunning(serverInfo: DeepnoteServerInfo): Promise<boolean> {
         try {
-            // Try to connect to the Jupyter API endpoint
-            const exists = await this.httpClient.exists(`${serverInfo.url}/api`).catch(() => false);
-            return exists;
+            const response = await fetch(`${serverInfo.url}/api`, { signal: AbortSignal.timeout(5000) });
+            return response.ok;
         } catch {
             return false;
         }
     }
 
     /**
-     * Allocate both Jupyter and LSP ports atomically with global serialization.
-     * When multiple environments start simultaneously, this ensures each gets unique ports.
-     *
-     * @param key The environment ID to reserve ports for
-     * @returns Object with jupyterPort and lspPort
+     * Gather SQL integration environment variables for the deepnote-toolkit server.
      */
-    private async allocatePorts(key: string): Promise<{ jupyterPort: number; lspPort: number }> {
-        // Chain onto the existing lock promise to serialize allocations even when multiple calls start concurrently
-        const previousLock = this.portAllocationLock;
-        let releaseLock: () => void;
-        const currentLock = new Promise<void>((resolve) => {
-            releaseLock = resolve;
-        });
-        this.portAllocationLock = previousLock.then(() => currentLock);
-
-        // Wait until all prior allocations have completed before proceeding
-        await previousLock;
-
-        try {
-            // Get all ports currently in use by our managed servers
-            const portsInUse = new Set<number>();
-            for (const serverInfo of this.serverInfos.values()) {
-                if (serverInfo.jupyterPort) {
-                    portsInUse.add(serverInfo.jupyterPort);
-                }
-                if (serverInfo.lspPort) {
-                    portsInUse.add(serverInfo.lspPort);
-                }
-            }
-
-            // Find a pair of consecutive available ports
-            const { jupyterPort, lspPort } = await this.findConsecutiveAvailablePorts(
-                DEEPNOTE_DEFAULT_PORT,
-                portsInUse
-            );
-
-            // Reserve both ports by adding to serverInfos
-            // This prevents other concurrent allocations from getting the same ports
-            const serverInfo = {
-                url: `http://localhost:${jupyterPort}`,
-                jupyterPort,
-                lspPort
-            };
-            this.serverInfos.set(key, serverInfo);
-
-            logger.info(
-                `Allocated consecutive ports for ${key}: jupyter=${jupyterPort}, lsp=${lspPort} (excluded: ${
-                    portsInUse.size > 2
-                        ? Array.from(portsInUse)
-                              .filter((p) => p !== jupyterPort && p !== lspPort)
-                              .join(', ')
-                        : 'none'
-                })`
-            );
+    private async gatherSqlIntegrationEnvVars(
+        deepnoteFileUri: Uri,
+        environmentId: string,
+        token?: CancellationToken
+    ): Promise<Record<string, string>> {
+        const extraEnv: Record<string, string> = {};
 
-            return { jupyterPort, lspPort };
-        } finally {
-            // Release the lock to allow next allocation in the chain to proceed
-            releaseLock!();
+        if (!this.sqlIntegrationEnvVars) {
+            logger.debug('DeepnoteServerStarter: SqlIntegrationEnvironmentVariablesProvider not available');
+            return extraEnv;
         }
-    }
-
-    /**
-     * Find a pair of consecutive available ports (port and port+1).
-     * This is critical for the deepnote-toolkit server which expects consecutive ports.
-     *
-     * @param startPort The port number to start searching from
-     * @param portsInUse Set of ports already allocated to other servers
-     * @returns A pair of consecutive ports { jupyterPort, lspPort } where lspPort = jupyterPort + 1
-     * @throws DeepnoteServerStartupError if no consecutive ports can be found after maxAttempts
-     */
-    private async findConsecutiveAvailablePorts(
-        startPort: number,
-        portsInUse: Set<number>
-    ): Promise<{ jupyterPort: number; lspPort: number }> {
-        const maxAttempts = 100;
-
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            // Try to find an available Jupyter port
-            const candidatePort = await this.findAvailablePort(
-                attempt === 0 ? startPort : startPort + attempt,
-                portsInUse
-            );
-
-            const nextPort = candidatePort + 1;
-
-            // Check if the consecutive port (candidatePort + 1) is also available
-            const isNextPortInUse = portsInUse.has(nextPort);
-            const isNextPortAvailable = !isNextPortInUse && (await this.isPortAvailable(nextPort));
-            logger.info(
-                `Consecutive port check for base ${candidatePort}: next=${nextPort}, inUseSet=${isNextPortInUse}, available=${isNextPortAvailable}`
-            );
-
-            if (isNextPortAvailable) {
-                // Found a consecutive pair!
-                return { jupyterPort: candidatePort, lspPort: nextPort };
-            }
 
-            // Consecutive port not available - mark both as unavailable and try next
-            portsInUse.add(candidatePort);
-            portsInUse.add(nextPort);
-        }
+        const fileKey = deepnoteFileUri.fsPath;
 
-        // Failed to find consecutive ports after max attempts
-        throw new DeepnoteServerStartupError(
-            'python',
-            startPort,
-            'process_failed',
-            '',
-            l10n.t(
-                'Failed to find consecutive available ports after {0} attempts starting from port {1}. Please close some applications using network ports and try again.',
-                maxAttempts,
-                startPort
-            )
+        logger.debug(
+            `DeepnoteServerStarter: Injecting SQL integration env vars for ${fileKey} with environmentId ${environmentId}`
         );
-    }
-
-    /**
-     * Check if a specific port is available on the system by actually trying to bind to it.
-     * This is more reliable than get-port which doesn't test the exact port.
-     */
-    private async isPortAvailable(port: number): Promise<boolean> {
         try {
-            const inUse = await tcpPortUsed.check(port, '127.0.0.1');
-            if (inUse) {
-                return false;
-            }
-
-            // Also check IPv6 loopback to be safe
-            try {
-                const inUseIpv6 = await tcpPortUsed.check(port, '::1');
-                return !inUseIpv6;
-            } catch (error: unknown) {
-                if (error instanceof Error && 'code' in error && error.code === 'EAFNOSUPPORT') {
-                    logger.debug('IPv6 is not supported on this system');
-                    return true;
-                }
-                logger.warn(`Failed to check IPv6 port availability for ${port}:`, error);
-                return false;
+            const sqlEnvVars = await this.sqlIntegrationEnvVars.getEnvironmentVariables(deepnoteFileUri, token);
+            if (sqlEnvVars && Object.keys(sqlEnvVars).length > 0) {
+                logger.debug(`DeepnoteServerStarter: Injecting ${Object.keys(sqlEnvVars).length} SQL env vars`);
+                Object.assign(extraEnv, sqlEnvVars);
+            } else {
+                logger.debug('DeepnoteServerStarter: No SQL integration env vars to inject');
             }
         } catch (error) {
-            logger.warn(`Failed to check port availability for ${port}:`, error);
-            return false;
+            logger.error('DeepnoteServerStarter: Failed to get SQL integration env vars', error);
         }
+
+        return extraEnv;
     }
 
     /**
-     * Find an available port starting from the given port number.
-     * Checks both our internal portsInUse set and system availability by actually binding to test.
+     * Stream stdout/stderr from the server process to the VSCode output channel.
      */
-    private async findAvailablePort(startPort: number, portsInUse: Set<number>): Promise<number> {
-        let port = startPort;
-        let attempts = 0;
-        const maxAttempts = 100;
-
-        while (attempts < maxAttempts) {
-            // Skip ports already in use by our servers
-            if (!portsInUse.has(port)) {
-                // Check if this port is actually available on the system by binding to it
-                const available = await this.isPortAvailable(port);
-
-                if (available) {
-                    return port;
+    private monitorServerOutput(fileKey: string, serverInfo: DeepnoteServerInfo): void {
+        const proc = serverInfo.process;
+        const disposables: IDisposable[] = [];
+        this.disposablesByFile.set(fileKey, disposables);
+
+        if (proc.stdout) {
+            const stdout = proc.stdout;
+            const onData = (data: Buffer) => {
+                const text = data.toString();
+                logger.trace(`Deepnote server (${fileKey}): ${text}`);
+                this.outputChannel.appendLine(text);
+
+                const outputTracking = this.serverOutputByFile.get(fileKey);
+                if (outputTracking) {
+                    outputTracking.stdout = (outputTracking.stdout + text).slice(-MAX_OUTPUT_TRACKING_LENGTH);
                 }
-            }
-
-            // Try next port
-            port++;
-            attempts++;
+            };
+            stdout.on('data', onData);
+            disposables.push({
+                dispose: () => {
+                    stdout.off('data', onData);
+                }
+            });
         }
 
-        throw new DeepnoteServerStartupError(
-            'python', // unknown here
-            startPort,
-            'process_failed',
-            '',
-            l10n.t(
-                'Failed to find available port after {0} attempts (started at {1}). Ports in use: {2}',
-                maxAttempts,
-                startPort,
-                Array.from(portsInUse).join(', ')
-            )
-        );
+        if (proc.stderr) {
+            const stderr = proc.stderr;
+            const onData = (data: Buffer) => {
+                const text = data.toString();
+                logger.warn(`Deepnote server stderr (${fileKey}): ${text}`);
+                this.outputChannel.appendLine(text);
+
+                const outputTracking = this.serverOutputByFile.get(fileKey);
+                if (outputTracking) {
+                    outputTracking.stderr = (outputTracking.stderr + text).slice(-MAX_OUTPUT_TRACKING_LENGTH);
+                }
+            };
+            stderr.on('data', onData);
+            disposables.push({
+                dispose: () => {
+                    stderr.off('data', onData);
+                }
+            });
+        }
     }
 
     public async dispose(): Promise<void> {
         logger.info('Disposing DeepnoteServerStarter - stopping all servers...');
 
-        // Wait for any pending operations to complete (with timeout)
         const pendingOps = Array.from(this.pendingOperations.values());
         if (pendingOps.length > 0) {
             logger.info(`Waiting for ${pendingOps.length} pending operations to complete...`);
-            await Promise.allSettled(pendingOps.map((op) => Promise.race([op, sleep(2000)])));
+            await Promise.allSettled(
+                pendingOps.map((op) => Promise.race([op.promise, sleep(GRACEFUL_SHUTDOWN_TIMEOUT_MS)]))
+            );
         }
 
-        // Stop all server processes and wait for them to exit
-        const killPromises: Promise<void>[] = [];
+        const stopPromises: Promise<void>[] = [];
         const pidsToCleanup: number[] = [];
 
-        for (const [fileKey, serverProcess] of this.serverProcesses.entries()) {
-            try {
-                logger.info(`Stopping Deepnote server for ${fileKey}...`);
-                const proc = serverProcess.proc;
-                if (proc && !proc.killed) {
-                    const serverPid = proc.pid;
-                    if (serverPid) {
-                        pidsToCleanup.push(serverPid);
-                    }
-
-                    // Create a promise that resolves when the process exits
-                    const exitPromise = new Promise<void>((resolve) => {
-                        const timeout = setTimeout(() => {
-                            logger.warn(`Process for ${fileKey} did not exit gracefully, force killing...`);
-                            try {
-                                proc.kill('SIGKILL');
-                            } catch {
-                                // Ignore errors on force kill
-                            }
-                            resolve();
-                        }, 3000); // Wait up to 3 seconds for graceful exit
-
-                        proc.once('exit', () => {
-                            clearTimeout(timeout);
-                            resolve();
-                        });
-                    });
-
-                    // Send SIGTERM for graceful shutdown
-                    proc.kill('SIGTERM');
-                    killPromises.push(exitPromise);
+        for (const [key, ctx] of this.projectContexts.entries()) {
+            if (ctx.serverInfo) {
+                const pid = ctx.serverInfo.process.pid;
+                if (pid) {
+                    pidsToCleanup.push(pid);
                 }
-            } catch (ex) {
-                logger.error(`Error stopping Deepnote server for ${fileKey}`, ex);
+
+                logger.info(`Stopping Deepnote server for ${key}...`);
+                stopPromises.push(
+                    stopServer(ctx.serverInfo).catch((ex) => {
+                        logger.error(`Error stopping Deepnote server for ${key}`, ex);
+                    })
+                );
             }
         }
 
-        // Wait for all processes to exit
-        if (killPromises.length > 0) {
-            logger.info(`Waiting for ${killPromises.length} server processes to exit...`);
-            await Promise.allSettled(killPromises);
+        if (stopPromises.length > 0) {
+            logger.info(`Waiting for ${stopPromises.length} server processes to exit...`);
+            await Promise.allSettled(stopPromises);
         }
 
-        // Clean up lock files for all stopped processes
         for (const pid of pidsToCleanup) {
             await this.deleteLockFile(pid);
         }
 
-        // Dispose all tracked disposables
         for (const [fileKey, disposables] of this.disposablesByFile.entries()) {
             try {
                 disposables.forEach((d) => d.dispose());
@@ -757,19 +493,16 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
             }
         }
 
-        // Clear all maps
-        this.serverProcesses.clear();
-        this.serverInfos.clear();
         this.disposablesByFile.clear();
         this.pendingOperations.clear();
+        this.projectContexts.clear();
         this.serverOutputByFile.clear();
 
         logger.info('DeepnoteServerStarter disposed successfully');
     }
 
-    /**
-     * Initialize the lock file directory
-     */
+    // ── Lock file management (extension-specific) ──
+
     private async initializeLockFileDirectory(): Promise<void> {
         try {
             await fs.ensureDir(this.lockFileDir);
@@ -779,16 +512,10 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         }
     }
 
-    /**
-     * Get the lock file path for a given PID
-     */
     private getLockFilePath(pid: number): string {
         return path.join(this.lockFileDir, `server-${pid}.json`);
     }
 
-    /**
-     * Write a lock file for a server process
-     */
     private async writeLockFile(pid: number): Promise<void> {
         try {
             const lockData: ServerLockFile = {
@@ -804,9 +531,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         }
     }
 
-    /**
-     * Read a lock file for a given PID
-     */
     private async readLockFile(pid: number): Promise<ServerLockFile | null> {
         try {
             const lockFilePath = this.getLockFilePath(pid);
@@ -819,9 +543,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         return null;
     }
 
-    /**
-     * Delete a lock file for a given PID
-     */
     private async deleteLockFile(pid: number): Promise<void> {
         try {
             const lockFilePath = this.getLockFilePath(pid);
@@ -834,15 +555,13 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         }
     }
 
-    /**
-     * Check if a process is orphaned by verifying its parent process
-     */
+    // ── Orphaned process cleanup (extension-specific) ──
+
     private async isProcessOrphaned(pid: number): Promise<boolean> {
         try {
             const processService = await this.processServiceFactory.create(undefined);
 
             if (process.platform === 'win32') {
-                // Windows: use WMIC to get parent process ID
                 const result = await processService.exec(
                     'wmic',
                     ['process', 'where', `ProcessId=${pid}`, 'get', 'ParentProcessId'],
@@ -856,36 +575,27 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                     if (lines.length > 0) {
                         const ppid = parseInt(lines[0].trim(), 10);
                         if (!isNaN(ppid)) {
-                            // PPID of 0 means orphaned
                             if (ppid === 0) {
                                 return true;
                             }
 
-                            // Check if parent process exists
                             const parentCheck = await processService.exec(
                                 'tasklist',
                                 ['/FI', `PID eq ${ppid}`, '/FO', 'CSV', '/NH'],
                                 { throwOnStdErr: false }
                             );
 
-                            // Normalize and check stdout
                             const stdout = (parentCheck.stdout || '').trim();
 
-                            // Parent is missing if:
-                            // 1. stdout is empty
-                            // 2. stdout starts with "INFO:" (case-insensitive)
-                            // 3. stdout contains "no tasks are running" (case-insensitive)
                             if (stdout.length === 0 || /^INFO:/i.test(stdout) || /no tasks are running/i.test(stdout)) {
-                                return true; // Parent missing, process is orphaned
+                                return true;
                             }
 
-                            // Parent exists
                             return false;
                         }
                     }
                 }
             } else {
-                // Unix: use ps to get parent process ID
                 const result = await processService.exec('ps', ['-o', 'ppid=', '-p', pid.toString()], {
                     throwOnStdErr: false
                 });
@@ -893,11 +603,10 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                 if (result.stdout) {
                     const ppid = parseInt(result.stdout.trim(), 10);
                     if (!isNaN(ppid)) {
-                        // PPID of 1 typically means orphaned (adopted by init/systemd)
                         if (ppid === 1) {
                             return true;
                         }
-                        // Check if parent process exists
+
                         const parentCheck = await processService.exec('ps', ['-p', ppid.toString(), '-o', 'pid='], {
                             throwOnStdErr: false
                         });
@@ -909,29 +618,21 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
             logger.warn(`Failed to check if process ${pid} is orphaned`, ex);
         }
 
-        // If we can't determine, assume it's not orphaned (safer)
         return false;
     }
 
-    /**
-     * Cleans up any orphaned deepnote-toolkit processes from previous VS Code sessions.
-     * This prevents port conflicts when starting new servers.
-     */
     private async cleanupOrphanedProcesses(): Promise<void> {
         try {
             logger.info('Checking for orphaned deepnote-toolkit processes...');
             const processService = await this.processServiceFactory.create(undefined);
 
-            // Find all deepnote-toolkit server processes
             let command: string;
             let args: string[];
 
             if (process.platform === 'win32') {
-                // Windows: use tasklist and findstr
                 command = 'tasklist';
                 args = ['/FI', 'IMAGENAME eq python.exe', '/FO', 'CSV', '/NH'];
             } else {
-                // Unix-like: use ps and grep
                 command = 'ps';
                 args = ['aux'];
             }
@@ -943,19 +644,15 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                 const candidatePids: number[] = [];
 
                 for (const line of lines) {
-                    // Look for processes running deepnote_toolkit server
                     if (line.includes('deepnote_toolkit') && line.includes('server')) {
-                        // Extract PID based on platform
                         let pid: number | undefined;
 
                         if (process.platform === 'win32') {
-                            // Windows CSV format: "python.exe","12345",...
                             const match = line.match(/"python\.exe","(\d+)"/);
                             if (match) {
                                 pid = parseInt(match[1], 10);
                             }
                         } else {
-                            // Unix format: user PID ...
                             const parts = line.trim().split(/\s+/);
                             if (parts.length > 1) {
                                 pid = parseInt(parts[1], 10);
@@ -976,15 +673,11 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                     const pidsToKill: number[] = [];
                     const pidsToSkip: Array<{ pid: number; reason: string }> = [];
 
-                    // Check each process to determine if it should be killed
                     for (const pid of candidatePids) {
-                        // Check if there's a lock file for this PID
                         const lockData = await this.readLockFile(pid);
 
                         if (lockData) {
-                            // Lock file exists - check if it belongs to a different session
                             if (lockData.sessionId !== this.sessionId) {
-                                // Different session - check if the process is actually orphaned
                                 const isOrphaned = await this.isProcessOrphaned(pid);
                                 if (isOrphaned) {
                                     logger.info(
@@ -998,23 +691,19 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                                     });
                                 }
                             } else {
-                                // Same session - this shouldn't happen during startup, but skip it
                                 pidsToSkip.push({ pid, reason: 'belongs to current session' });
                             }
                         } else {
-                            // No lock file - assume it's an external/non-managed process and skip it
                             pidsToSkip.push({ pid, reason: 'no lock file (assuming external process)' });
                         }
                     }
 
-                    // Log skipped processes
                     if (pidsToSkip.length > 0) {
                         for (const { pid, reason } of pidsToSkip) {
                             logger.info(`Skipping PID ${pid}: ${reason}`);
                         }
                     }
 
-                    // Kill orphaned processes
                     if (pidsToKill.length > 0) {
                         logger.info(`Killing ${pidsToKill.length} orphaned process(es): ${pidsToKill.join(', ')}`);
                         this.outputChannel.appendLine(
@@ -1032,7 +721,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                                 }
                                 logger.info(`Killed orphaned process ${pid}`);
 
-                                // Clean up the lock file after killing
                                 await this.deleteLockFile(pid);
                             } catch (ex) {
                                 logger.warn(`Failed to kill process ${pid}`, ex);
@@ -1048,7 +736,6 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
                 }
             }
         } catch (ex) {
-            // Don't fail startup if cleanup fails
             logger.warn('Error during orphaned process cleanup', ex);
         }
     }
diff --git a/src/kernels/deepnote/deepnoteServerStarter.unit.test.ts b/src/kernels/deepnote/deepnoteServerStarter.unit.test.ts
index b6f46df475..f90e3a8ec1 100644
--- a/src/kernels/deepnote/deepnoteServerStarter.unit.test.ts
+++ b/src/kernels/deepnote/deepnoteServerStarter.unit.test.ts
@@ -1,46 +1,40 @@
 import { assert } from 'chai';
-import * as sinon from 'sinon';
-import tcpPortUsed from 'tcp-port-used';
+import * as fakeTimers from '@sinonjs/fake-timers';
 import { anything, instance, mock, when } from 'ts-mockito';
+
 import { DeepnoteAgentSkillsManager } from './deepnoteAgentSkillsManager.node';
 import { DeepnoteServerStarter } from './deepnoteServerStarter.node';
 import { IProcessServiceFactory } from '../../platform/common/process/types.node';
-import { IAsyncDisposableRegistry, IHttpClient, IOutputChannel } from '../../platform/common/types';
+import { IAsyncDisposableRegistry, IOutputChannel } from '../../platform/common/types';
 import { IDeepnoteToolkitInstaller } from './types';
 import { ISqlIntegrationEnvVarsProvider } from '../../platform/notebooks/deepnote/types';
-import { logger } from '../../platform/logging';
-import * as net from 'net';
 
 /**
- * Integration tests for DeepnoteServerStarter port allocation logic.
- * These tests use real port checking to ensure consecutive ports are allocated.
+ * Unit tests for DeepnoteServerStarter.
  *
- * Note: These are integration tests that actually check port availability on the system.
- * They test the critical fix where consecutive ports must be available.
+ * Port allocation, server spawning, and health checks are delegated to
+ * @deepnote/runtime-core's startServer/stopServer. These tests focus on the
+ * extension-specific layers: SQL env var gathering and lifecycle orchestration.
  */
-suite('DeepnoteServerStarter - Port Allocation Integration Tests', () => {
+suite('DeepnoteServerStarter', () => {
     let serverStarter: DeepnoteServerStarter;
     let mockProcessServiceFactory: IProcessServiceFactory;
     let mockToolkitInstaller: IDeepnoteToolkitInstaller;
     let mockAgentSkillsManager: DeepnoteAgentSkillsManager;
     let mockOutputChannel: IOutputChannel;
-    let mockHttpClient: IHttpClient;
     let mockAsyncRegistry: IAsyncDisposableRegistry;
     let mockSqlIntegrationEnvVars: ISqlIntegrationEnvVarsProvider;
 
-    // Helper to access private methods for testing
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const getPrivateMethod = (obj: any, methodName: string) => {
         return obj[methodName].bind(obj);
     };
 
     setup(() => {
-        // Create mocks
         mockProcessServiceFactory = mock<IProcessServiceFactory>();
         mockToolkitInstaller = mock<IDeepnoteToolkitInstaller>();
         mockAgentSkillsManager = mock<DeepnoteAgentSkillsManager>();
         mockOutputChannel = mock<IOutputChannel>();
-        mockHttpClient = mock<IHttpClient>();
         mockAsyncRegistry = mock<IAsyncDisposableRegistry>();
         mockSqlIntegrationEnvVars = mock<ISqlIntegrationEnvVarsProvider>();
 
@@ -52,527 +46,115 @@ suite('DeepnoteServerStarter - Port Allocation Integration Tests', () => {
             instance(mockToolkitInstaller),
             instance(mockAgentSkillsManager),
             instance(mockOutputChannel),
-            instance(mockHttpClient),
             instance(mockAsyncRegistry),
             instance(mockSqlIntegrationEnvVars)
         );
     });
 
     teardown(async () => {
-        // Dispose the serverStarter to clean up any allocated ports and state
         if (serverStarter) {
             await serverStarter.dispose();
         }
     });
 
-    suite('isPortAvailable', () => {
-        let checkStub: sinon.SinonStub;
-
-        setup(() => {
-            checkStub = sinon.stub(tcpPortUsed, 'check');
-        });
-
-        teardown(() => {
-            checkStub.restore();
-        });
-
-        test('should return true when both IPv4 and IPv6 loopbacks are free', async () => {
-            const port = 54321;
-            checkStub.onFirstCall().resolves(false); // IPv4
-            checkStub.onSecondCall().resolves(false); // IPv6
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const isPortAvailable = getPrivateMethod(serverStarter as any, 'isPortAvailable');
-            const result = await isPortAvailable(port);
-
-            assert.isTrue(result, 'Expected port to be reported as available');
-            assert.strictEqual(checkStub.callCount, 2, 'Should check both IPv4 and IPv6 loopbacks');
-            assert.deepEqual(checkStub.getCall(0).args, [port, '127.0.0.1']);
-            assert.deepEqual(checkStub.getCall(1).args, [port, '::1']);
-        });
-
-        test('should return false when IPv4 loopback is already in use', async () => {
-            const port = 54322;
-            checkStub.onFirstCall().resolves(true);
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const isPortAvailable = getPrivateMethod(serverStarter as any, 'isPortAvailable');
-            const result = await isPortAvailable(port);
-
-            assert.isFalse(result, 'Expected port to be reported as in use');
-            assert.strictEqual(checkStub.callCount, 1, 'IPv6 check should be skipped when IPv4 is busy');
-        });
-
-        test('should return false and log when port checks throw', async () => {
-            const port = 54323;
-            const error = new Error('check failed');
-            checkStub.rejects(error);
-
-            const warnStub = sinon.stub(logger, 'warn');
-
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const isPortAvailable = getPrivateMethod(serverStarter as any, 'isPortAvailable');
-                const result = await isPortAvailable(port);
-
-                assert.isFalse(result, 'Expected port check to fail closed when an error occurs');
-                assert.isTrue(warnStub.called, 'Expected warning to be logged when check fails');
-            } finally {
-                warnStub.restore();
-            }
-        });
-
-        test('should return true when IPv6 is disabled (EAFNOSUPPORT error)', async () => {
-            const port = 54324;
-            const ipv6Error = new Error('connect EAFNOSUPPORT ::1:54324');
-            (ipv6Error as any).code = 'EAFNOSUPPORT';
-
-            // IPv4 check succeeds (port is available)
-            checkStub.onFirstCall().resolves(false);
-
-            // IPv6 check throws EAFNOSUPPORT (IPv6 not supported)
-            checkStub.onSecondCall().rejects(ipv6Error);
+    suite('gatherSqlIntegrationEnvVars', () => {
+        test('should return empty object when no provider is available', async () => {
+            // Create a starter without SQL provider
+            const starterWithoutSql = new DeepnoteServerStarter(
+                instance(mockProcessServiceFactory),
+                instance(mockToolkitInstaller),
+                instance(mockAgentSkillsManager),
+                instance(mockOutputChannel),
+                instance(mockAsyncRegistry)
+            );
 
-            const debugStub = sinon.stub(logger, 'debug');
+            const gatherEnvVars = getPrivateMethod(starterWithoutSql, 'gatherSqlIntegrationEnvVars');
+            const { Uri } = await import('vscode');
+            const result = await gatherEnvVars(Uri.file('/test/file.deepnote'), 'env1');
 
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const isPortAvailable = getPrivateMethod(serverStarter as any, 'isPortAvailable');
-                const result = await isPortAvailable(port);
+            assert.deepStrictEqual(result, {});
 
-                assert.isTrue(result, 'Expected port to be available when IPv4 is free and IPv6 is not supported');
-                assert.strictEqual(checkStub.callCount, 2, 'Should check both IPv4 and IPv6');
-                assert.deepEqual(checkStub.getCall(0).args, [port, '127.0.0.1']);
-                assert.deepEqual(checkStub.getCall(1).args, [port, '::1']);
-                assert.isTrue(
-                    debugStub.calledWith('IPv6 is not supported on this system'),
-                    'Should log debug message about IPv6 not being supported'
-                );
-            } finally {
-                debugStub.restore();
-            }
+            await starterWithoutSql.dispose();
         });
 
-        test('should return false when IPv6 check throws non-EAFNOSUPPORT error', async () => {
-            const port = 54325;
-            const ipv6Error = new Error('Some other IPv6 error');
+        test('should return empty object when provider rejects with cancellation error', async () => {
+            const { CancellationError, Uri } = await import('vscode');
 
-            // IPv4 check succeeds (port is available)
-            checkStub.onFirstCall().resolves(false);
+            const cancelledProvider = mock<ISqlIntegrationEnvVarsProvider>();
+            when(cancelledProvider.getEnvironmentVariables(anything(), anything())).thenReject(new CancellationError());
 
-            // IPv6 check throws a different error
-            checkStub.onSecondCall().rejects(ipv6Error);
+            const starterWithCancelledSql = new DeepnoteServerStarter(
+                instance(mockProcessServiceFactory),
+                instance(mockToolkitInstaller),
+                instance(mockAgentSkillsManager),
+                instance(mockOutputChannel),
+                instance(mockAsyncRegistry),
+                instance(cancelledProvider)
+            );
 
-            const warnStub = sinon.stub(logger, 'warn');
+            const gatherEnvVars = getPrivateMethod(starterWithCancelledSql, 'gatherSqlIntegrationEnvVars');
+            const result = await gatherEnvVars(Uri.file('/test/file.deepnote'), 'env1');
 
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const isPortAvailable = getPrivateMethod(serverStarter as any, 'isPortAvailable');
-                const result = await isPortAvailable(port);
+            assert.deepStrictEqual(result, {});
 
-                assert.isFalse(
-                    result,
-                    'Expected port check to fail closed when IPv6 check fails with non-EAFNOSUPPORT error'
-                );
-                assert.strictEqual(checkStub.callCount, 2, 'Should check both IPv4 and IPv6');
-                assert.isTrue(warnStub.called, 'Should log warning when IPv6 check fails');
-                const warnCall = warnStub.getCall(0);
-                assert.include(warnCall.args[0], 'Failed to check IPv6 port availability');
-            } finally {
-                warnStub.restore();
-            }
+            await starterWithCancelledSql.dispose();
         });
     });
 
-    suite('findAvailablePort', () => {
-        test('should find an available port starting from given port', async () => {
-            const portsInUse = new Set<number>();
-            const startPort = 54400;
+    suite('dispose', () => {
+        let clock: fakeTimers.InstalledClock;
 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const findAvailablePort = getPrivateMethod(serverStarter as any, 'findAvailablePort');
-            const result = await findAvailablePort(startPort, portsInUse);
-
-            // Should find a port at or after the start port
-            assert.isAtLeast(result, startPort);
-        });
-
-        test('should skip ports in portsInUse set', async () => {
-            const portsInUse = new Set<number>([54500, 54501, 54502]);
-            const startPort = 54500;
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const findAvailablePort = getPrivateMethod(serverStarter as any, 'findAvailablePort');
-            const result = await findAvailablePort(startPort, portsInUse);
-
-            // Should skip the ports in use
-            assert.isFalse(portsInUse.has(result), 'Should not return a port from portsInUse');
-            assert.isAtLeast(result, 54503);
+        setup(() => {
+            clock = fakeTimers.install();
         });
 
-        test('should find available port within reasonable attempts', async () => {
-            const portsInUse = new Set<number>();
-            const startPort = 54600;
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const findAvailablePort = getPrivateMethod(serverStarter as any, 'findAvailablePort');
-            const result = await findAvailablePort(startPort, portsInUse);
-
-            // Should find a port without error
-            assert.isNumber(result);
-            assert.isAtLeast(result, startPort);
+        teardown(() => {
+            clock.uninstall();
         });
-    });
 
-    suite('allocatePorts - Consecutive Port Allocation (Critical Bug Fix)', () => {
-        test('should allocate consecutive ports (LSP = Jupyter + 1)', async () => {
-            const key = 'test-consecutive-1';
+        test('should clear all internal state', async () => {
+            await serverStarter.dispose();
 
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-            const result = await allocatePorts(key);
-
-            // THIS IS THE CRITICAL ASSERTION: LSP port must be exactly Jupyter + 1
-            assert.strictEqual(
-                result.lspPort,
-                result.jupyterPort + 1,
-                'LSP port must be consecutive (Jupyter port + 1)'
-            );
+            const starter = serverStarter as any;
+            assert.strictEqual(starter.disposablesByFile.size, 0);
+            assert.strictEqual(starter.pendingOperations.size, 0);
+            assert.strictEqual(starter.projectContexts.size, 0);
+            assert.strictEqual(starter.serverOutputByFile.size, 0);
         });
 
-        test('should allocate different consecutive port pairs for multiple servers', async () => {
-            const key1 = 'test-server-1';
-            const key2 = 'test-server-2';
-
+        test('should wait for in-flight pending operations before completing', async () => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
+            const starter = serverStarter as any;
 
-            const result1 = await allocatePorts(key1);
-            const result2 = await allocatePorts(key2);
-
-            // Both should have consecutive ports
-            assert.strictEqual(result1.lspPort, result1.jupyterPort + 1);
-            assert.strictEqual(result2.lspPort, result2.jupyterPort + 1);
-
-            // Ports should not overlap
-            assert.notEqual(result1.jupyterPort, result2.jupyterPort);
-            assert.notEqual(result1.lspPort, result2.lspPort);
-            assert.notEqual(result1.jupyterPort, result2.lspPort);
-            assert.notEqual(result1.lspPort, result2.jupyterPort);
-        });
-
-        test('CRITICAL REGRESSION TEST: should skip non-consecutive ports when LSP port is taken', async () => {
-            // This test simulates the EXACT bug scenario that was reported:
-            // - Port 8888 is available
-            // - Port 8889 (8888+1) is TAKEN by another process
-            // - System should NOT allocate 8888+8890 (non-consecutive)
-            // - System SHOULD find a different consecutive pair like 8890+8891
-
-            const blockingServer = net.createServer();
-            const blockedPort = 54701; // We'll block this port to simulate 8889 being taken
-
-            // Bind to port 54701 to block it
-            await new Promise<void>((resolve) => {
-                blockingServer.listen(blockedPort, 'localhost', () => {
-                    resolve();
-                });
+            let resolveDeferred!: () => void;
+            const deferred = new Promise<void>((resolve) => {
+                resolveDeferred = resolve;
             });
 
-            try {
-                const key = 'test-blocked-lsp-port';
-
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-
-                // Try to allocate ports - it should skip 54700 because 54701 is taken
-                const result = await allocatePorts(key);
-
-                // CRITICAL: Ports must be consecutive
-                assert.strictEqual(
-                    result.lspPort,
-                    result.jupyterPort + 1,
-                    'Even when some ports are blocked, allocated ports MUST be consecutive'
-                );
-
-                // Should not have allocated the blocked port or its predecessor
-                assert.notEqual(result.jupyterPort, blockedPort);
-                assert.notEqual(result.lspPort, blockedPort);
-                assert.isFalse(
-                    result.jupyterPort === blockedPort - 1 && result.lspPort === blockedPort,
-                    'Should not allocate pair where second port is blocked'
-                );
-            } finally {
-                // Clean up: close the blocking server
-                await new Promise<void>((resolve) => {
-                    blockingServer.close(() => resolve());
-                });
-            }
-        });
-
-        test('should handle rapid sequential allocations', async () => {
-            const keys = ['seq-1', 'seq-2', 'seq-3', 'seq-4', 'seq-5'];
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-
-            const results = [];
-            for (const key of keys) {
-                const result = await allocatePorts(key);
-                results.push(result);
-            }
-
-            // All should have unique, consecutive port pairs
-            const allPorts = results.flatMap((r) => [r.jupyterPort, r.lspPort]);
-            const uniquePorts = new Set(allPorts);
-            assert.strictEqual(uniquePorts.size, results.length * 2, 'All ports should be unique');
-
-            // Each result should have consecutive ports
-            for (const result of results) {
-                assert.strictEqual(result.lspPort, result.jupyterPort + 1);
-            }
-        });
-
-        test('should update serverInfos map with allocated ports', async () => {
-            const key = 'test-server-info';
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-            const result = await allocatePorts(key);
-
-            // Check that serverInfos was updated
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const serverInfos = (serverStarter as any).serverInfos as Map<string, any>;
-            assert.isTrue(serverInfos.has(key));
-
-            const info = serverInfos.get(key);
-            assert.strictEqual(info.jupyterPort, result.jupyterPort);
-            assert.strictEqual(info.lspPort, result.lspPort);
-            assert.strictEqual(info.url, `http://localhost:${result.jupyterPort}`);
-        });
-
-        test('should respect already allocated ports', async () => {
-            // First allocation
-            const key1 = 'first-server';
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-            const result1 = await allocatePorts(key1);
-
-            // Second allocation should get different ports
-            const key2 = 'second-server';
-            const result2 = await allocatePorts(key2);
-
-            // Verify no overlap
-            const ports1 = new Set([result1.jupyterPort, result1.lspPort]);
-            assert.isFalse(ports1.has(result2.jupyterPort), 'Second Jupyter port should not overlap');
-            assert.isFalse(ports1.has(result2.lspPort), 'Second LSP port should not overlap');
-        });
-    });
-
-    suite('Port Allocation Edge Cases', () => {
-        test('should allocate ports successfully even after multiple allocations', async () => {
-            // Allocate many port pairs to test robustness
-            const count = 10;
-            const keys = Array.from({ length: count }, (_, i) => `stress-test-${i}`);
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-
-            const results = [];
-            for (const key of keys) {
-                const result = await allocatePorts(key);
-                results.push(result);
-            }
-
-            // All should be successful and consecutive
-            assert.strictEqual(results.length, count);
-            for (const result of results) {
-                assert.strictEqual(result.lspPort, result.jupyterPort + 1);
-            }
-
-            // All ports should be unique
-            const allPorts = results.flatMap((r) => [r.jupyterPort, r.lspPort]);
-            const uniquePorts = new Set(allPorts);
-            assert.strictEqual(uniquePorts.size, count * 2);
-        });
-
-        test('should return valid port numbers', async () => {
-            const key = 'valid-ports';
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-            const result = await allocatePorts(key);
-
-            // Ports should be in valid range
-            assert.isAtLeast(result.jupyterPort, 1024, 'Port should be above well-known ports');
-            assert.isBelow(result.jupyterPort, 65536, 'Port should be below max port number');
-            assert.isAtLeast(result.lspPort, 1024);
-            assert.isBelow(result.lspPort, 65536);
-        });
-    });
-
-    suite('Critical Bug Fix Verification', () => {
-        test('REGRESSION TEST: should never allocate non-consecutive ports', async () => {
-            // This is the critical regression test for the bug where
-            // if Jupyter port was available but LSP port (Jupyter+1) was not,
-            // the system would allocate non-consecutive ports causing server hangs
-
-            // Use unique keys with timestamp to avoid conflicts with other tests
-            const timestamp = Date.now();
-            const keys = [
-                `concurrent-test-${timestamp}-1`,
-                `concurrent-test-${timestamp}-2`,
-                `concurrent-test-${timestamp}-3`
-            ];
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const allocatePorts = getPrivateMethod(serverStarter as any, 'allocatePorts');
-
-            const results = await Promise.all(keys.map((key) => allocatePorts(key)));
-
-            // Verify each result has consecutive ports
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                assert.strictEqual(
-                    result.lspPort,
-                    result.jupyterPort + 1,
-                    `Server ${i + 1} (${keys[i]}): LSP port MUST be Jupyter port + 1. ` +
-                        `This prevents server startup hangs when toolkit expects consecutive ports.`
-                );
-            }
+            starter.pendingOperations.set('/test/inflight.deepnote', {
+                type: 'stop',
+                promise: deferred
+            });
 
-            // Verify uniqueness: no two concurrent calls received the same port pair
-            const portPairs = new Set(results.map((r) => `${r.jupyterPort}:${r.lspPort}`));
-            assert.strictEqual(
-                portPairs.size,
-                results.length,
-                'All concurrent allocations must receive unique port pairs'
-            );
+            let disposeResolved = false;
+            const disposePromise = serverStarter.dispose().then(() => {
+                disposeResolved = true;
+            });
 
-            // Verify uniqueness of individual ports
-            const allPorts = results.flatMap((r) => [r.jupyterPort, r.lspPort]);
-            const uniquePorts = new Set(allPorts);
+            await clock.tickAsync(0);
             assert.strictEqual(
-                uniquePorts.size,
-                allPorts.length,
-                'All allocated ports (both Jupyter and LSP) must be unique across concurrent calls'
+                disposeResolved,
+                false,
+                'dispose() should not resolve while a pending operation is in flight'
             );
-        });
-    });
-
-    suite('findConsecutiveAvailablePorts - Edge Cases', () => {
-        test('should mark both ports unavailable and continue when consecutive port is taken', async () => {
-            // This test covers the scenario where a candidate port is available
-            // but the next port (candidate + 1) is not available.
-            // The system should mark BOTH ports as unavailable in portsInUse and continue searching.
-
-            const server1 = net.createServer();
-            const server2 = net.createServer();
-            const blockedPort1 = 54801;
-            const blockedPort2 = 54803;
-
-            // Block ports 54801 and 54803 (leaving 54800 and 54802 available but not consecutive)
-            await new Promise<void>((resolve) => {
-                server1.listen(blockedPort1, 'localhost', () => {
-                    server2.listen(blockedPort2, 'localhost', () => {
-                        resolve();
-                    });
-                });
-            });
-
-            try {
-                const portsInUse = new Set<number>();
-                const startPort = 54800;
-
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const findConsecutiveAvailablePorts = getPrivateMethod(
-                    serverStarter as any,
-                    'findConsecutiveAvailablePorts'
-                );
-
-                // Should skip 54800 (since 54801 is blocked) and 54802 (since 54803 is blocked)
-                // and find the next consecutive pair like 54804+54805
-                const result = await findConsecutiveAvailablePorts(startPort, portsInUse);
-
-                // Verify ports are consecutive
-                assert.strictEqual(result.lspPort, result.jupyterPort + 1);
-
-                // Should have found ports after the blocked ones
-                assert.isTrue(
-                    result.jupyterPort > blockedPort2 || result.jupyterPort < blockedPort1 - 1,
-                    'Should skip blocked port ranges'
-                );
-            } finally {
-                // Clean up
-                await new Promise<void>((resolve) => {
-                    server1.close(() => {
-                        server2.close(() => resolve());
-                    });
-                });
-            }
-        });
-
-        test('should throw DeepnoteServerStartupError when max attempts exhausted', async () => {
-            // This test covers the scenario where we cannot find consecutive ports
-            // after maxAttempts (100 attempts). This should throw a DeepnoteServerStartupError.
-            // Strategy: Block every other port so individual ports are available,
-            // but no consecutive pairs exist (blocking the +1 port for each available port)
-
-            const servers: any[] = [];
-
-            try {
-                // Block every other port starting from 55001 (leaving 55000, 55002, 55004, etc. available)
-                // This ensures findAvailablePort succeeds, but the consecutive port is always blocked
-                const startPort = 55000;
-                const portsToBlock = 200; // Block 200 odd-numbered ports
-
-                // Create servers blocking every other port (the +1 ports)
-                for (let i = 0; i < portsToBlock; i++) {
-                    const portToBlock = startPort + i * 2 + 1; // Block 55001, 55003, 55005, etc.
-                    const server = net.createServer();
-                    servers.push(server);
-                    await new Promise<void>((resolve) => {
-                        server.listen(portToBlock, 'localhost', () => resolve());
-                    });
-                }
-
-                const portsInUse = new Set<number>();
-
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const findConsecutiveAvailablePorts = getPrivateMethod(
-                    serverStarter as any,
-                    'findConsecutiveAvailablePorts'
-                );
 
-                // Should throw DeepnoteServerStartupError after maxAttempts
-                // Note: The error could come from either findConsecutiveAvailablePorts or findAvailablePort
-                // depending on port availability timing
-                let errorThrown = false;
-                try {
-                    await findConsecutiveAvailablePorts(startPort, portsInUse);
-                } catch (error: any) {
-                    errorThrown = true;
-                    assert.strictEqual(error.constructor.name, 'DeepnoteServerStartupError');
-                    // Accept either error message since both indicate port exhaustion
-                    const isConsecutiveError = error.stderr.includes('Failed to find consecutive available ports');
-                    const isSinglePortError = error.stderr.includes('Failed to find available port');
-                    assert.isTrue(
-                        isConsecutiveError || isSinglePortError,
-                        `Expected port exhaustion error, got: ${error.stderr}`
-                    );
-                }
+            resolveDeferred();
+            await clock.tickAsync(0);
+            await disposePromise;
 
-                assert.isTrue(errorThrown, 'Expected DeepnoteServerStartupError to be thrown');
-            } finally {
-                // Clean up all servers
-                await Promise.all(
-                    servers.map(
-                        (server) =>
-                            new Promise<void>((resolve) => {
-                                server.close(() => resolve());
-                            })
-                    )
-                );
-            }
+            assert.strictEqual(disposeResolved, true, 'dispose() should resolve after pending operation completes');
+            assert.strictEqual(starter.pendingOperations.size, 0);
         });
     });
 });
diff --git a/src/kernels/deepnote/deepnoteTestHelpers.node.ts b/src/kernels/deepnote/deepnoteTestHelpers.node.ts
new file mode 100644
index 0000000000..524c6e0e47
--- /dev/null
+++ b/src/kernels/deepnote/deepnoteTestHelpers.node.ts
@@ -0,0 +1,15 @@
+import type { ChildProcess } from 'node:child_process';
+
+/**
+ * Creates a mock ChildProcess for use in Deepnote server info tests.
+ * Satisfies the ChildProcess interface with minimal stub values.
+ */
+export function createMockChildProcess(overrides?: Partial<ChildProcess>): ChildProcess {
+    return {
+        pid: undefined,
+        stdout: null,
+        stderr: null,
+        exitCode: null,
+        ...overrides
+    } as ChildProcess;
+}
diff --git a/src/kernels/deepnote/deepnoteToolkitInstaller.node.ts b/src/kernels/deepnote/deepnoteToolkitInstaller.node.ts
index c18c9d4a47..2c7ebdadbc 100644
--- a/src/kernels/deepnote/deepnoteToolkitInstaller.node.ts
+++ b/src/kernels/deepnote/deepnoteToolkitInstaller.node.ts
@@ -4,6 +4,8 @@
 import { inject, injectable, named } from 'inversify';
 import { CancellationToken, l10n, Uri, workspace } from 'vscode';
 
+import { resolvePythonExecutable } from '@deepnote/runtime-core';
+
 import { Cancellation } from '../../platform/common/cancellation';
 import { STANDARD_OUTPUT_CHANNEL } from '../../platform/common/constants';
 import { IFileSystem } from '../../platform/common/platform/types';
@@ -44,6 +46,8 @@ export class DeepnoteToolkitInstaller implements IDeepnoteToolkitInstaller {
 
     /**
      * Get the venv Python interpreter by direct venv path.
+     * Uses @deepnote/runtime-core's `resolvePythonExecutable` which handles
+     * venv root, bin dir, and bare command detection across all platforms.
      */
     private async getVenvInterpreterByPath(venvPath: Uri): Promise<PythonEnvironment | undefined> {
         const cacheKey = venvPath.fsPath;
@@ -52,18 +56,15 @@ export class DeepnoteToolkitInstaller implements IDeepnoteToolkitInstaller {
             return { uri: this.venvPythonPaths.get(cacheKey)!, id: this.venvPythonPaths.get(cacheKey)!.fsPath };
         }
 
-        // Check if venv exists
-        const pythonInVenv =
-            process.platform === 'win32'
-                ? Uri.joinPath(venvPath, 'Scripts', 'python.exe')
-                : Uri.joinPath(venvPath, 'bin', 'python');
+        try {
+            const resolvedPath = await resolvePythonExecutable(venvPath.fsPath);
+            const pythonUri = Uri.file(resolvedPath);
 
-        if (await this.fs.exists(pythonInVenv)) {
-            this.venvPythonPaths.set(cacheKey, pythonInVenv);
-            return { uri: pythonInVenv, id: pythonInVenv.fsPath };
+            this.venvPythonPaths.set(cacheKey, pythonUri);
+            return { uri: pythonUri, id: pythonUri.fsPath };
+        } catch {
+            return undefined;
         }
-
-        return undefined;
     }
 
     public async getVenvInterpreter(deepnoteFileUri: Uri): Promise<PythonEnvironment | undefined> {
diff --git a/src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.unit.test.ts b/src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.unit.test.ts
index 4cc6d5df5d..05b690f3b7 100644
--- a/src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.unit.test.ts
+++ b/src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.unit.test.ts
@@ -1,6 +1,7 @@
 import { assert } from 'chai';
 import { instance, mock, when } from 'ts-mockito';
 import { Uri, EventEmitter } from 'vscode';
+import { createMockChildProcess } from '../deepnoteTestHelpers.node';
 import { DeepnoteEnvironmentTreeDataProvider } from './deepnoteEnvironmentTreeDataProvider.node';
 import { IDeepnoteEnvironmentManager } from '../types';
 import { DeepnoteEnvironment } from './deepnoteEnvironment';
@@ -40,7 +41,8 @@ suite('DeepnoteEnvironmentTreeDataProvider', () => {
             url: 'http://localhost:8888',
             jupyterPort: 8888,
             lspPort: 8889,
-            token: 'test-token'
+            token: 'test-token',
+            process: createMockChildProcess()
         }
     };
 
diff --git a/src/kernels/deepnote/types.ts b/src/kernels/deepnote/types.ts
index ef64ae04e0..a0c17a31ba 100644
--- a/src/kernels/deepnote/types.ts
+++ b/src/kernels/deepnote/types.ts
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+import type { ServerInfo as RuntimeCoreServerInfo } from '@deepnote/runtime-core';
 import * as vscode from 'vscode';
 
 import { serializePythonEnvironment } from '../../platform/api/pythonApi';
@@ -185,10 +186,7 @@ export interface IDeepnoteServerStarter {
     dispose(): Promise<void>;
 }
 
-export interface DeepnoteServerInfo {
-    url: string;
-    jupyterPort: number;
-    lspPort: number;
+export interface DeepnoteServerInfo extends RuntimeCoreServerInfo {
     token?: string;
 }
 
diff --git a/src/notebooks/deepnote/deepnoteKernelAutoSelector.node.unit.test.ts b/src/notebooks/deepnote/deepnoteKernelAutoSelector.node.unit.test.ts
index 8141e32093..824635343c 100644
--- a/src/notebooks/deepnote/deepnoteKernelAutoSelector.node.unit.test.ts
+++ b/src/notebooks/deepnote/deepnoteKernelAutoSelector.node.unit.test.ts
@@ -2,6 +2,7 @@ import { assert } from 'chai';
 import * as sinon from 'sinon';
 import { anything, instance, mock, verify, when } from 'ts-mockito';
 import { DeepnoteKernelAutoSelector } from './deepnoteKernelAutoSelector.node';
+import { createMockChildProcess } from '../../kernels/deepnote/deepnoteTestHelpers.node';
 import {
     IDeepnoteEnvironmentManager,
     IDeepnoteLspClientManager,
@@ -1042,7 +1043,8 @@ function createMockEnvironment(id: string, name: string, hasServer: boolean = fa
                   url: `http://localhost:8888`,
                   jupyterPort: 8888,
                   lspPort: 8889,
-                  token: 'test-token'
+                  token: 'test-token',
+                  process: createMockChildProcess()
               }
             : undefined
     };