From 309a165d178676a5c3413be0b92ebcf781ac756f Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 10:34:58 +0000
Subject: [PATCH 1/7] chore: Rename jupyter command prefix to deepnote

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 .../instructions/ipywidgets.instructions.md   |  445 ++++---
 api/README.md                                 |    3 +-
 build/preDebugWebTest.js                      |    4 +-
 package.json                                  | 1106 ++++++++---------
 package.nls.json                              |  342 ++---
 src/commands.ts                               |   16 +-
 src/extension.common.ts                       |    2 +-
 src/extension.node.ts                         |    4 +-
 src/extension.web.ts                          |    4 +-
 .../editor-integration/cellRangeCache.ts      |    4 +-
 .../cellRangeCache.unit.test.ts               |   12 +-
 src/kernels/errors/kernelErrorHandler.ts      |    2 +-
 .../errors/kernelErrorHandler.unit.test.ts    |    6 +-
 ...jupyterInterpreterSelectionCommand.node.ts |    2 +-
 ...erInterpreterSelectionCommand.unit.test.ts |    8 +-
 .../installPythonControllerCommands.ts        |    2 +-
 .../message/ipyWidgetMessageDispatcher.ts     |    2 +-
 .../kernelSourceCommandHandler.ts             |   16 +-
 src/notebooks/outputs/linkProvider.ts         |    6 +-
 .../commands/reloadCommand.node.ts            |    2 +-
 .../commands/reloadCommand.unit.test.ts       |    2 +-
 .../runInDedicatedExtensionHost.node.ts       |    2 +-
 src/platform/common/cache.ts                  |    2 +-
 src/platform/common/constants.ts              |  212 ++--
 src/platform/common/utils/localize.ts         |   52 +-
 src/platform/errors/errorUtils.ts             |    2 +-
 .../filter/completionProvider.node.ts         |    2 +-
 .../interpreter/filter/filterService.ts       |    2 +-
 .../filter/uiDeprecationHandler.ts            |    4 +-
 src/platform/logging/index.ts                 |    2 +-
 src/platform/webviews/webviewHost.ts          |    2 +-
 .../api/kernels/accessManagement.ts           |    2 +-
 src/standalone/chat/extension.node.ts         |    4 +-
 src/standalone/executionAnalysis/extension.ts |   10 +-
 src/standalone/executionAnalysis/symbols.ts   |    2 +-
 .../intellisense/kernelCompletionProvider.ts  |   10 +-
 .../serverSelectorForTests.ts                 |    2 +-
 src/test/.vscode/settings.json                |    2 +-
 src/test/common.node.ts                       |    6 +-
 src/test/common.web.ts                        |    2 +-
 src/test/datascience/.vscode/settings.json    |   10 +-
 .../interactiveDebugging.vscode.test.ts       |   20 +-
 .../interactiveWindow.vscode.common.test.ts   |    4 +-
 .../notebook/exportFull.vscode.test.ts        |   10 +-
 src/test/index.node.ts                        |    2 +-
 src/test/smoke/datascience.smoke.test.ts      |    6 +-
 src/test/standardTest.node.ts                 |    6 +-
 src/test/web/index.ts                         |    4 +-
 48 files changed, 1186 insertions(+), 1188 deletions(-)

diff --git a/.github/instructions/ipywidgets.instructions.md b/.github/instructions/ipywidgets.instructions.md
index 4c574c0213..6d5dcc2d4a 100644
--- a/.github/instructions/ipywidgets.instructions.md
+++ b/.github/instructions/ipywidgets.instructions.md
@@ -47,16 +47,16 @@ src/
 
 **Key Responsibilities**:
 
--   Manages lifecycle of IPyWidgets per notebook document
--   Coordinates communication between VS Code UI and webview renderers
--   Handles controller selection and webview attachment
--   Creates and manages `CommonMessageCoordinator` instances per notebook
+- Manages lifecycle of IPyWidgets per notebook document
+- Coordinates communication between VS Code UI and webview renderers
+- Handles controller selection and webview attachment
+- Creates and manages `CommonMessageCoordinator` instances per notebook
 
 **Key Methods**:
 
--   `activate()`: Initializes event listeners for notebook lifecycle
--   `onDidSelectController()`: Handles kernel controller changes
--   `initializeNotebookCommunication()`: Sets up webview communication
+- `activate()`: Initializes event listeners for notebook lifecycle
+- `onDidSelectController()`: Handles kernel controller changes
+- `initializeNotebookCommunication()`: Sets up webview communication
 
 ### 2. CommonMessageCoordinator (`message/commonMessageCoordinator.ts`)
 
@@ -64,16 +64,16 @@ src/
 
 **Key Responsibilities**:
 
--   Manages message flow between extension and webview
--   Handles IPyWidgets version determination and script loading
--   Coordinates between message dispatcher and script source provider
--   Manages widget load success/failure telemetry
+- Manages message flow between extension and webview
+- Handles IPyWidgets version determination and script loading
+- Coordinates between message dispatcher and script source provider
+- Manages widget load success/failure telemetry
 
 **Key Methods**:
 
--   `attach()`: Attaches to a webview communication channel
--   `onMessage()`: Processes incoming messages from webview
--   `initialize()`: Sets up message dispatcher and script source provider
+- `attach()`: Attaches to a webview communication channel
+- `onMessage()`: Processes incoming messages from webview
+- `initialize()`: Sets up message dispatcher and script source provider
 
 ### 3. IPyWidgetMessageDispatcher (`message/ipyWidgetMessageDispatcher.ts`)
 
@@ -81,24 +81,24 @@ src/
 
 **Key Responsibilities**:
 
--   Proxies kernel messages between extension and webview
--   Manages comm target registration for widget communication
--   Handles message hooks for widget output processing
--   Synchronizes kernel state with webview widget manager
+- Proxies kernel messages between extension and webview
+- Manages comm target registration for widget communication
+- Handles message hooks for widget output processing
+- Synchronizes kernel state with webview widget manager
 
 **Key Methods**:
 
--   `receiveMessage()`: Processes messages from webview
--   `sendRawPayloadToKernelSocket()`: Sends messages to kernel
--   `registerCommTarget()`: Registers communication targets
--   `onKernelSocketMessage()`: Handles incoming kernel messages
+- `receiveMessage()`: Processes messages from webview
+- `sendRawPayloadToKernelSocket()`: Sends messages to kernel
+- `registerCommTarget()`: Registers communication targets
+- `onKernelSocketMessage()`: Handles incoming kernel messages
 
 **Integration with `@jupyterlab/services`**:
 
--   Uses `@jupyterlab/services` for kernel message serialization/deserialization
--   Leverages `KernelMessage` interfaces for type safety
--   Utilizes `Kernel.IKernelConnection` for comm target management
--   Handles `IIOPubMessage` and `IDisplayDataMsg` types
+- Uses `@jupyterlab/services` for kernel message serialization/deserialization
+- Leverages `KernelMessage` interfaces for type safety
+- Utilizes `Kernel.IKernelConnection` for comm target management
+- Handles `IIOPubMessage` and `IDisplayDataMsg` types
 
 ### 4. Script Source Management (`scriptSourceProvider/`)
 
@@ -108,21 +108,21 @@ src/
 
 #### IPyWidgetScriptSource (`ipyWidgetScriptSource.ts`)
 
--   Coordinates script source requests from webview
--   Manages communication with script source providers
--   Handles widget script caching and serving
+- Coordinates script source requests from webview
+- Manages communication with script source providers
+- Handles widget script caching and serving
 
 #### Script Source Providers
 
--   **CDNWidgetScriptSourceProvider**: Serves scripts from CDN sources
--   **LocalWidgetScriptSourceProvider**: Serves scripts from local Python environment
--   **RemoteWidgetScriptSourceProvider**: Serves scripts from remote Jupyter servers
+- **CDNWidgetScriptSourceProvider**: Serves scripts from CDN sources
+- **LocalWidgetScriptSourceProvider**: Serves scripts from local Python environment
+- **RemoteWidgetScriptSourceProvider**: Serves scripts from remote Jupyter servers
 
 #### IPyWidgetScriptManager (Platform-specific)
 
--   **LocalIPyWidgetScriptManager**: Manages local nbextensions directory
--   **RemoteIPyWidgetScriptManager**: Manages remote widget scripts
--   **BaseIPyWidgetScriptManager**: Common functionality across platforms
+- **LocalIPyWidgetScriptManager**: Manages local nbextensions directory
+- **RemoteIPyWidgetScriptManager**: Manages remote widget scripts
+- **BaseIPyWidgetScriptManager**: Common functionality across platforms
 
 ### 5. Webview-Side Widget System (`webviews/webview-side/ipywidgets/`)
 
@@ -132,21 +132,21 @@ src/
 
 #### Kernel Proxy (`kernel/index.ts`)
 
--   Creates a proxy kernel connection in the webview
--   Manages widget lifecycle and rendering
--   Handles message passing between extension and widget manager
+- Creates a proxy kernel connection in the webview
+- Manages widget lifecycle and rendering
+- Handles message passing between extension and widget manager
 
 #### Widget Manager (`kernel/manager.ts`)
 
--   Integrates with JupyterLab widget manager
--   Manages widget model state and synchronization
--   Handles widget rendering and disposal
+- Integrates with JupyterLab widget manager
+- Manages widget model state and synchronization
+- Handles widget rendering and disposal
 
 #### Script Manager (`kernel/scriptManager.ts`)
 
--   Dynamically loads widget JavaScript modules
--   Manages script dependencies and loading order
--   Handles script loading failures and retries
+- Dynamically loads widget JavaScript modules
+- Manages script dependencies and loading order
+- Handles script loading failures and retries
 
 ### 6. Renderer Communication (`webviews/extension-side/ipywidgets/rendererComms.ts`)
 
@@ -154,10 +154,10 @@ src/
 
 **Key Responsibilities**:
 
--   Tracks widget model IDs in notebook outputs
--   Handles renderer-specific widget queries
--   Manages widget state and version information
--   Coordinates with IPyWidgetMessageDispatcher for display messages
+- Tracks widget model IDs in notebook outputs
+- Handles renderer-specific widget queries
+- Manages widget state and version information
+- Coordinates with IPyWidgetMessageDispatcher for display messages
 
 ### 7. IPyWidgets Standalone Package (`@vscode/jupyter-ipywidgets8`)
 
@@ -167,11 +167,11 @@ src/
 
 **Key Features**:
 
--   Self-contained IPyWidgets 8.x implementation
--   JupyterLab compatibility layer
--   Dynamic module loading via RequireJS
--   Version-specific widget support
--   CSS and font bundling
+- Self-contained IPyWidgets 8.x implementation
+- JupyterLab compatibility layer
+- Dynamic module loading via RequireJS
+- Version-specific widget support
+- CSS and font bundling
 
 **Package Structure**:
 
@@ -187,31 +187,31 @@ src/
 
 **Critical Classes**:
 
--   **`WidgetManager`**: Extends `@jupyter-widgets/jupyterlab-manager`
+- **`WidgetManager`**: Extends `@jupyter-widgets/jupyterlab-manager`
 
-    -   Implements dynamic widget class loading
-    -   Handles script loading with fallbacks
-    -   Provides error/success callbacks
-    -   Registers mime renderers for nested outputs
+  - Implements dynamic widget class loading
+  - Handles script loading with fallbacks
+  - Provides error/success callbacks
+  - Registers mime renderers for nested outputs
 
--   **`DocumentContext`**: Mock implementation of JupyterLab's document context
+- **`DocumentContext`**: Mock implementation of JupyterLab's document context
 
-    -   Implements `ISessionContext` and `DocumentRegistry.IContext`
-    -   Bridges VS Code kernel with JupyterLab widget system
-    -   Provides minimal required functionality
+  - Implements `ISessionContext` and `DocumentRegistry.IContext`
+  - Bridges VS Code kernel with JupyterLab widget system
+  - Provides minimal required functionality
 
--   **`SessionConnection`**: Wrapper around kernel connection
-    -   Implements `ISessionConnection` interface
-    -   Delegates to underlying kernel connection
-    -   Provides session-like API for compatibility
+- **`SessionConnection`**: Wrapper around kernel connection
+  - Implements `ISessionConnection` interface
+  - Delegates to underlying kernel connection
+  - Provides session-like API for compatibility
 
 **Dynamic Loading Pattern**:
 
 ```typescript
 // Global exposure for extension consumption
 (window as any).vscIPyWidgets8 = {
-    load, // Loads IPyWidgets 8.x scripts and CSS
-    unload // Cleans up and unloads modules
+  load, // Loads IPyWidgets 8.x scripts and CSS
+  unload // Cleans up and unloads modules
 };
 
 // RequireJS module registration
@@ -222,9 +222,9 @@ define('@jupyter-widgets/output', () => outputWidgets);
 
 **Integration Points**:
 
--   Consumed by main extension via webpack bundle
--   Loaded conditionally based on detected IPyWidgets version
--   Provides `WidgetManager` class for webview-side widget rendering
+- Consumed by main extension via webpack bundle
+- Loaded conditionally based on detected IPyWidgets version
+- Provides `WidgetManager` class for webview-side widget rendering
 
 ## IPyWidgets Protocol and Communication Patterns
 
@@ -238,16 +238,16 @@ IPyWidgets uses the Jupyter Comm system for kernel-frontend communication:
 
 **Core Characteristics**:
 
--   **Symmetric**: Both kernel and frontend can initiate communication
--   **Asynchronous**: Fire-and-forget messaging with no guaranteed delivery
--   **GUID-based**: Each comm has unique identifier for message routing
--   **Target-based**: Comms registered with specific target names
+- **Symmetric**: Both kernel and frontend can initiate communication
+- **Asynchronous**: Fire-and-forget messaging with no guaranteed delivery
+- **GUID-based**: Each comm has unique identifier for message routing
+- **Target-based**: Comms registered with specific target names
 
 **Message Types**:
 
--   `comm_open`: Establish new communication channel
--   `comm_msg`: Send data over established channel
--   `comm_close`: Close communication channel
+- `comm_open`: Establish new communication channel
+- `comm_msg`: Send data over established channel
+- `comm_close`: Close communication channel
 
 #### State Synchronization Model
 
@@ -255,10 +255,10 @@ Widget state synchronization follows a distributed model:
 
 **Key Principles**:
 
--   No single source of truth - both kernel and frontend maintain state
--   Automatic bidirectional propagation for traits marked `sync=True`
--   Conflict resolution via "last write wins" semantics
--   Custom serialization support for complex data types
+- No single source of truth - both kernel and frontend maintain state
+- Automatic bidirectional propagation for traits marked `sync=True`
+- Conflict resolution via "last write wins" semantics
+- Custom serialization support for complex data types
 
 ### 2. Message Flow Patterns
 
@@ -276,7 +276,7 @@ display(widget)               # 2. Display in cell output
 **Corresponding Message Flow**:
 
 ```
-1. Widget constructor → comm_open with target 'jupyter.widget'
+1. Widget constructor → comm_open with target 'deepnote.widget'
 2. display() call → display_data message with widget repr
 3. Initial state sync → comm_msg with current trait values
 4. Frontend receives messages → creates WidgetModel + WidgetView
@@ -364,13 +364,13 @@ VS Code's webview isolation requires message bridging:
 
 ```typescript
 // Forward kernel comms to webview
-kernel.addCommTarget('jupyter.widget', (comm, msg) => {
-    webview.postMessage({
-        type: 'comm_open',
-        comm_id: comm.id,
-        target: comm.target_name,
-        data: msg.content.data
-    });
+kernel.addCommTarget('deepnote.widget', (comm, msg) => {
+  webview.postMessage({
+    type: 'comm_open',
+    comm_id: comm.id,
+    target: comm.target_name,
+    data: msg.content.data
+  });
 });
 ```
 
@@ -379,10 +379,10 @@ kernel.addCommTarget('jupyter.widget', (comm, msg) => {
 ```typescript
 // Recreate comms in proxy kernel
 onDidReceiveMessage((message) => {
-    if (message.type === 'comm_open') {
-        const comm = this.proxyKernel.createComm(message.target, message.data);
-        comm.comm_id = message.comm_id;
-    }
+  if (message.type === 'comm_open') {
+    const comm = this.proxyKernel.createComm(message.target, message.data);
+    comm.comm_id = message.comm_id;
+  }
 });
 ```
 
@@ -437,31 +437,31 @@ The IPyWidgets system relies on a sophisticated kernel hook system that intercep
 
 ```typescript
 export function KernelSocketWrapper<T extends ClassType<IWebSocketLike>>(SuperClass: T) {
-    return class BaseKernelSocket extends SuperClass implements IKernelSocket {
-        private receiveHooks: ((data: WebSocketData) => Promise<void>)[];
-        private sendHooks: ((data: any, cb?: (err?: Error) => void) => Promise<void>)[];
-        private msgChain: Promise<any>;
-        private sendChain: Promise<any>;
-
-        // Override send to inject sendHooks
-        public override send(data: any, a2: any): void {
-            this.sendChain = this.sendChain
-                .then(() => Promise.all(this.sendHooks.map((s) => s(data, a2))))
-                .then(() => super.send(data, a2));
-        }
+  return class BaseKernelSocket extends SuperClass implements IKernelSocket {
+    private receiveHooks: ((data: WebSocketData) => Promise<void>)[];
+    private sendHooks: ((data: any, cb?: (err?: Error) => void) => Promise<void>)[];
+    private msgChain: Promise<any>;
+    private sendChain: Promise<any>;
+
+    // Override send to inject sendHooks
+    public override send(data: any, a2: any): void {
+      this.sendChain = this.sendChain
+        .then(() => Promise.all(this.sendHooks.map((s) => s(data, a2))))
+        .then(() => super.send(data, a2));
+    }
 
-        // Override emit to inject receiveHooks
-        protected handleEvent(superHandler, event, ...args): boolean {
-            if (event === 'message' && this.receiveHooks.length) {
-                this.msgChain = this.msgChain
-                    .then(() => Promise.all(this.receiveHooks.map((p) => p(args[0]))))
-                    .then(() => superHandler(event, ...args))
-                    .catch((e) => logger.error(`Exception while handling messages: ${e}`));
-                return true;
-            }
-            return superHandler(event, ...args);
-        }
-    };
+    // Override emit to inject receiveHooks
+    protected handleEvent(superHandler, event, ...args): boolean {
+      if (event === 'message' && this.receiveHooks.length) {
+        this.msgChain = this.msgChain
+          .then(() => Promise.all(this.receiveHooks.map((p) => p(args[0]))))
+          .then(() => superHandler(event, ...args))
+          .catch((e) => logger.error(`Exception while handling messages: ${e}`));
+        return true;
+      }
+      return superHandler(event, ...args);
+    }
+  };
 }
 ```
 
@@ -527,12 +527,12 @@ if (this.messageNeedsFullHandle(message)) {
 
 ```typescript
 const mustDeserialize =
-    typeof data !== 'string' ||
-    data.includes(WIDGET_MIMETYPE) ||
-    data.includes(Identifiers.DefaultCommTarget) ||
-    data.includes('comm_open') ||
-    data.includes('comm_close') ||
-    data.includes('comm_msg');
+  typeof data !== 'string' ||
+  data.includes(WIDGET_MIMETYPE) ||
+  data.includes(Identifiers.DefaultCommTarget) ||
+  data.includes('comm_open') ||
+  data.includes('comm_close') ||
+  data.includes('comm_msg');
 ```
 
 **Performance Optimization**: Only deserialize messages that potentially contain widget data to minimize processing overhead.
@@ -598,29 +598,29 @@ The system uses a comprehensive set of message types for communication:
 
 #### Widget Lifecycle Messages
 
--   `IPyWidgets_Ready`: Webview ready for widget communication
--   `IPyWidgets_Request_Widget_Version`: Request IPyWidgets version
--   `IPyWidgets_Reply_Widget_Version`: Version response
--   `IPyWidgets_onRestartKernel`: Kernel restart notification
+- `IPyWidgets_Ready`: Webview ready for widget communication
+- `IPyWidgets_Request_Widget_Version`: Request IPyWidgets version
+- `IPyWidgets_Reply_Widget_Version`: Version response
+- `IPyWidgets_onRestartKernel`: Kernel restart notification
 
 #### Script Loading Messages
 
--   `IPyWidgets_WidgetScriptSourceRequest`: Request widget script source
--   `IPyWidgets_WidgetScriptSourceResponse`: Script source response
--   `IPyWidgets_BaseUrlResponse`: Base URL for script loading
+- `IPyWidgets_WidgetScriptSourceRequest`: Request widget script source
+- `IPyWidgets_WidgetScriptSourceResponse`: Script source response
+- `IPyWidgets_BaseUrlResponse`: Base URL for script loading
 
 #### Kernel Communication Messages
 
--   `IPyWidgets_msg`: Kernel message (text)
--   `IPyWidgets_binary_msg`: Kernel message (binary)
--   `IPyWidgets_msg_received`: Message received acknowledgment
--   `IPyWidgets_kernelOptions`: Kernel configuration
+- `IPyWidgets_msg`: Kernel message (text)
+- `IPyWidgets_binary_msg`: Kernel message (binary)
+- `IPyWidgets_msg_received`: Message received acknowledgment
+- `IPyWidgets_kernelOptions`: Kernel configuration
 
 #### Error and Status Messages
 
--   `IPyWidgetLoadSuccess`: Widget loaded successfully
--   `IPyWidgetLoadFailure`: Widget load failed
--   `IPyWidgetRenderFailure`: Widget render failed
+- `IPyWidgetLoadSuccess`: Widget loaded successfully
+- `IPyWidgetLoadFailure`: Widget load failed
+- `IPyWidgetRenderFailure`: Widget render failed
 
 ### Communication Flow
 
@@ -673,7 +673,7 @@ const msg = deserialize(data, protocol) as KernelMessage.IMessage;
 
 // Type-safe message handling
 if (jupyterLab.KernelMessage.isDisplayDataMsg(msg)) {
-    this._onDisplayMessage.fire(msg);
+  this._onDisplayMessage.fire(msg);
 }
 ```
 
@@ -696,7 +696,7 @@ import { IDisplayDataMsg, IIOPubMessage } from '@jupyterlab/services/lib/kernel/
 
 // Type-safe message processing
 if (KernelMessage.isDisplayDataMsg(msg)) {
-    this.trackModelId(notebook, msg);
+  this.trackModelId(notebook, msg);
 }
 ```
 
@@ -706,20 +706,20 @@ The system depends on several key modules from `@jupyterlab/services`:
 
 #### Kernel Management (`/kernel/`)
 
--   **`kernel.ts`**: Core kernel interface and connection management
--   **`messages.ts`**: Message type definitions and validation
--   **`serialize.ts`**: Message serialization/deserialization
--   **`manager.ts`**: Kernel manager functionality
+- **`kernel.ts`**: Core kernel interface and connection management
+- **`messages.ts`**: Message type definitions and validation
+- **`serialize.ts`**: Message serialization/deserialization
+- **`manager.ts`**: Kernel manager functionality
 
 #### Session Management (`/session/`)
 
--   **`session.ts`**: Session management and lifecycle
--   **`manager.ts`**: Session manager for connection handling
+- **`session.ts`**: Session management and lifecycle
+- **`manager.ts`**: Session manager for connection handling
 
 #### Server Connection (`serverConnection.ts`)
 
--   Handles HTTP/WebSocket connections to Jupyter servers
--   Manages authentication and connection state
+- Handles HTTP/WebSocket connections to Jupyter servers
+- Manages authentication and connection state
 
 ## Architecture Deep Dive
 
@@ -731,28 +731,28 @@ VS Code implements the complete IPyWidgets comm protocol as a transparent bridge
 
 **Protocol Requirements**:
 
--   Symmetric, asynchronous messaging between kernel and frontend
--   JSON-serializable message blobs with GUID-based routing
--   Target-based comm registration and lifecycle management
--   Bidirectional state synchronization without single source of truth
+- Symmetric, asynchronous messaging between kernel and frontend
+- JSON-serializable message blobs with GUID-based routing
+- Target-based comm registration and lifecycle management
+- Bidirectional state synchronization without single source of truth
 
 **VS Code Implementation**:
 
 ```typescript
 // Extension acts as comm broker
-kernel.registerCommTarget('jupyter.widget', (comm, msg) => {
-    // Forward comm lifecycle to webview
-    webview.postMessage({
-        type: 'comm_open',
-        comm_id: comm.id,
-        target: comm.target_name,
-        data: msg.content.data
-    });
+kernel.registerCommTarget('deepnote.widget', (comm, msg) => {
+  // Forward comm lifecycle to webview
+  webview.postMessage({
+    type: 'comm_open',
+    comm_id: comm.id,
+    target: comm.target_name,
+    data: msg.content.data
+  });
 });
 
 // Handle bidirectional comm messages
 comm.onMsg = (msg) => {
-    webview.postMessage({ type: 'comm_msg', comm_id: comm.id, msg });
+  webview.postMessage({ type: 'comm_msg', comm_id: comm.id, msg });
 };
 ```
 
@@ -762,9 +762,9 @@ Implements the standard IPyWidgets Model-View pattern with VS Code adaptations:
 
 **Standard Protocol**:
 
--   WidgetModel (1) ↔ WidgetView (N) relationship
--   State synchronization via trait system with `sync=True` metadata
--   Display association via execution message GUID tracking
+- WidgetModel (1) ↔ WidgetView (N) relationship
+- State synchronization via trait system with `sync=True` metadata
+- Display association via execution message GUID tracking
 
 **VS Code Specific Handling**:
 
@@ -798,14 +798,14 @@ class MyWidget(DOMWidget):
 
 ```javascript
 var MyWidgetView = widgets.DOMWidgetView.extend({
-    initialize: function () {
-        // Listen for model changes
-        this.listenTo(this.model, 'change:count', this._count_changed);
-    },
-    _count_changed: function () {
-        // Update view based on model change
-        this.el.textContent = this.model.get('count');
-    }
+  initialize: function () {
+    // Listen for model changes
+    this.listenTo(this.model, 'change:count', this._count_changed);
+  },
+  _count_changed: function () {
+    // Update view based on model change
+    this.el.textContent = this.model.get('count');
+  }
 });
 ```
 
@@ -875,9 +875,9 @@ Multiple providers ensure widget availability across deployment scenarios:
 
 **Provider Types**:
 
--   **LocalWidgetScriptSourceProvider**: Local nbextensions directory
--   **RemoteWidgetScriptSourceProvider**: Remote Jupyter server
--   **CDNWidgetScriptSourceProvider**: Public CDN fallback
+- **LocalWidgetScriptSourceProvider**: Local nbextensions directory
+- **RemoteWidgetScriptSourceProvider**: Remote Jupyter server
+- **CDNWidgetScriptSourceProvider**: Public CDN fallback
 
 ### 4. Execution Context and Display Protocol
 
@@ -1175,17 +1175,17 @@ const msg = deserialize(data, protocol) as KernelMessage.IMessage;
 
 // Webview side - creating proxy kernel with proper serialization
 const settings = ServerConnection.makeSettings({
-    WebSocket: ProxyWebSocket as any,
-    wsUrl: 'BOGUS_PVSC'
+  WebSocket: ProxyWebSocket as any,
+  wsUrl: 'BOGUS_PVSC'
 });
 ```
 
 **Critical Usage**:
 
--   Protocol-aware message deserialization
--   Binary data handling for widget state
--   Message validation and type checking
--   Cross-platform compatibility (Node.js vs Browser)
+- Protocol-aware message deserialization
+- Binary data handling for widget state
+- Message validation and type checking
+- Cross-platform compatibility (Node.js vs Browser)
 
 #### 2. Kernel Connection Management
 
@@ -1196,20 +1196,20 @@ const settings = ServerConnection.makeSettings({
 import { KernelConnection } from '@jupyterlab/services/lib/kernel/default';
 
 this.realKernel = new KernelConnection({
-    serverSettings: settings,
-    clientId: options.clientId,
-    handleComms: true,
-    username: options.userName,
-    model: options.model
+  serverSettings: settings,
+  clientId: options.clientId,
+  handleComms: true,
+  username: options.userName,
+  model: options.model
 });
 ```
 
 **Critical Features**:
 
--   Full `Kernel.IKernelConnection` interface implementation
--   Comm target registration and management
--   Message hook system integration
--   Future and promise-based message handling
+- Full `Kernel.IKernelConnection` interface implementation
+- Comm target registration and management
+- Message hook system integration
+- Future and promise-based message handling
 
 #### 3. Message Type Validation and Processing
 
@@ -1220,20 +1220,20 @@ this.realKernel = new KernelConnection({
 import { KernelMessage } from '@jupyterlab/services';
 
 if (KernelMessage.isDisplayDataMsg(msg)) {
-    this._onDisplayMessage.fire(msg as IDisplayDataMsg);
+  this._onDisplayMessage.fire(msg as IDisplayDataMsg);
 }
 
 if (KernelMessage.isCommOpenMsg(msg) || KernelMessage.isCommCloseMsg(msg) || KernelMessage.isCommMsgMsg(msg)) {
-    // Handle comm messages
+  // Handle comm messages
 }
 ```
 
 **Message Types Used**:
 
--   `IExecuteRequestMsg` / `IExecuteReplyMsg` - Code execution
--   `IDisplayDataMsg` / `IUpdateDisplayDataMsg` - Widget output
--   `ICommOpenMsg` / `ICommCloseMsg` / `ICommMsgMsg` - Widget communication
--   `IIOPubMessage` - Kernel output messages
+- `IExecuteRequestMsg` / `IExecuteReplyMsg` - Code execution
+- `IDisplayDataMsg` / `IUpdateDisplayDataMsg` - Widget output
+- `ICommOpenMsg` / `ICommCloseMsg` / `ICommMsgMsg` - Widget communication
+- `IIOPubMessage` - Kernel output messages
 
 #### 4. Server Connection and WebSocket Management
 
@@ -1244,19 +1244,19 @@ if (KernelMessage.isCommOpenMsg(msg) || KernelMessage.isCommCloseMsg(msg) || Ker
 import { ServerConnection } from '@jupyterlab/services';
 
 const settings = ServerConnection.makeSettings({
-    WebSocket: ProxyWebSocket as any,
-    wsUrl: 'BOGUS_PVSC',
-    token: '',
-    appUrl: ''
+  WebSocket: ProxyWebSocket as any,
+  wsUrl: 'BOGUS_PVSC',
+  token: '',
+  appUrl: ''
 });
 ```
 
 **Configuration**:
 
--   Custom WebSocket implementation for message bridging
--   Authentication and authorization handling
--   Base URL and endpoint configuration
--   Request/response interceptors
+- Custom WebSocket implementation for message bridging
+- Authentication and authorization handling
+- Base URL and endpoint configuration
+- Request/response interceptors
 
 #### 5. Comm System Integration
 
@@ -1280,10 +1280,10 @@ public async _create_comm(
 
 **Comm Features**:
 
--   Target-based communication channels
--   Bidirectional message passing
--   State synchronization between extension and webview
--   Message queuing and delivery guarantees
+- Target-based communication channels
+- Bidirectional message passing
+- State synchronization between extension and webview
+- Message queuing and delivery guarantees
 
 ### Critical Dependencies
 
@@ -1291,32 +1291,32 @@ The IPyWidgets system depends on these specific @jupyterlab/services modules:
 
 #### Core Kernel Module (`/kernel/**/*.ts`)
 
--   `kernel/default.ts` - `KernelConnection` class
--   `kernel/kernel.ts` - Core interfaces and types
--   `kernel/messages.ts` - Message type definitions
--   `kernel/serialize.ts` - Message serialization utilities
--   `kernel/comm.ts` - Communication channel management
+- `kernel/default.ts` - `KernelConnection` class
+- `kernel/kernel.ts` - Core interfaces and types
+- `kernel/messages.ts` - Message type definitions
+- `kernel/serialize.ts` - Message serialization utilities
+- `kernel/comm.ts` - Communication channel management
 
 #### Session Management (`/session/**/*.ts`)
 
--   `session/session.ts` - Session interface definitions
--   `session/manager.ts` - Session lifecycle management
+- `session/session.ts` - Session interface definitions
+- `session/manager.ts` - Session lifecycle management
 
 #### Server Connection (`/serverconnection.ts`)
 
--   WebSocket configuration and management
--   Authentication and request handling
--   Base URL and endpoint resolution
+- WebSocket configuration and management
+- Authentication and request handling
+- Base URL and endpoint resolution
 
 #### Manager Module (`/manager.ts`)
 
--   Service manager for coordinating kernel and session services
--   Resource lifecycle management
--   Configuration and settings management
+- Service manager for coordinating kernel and session services
+- Resource lifecycle management
+- Configuration and settings management
 
 ## Development Patterns and Best Practices
 
-###  Widget Development Guidelines
+### Widget Development Guidelines
 
 Refer to [anywidget](https://anywidget.dev/en/getting-started/) for widget development guides.
 
@@ -1374,5 +1374,4 @@ def debug_trait_change(change):
 widget.observe(debug_trait_change, names=['count', 'message'])
 ```
 
-
 This comprehensive documentation ensures robust IPyWidgets implementation that maintains compatibility across different environments while providing excellent user experience in VS Code.
diff --git a/api/README.md b/api/README.md
index 4d5f4022f7..817ab2c48b 100644
--- a/api/README.md
+++ b/api/README.md
@@ -20,6 +20,5 @@ See [here](https://code.visualstudio.com/api/references/vscode-api#extensions) f
 import { extensions } from 'vscode';
 import type { JupyterAPI } from '@vscode/jupyter';
 
-const jupyterApi = extensions.getExtension<JupyterAPI>('ms-jupyter.jupyter')?.exports;
+const jupyterApi = extensions.getExtension<JupyterAPI>('Deepnote.vscode-deepnote')?.exports;
 ```
-
diff --git a/build/preDebugWebTest.js b/build/preDebugWebTest.js
index 96d40a8449..bdbe26d672 100644
--- a/build/preDebugWebTest.js
+++ b/build/preDebugWebTest.js
@@ -12,12 +12,12 @@ async function go() {
     if (!url) {
         const info = await startJupyter(true);
         url = info.url;
-        fs.writeFileSync(path.join(__dirname, '..', 'temp', 'jupyter.pid'), info.server.pid.toString());
+        fs.writeFileSync(path.join(__dirname, '..', 'temp', 'deepnote.pid'), info.server.pid.toString());
     } else {
         console.log('Jupyter server URL provided in env args, no need to start one');
     }
     const settingsJson = fs.readFileSync(settingsFile).toString();
-    const edits = jsonc.modify(settingsJson, ['jupyter.DEBUG_JUPYTER_SERVER_URI'], url, {});
+    const edits = jsonc.modify(settingsJson, ['deepnote.DEBUG_JUPYTER_SERVER_URI'], url, {});
     const updatedSettingsJson = jsonc.applyEdits(settingsJson, edits);
     fs.writeFileSync(settingsFile, updatedSettingsJson);
     process.exit(0);
diff --git a/package.json b/package.json
index b0abf6d0db..6349ca93f3 100644
--- a/package.json
+++ b/package.json
@@ -83,7 +83,7 @@
                 "win": "ctrl+enter",
                 "linux": "ctrl+enter",
                 "when": "notebookEditorFocused && !findInputFocussed && !replaceInputFocussed",
-                "command": "jupyter.notebookeditor.runfocusedcell"
+                "command": "deepnote.notebookeditor.runfocusedcell"
             }
         ],
         "commands": [
@@ -280,75 +280,75 @@
             },
             {
                 "command": "dataScience.ClearCache",
-                "title": "%jupyter.command.dataScience.clearCache.title%",
+                "title": "%deepnote.command.dataScience.clearCache.title%",
                 "category": "Jupyter (Dev)",
-                "enablement": "jupyter.development"
+                "enablement": "deepnote.development"
             },
             {
-                "command": "jupyter.manageAccessToKernels",
-                "title": "%jupyter.command.manageAccessToKernels%",
+                "command": "deepnote.manageAccessToKernels",
+                "title": "%deepnote.command.manageAccessToKernels%",
                 "category": "Jupyter"
             },
             {
                 "command": "dataScience.ClearUserProviderJupyterServerCache",
-                "title": "%jupyter.command.dataScience.clearUserProviderJupyterServerCache.title%",
+                "title": "%deepnote.command.dataScience.clearUserProviderJupyterServerCache.title%",
                 "category": "Jupyter (Dev)",
-                "enablement": "jupyter.development"
+                "enablement": "deepnote.development"
             },
             {
-                "command": "jupyter.replayPylanceLog",
-                "title": "%jupyter.command.jupyter.replayPylanceLog.title%",
+                "command": "deepnote.replayPylanceLog",
+                "title": "%deepnote.command.deepnote.replayPylanceLog.title%",
                 "category": "Jupyter (Dev)",
-                "enablement": "jupyter.development && notebookType == jupyter-notebook && isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "deepnote.development && notebookType == jupyter-notebook && isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.replayPylanceLogStep",
-                "title": "%jupyter.command.jupyter.replayPylanceLogStep.title%",
+                "command": "deepnote.replayPylanceLogStep",
+                "title": "%deepnote.command.deepnote.replayPylanceLogStep.title%",
                 "category": "Jupyter (Dev)",
                 "icon": "$(debug-start)",
-                "enablement": "jupyter.development && notebookType == jupyter-notebook && isWorkspaceTrusted && jupyter.replayLogLoaded && !jupyter.webExtension"
+                "enablement": "deepnote.development && notebookType == jupyter-notebook && isWorkspaceTrusted && deepnote.replayLogLoaded && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.filterKernels",
-                "title": "%jupyter.command.jupyter.filterKernels.title%",
+                "command": "deepnote.filterKernels",
+                "title": "%deepnote.command.deepnote.filterKernels.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.runByLine",
-                "title": "%jupyter.command.jupyter.runByLine.title%",
+                "command": "deepnote.runByLine",
+                "title": "%deepnote.command.deepnote.runByLine.title%",
                 "icon": "$(debug-line-by-line)",
                 "category": "Jupyter",
-                "enablement": "notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in jupyter.notebookeditor.debugDocuments || !notebookKernel && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted"
+                "enablement": "notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in deepnote.notebookeditor.debugDocuments || !notebookKernel && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runAndDebugCell",
-                "title": "%jupyter.command.jupyter.debugCell.title%",
+                "command": "deepnote.runAndDebugCell",
+                "title": "%deepnote.command.deepnote.debugCell.title%",
                 "icon": "$(debug-alt-small)",
                 "category": "Jupyter",
-                "enablement": "notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in jupyter.notebookeditor.debugDocuments || !notebookKernel && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted"
+                "enablement": "notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in deepnote.notebookeditor.debugDocuments || !notebookKernel && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runByLineNext",
-                "title": "%jupyter.command.jupyter.runByLineNext.title%",
+                "command": "deepnote.runByLineNext",
+                "title": "%deepnote.command.deepnote.runByLineNext.title%",
                 "icon": "$(debug-line-by-line)",
                 "category": "Jupyter",
-                "enablement": "notebookCellResource in jupyter.notebookeditor.runByLineCells"
+                "enablement": "notebookCellResource in deepnote.notebookeditor.runByLineCells"
             },
             {
-                "command": "jupyter.runByLineStop",
-                "title": "%jupyter.command.jupyter.runByLineStop.title%",
+                "command": "deepnote.runByLineStop",
+                "title": "%deepnote.command.deepnote.runByLineStop.title%",
                 "icon": "$(debug-continue-small)",
                 "category": "Jupyter",
-                "enablement": "notebookCellResource in jupyter.notebookeditor.runByLineCells"
+                "enablement": "notebookCellResource in deepnote.notebookeditor.runByLineCells"
             },
             {
-                "command": "jupyter.viewOutput",
-                "title": "%jupyter.command.jupyter.viewOutput.title%",
+                "command": "deepnote.viewOutput",
+                "title": "%deepnote.command.deepnote.viewOutput.title%",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.notebookeditor.export",
+                "command": "deepnote.notebookeditor.export",
                 "title": "%DataScience.notebookExportAs%",
                 "shortTitle": "%DataScience.notebookExportAs.shorttitle%",
                 "category": "Notebook",
@@ -356,388 +356,388 @@
                     "light": "resources/light/export_to_python.svg",
                     "dark": "resources/dark/export_to_python.svg"
                 },
-                "enablement": "notebookType == jupyter-notebook && isWorkspaceTrusted && !jupyter.webExtension || notebookType == jupyter-notebook && isWorkspaceTrusted && jupyter.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
+                "enablement": "notebookType == jupyter-notebook && isWorkspaceTrusted && !deepnote.webExtension || notebookType == jupyter-notebook && isWorkspaceTrusted && deepnote.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
             },
             {
-                "command": "jupyter.export",
+                "command": "deepnote.export",
                 "title": "%DataScience.notebookExportAs%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension || isWorkspaceTrusted && jupyter.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension || isWorkspaceTrusted && deepnote.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
             },
             {
-                "command": "jupyter.exportAsPythonScript",
-                "title": "%jupyter.command.jupyter.exportAsPythonScript.title%",
+                "command": "deepnote.exportAsPythonScript",
+                "title": "%deepnote.command.deepnote.exportAsPythonScript.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension || isWorkspaceTrusted && jupyter.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension || isWorkspaceTrusted && deepnote.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
             },
             {
-                "command": "jupyter.exportToHTML",
-                "title": "%jupyter.command.jupyter.exportToHTML.title%",
+                "command": "deepnote.exportToHTML",
+                "title": "%deepnote.command.deepnote.exportToHTML.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension || isWorkspaceTrusted && jupyter.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension || isWorkspaceTrusted && deepnote.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
             },
             {
-                "command": "jupyter.exportToPDF",
-                "title": "%jupyter.command.jupyter.exportToPDF.title%",
+                "command": "deepnote.exportToPDF",
+                "title": "%deepnote.command.deepnote.exportToPDF.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension || isWorkspaceTrusted && jupyter.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension || isWorkspaceTrusted && deepnote.webExtension && notebookKernel =~ /^ms-toolsai.jupyter\\//"
             },
             {
-                "command": "jupyter.selectJupyterInterpreter",
-                "title": "%jupyter.command.jupyter.selectJupyterInterpreter.title%",
+                "command": "deepnote.selectJupyterInterpreter",
+                "title": "%deepnote.command.deepnote.selectJupyterInterpreter.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.runcurrentcell",
-                "title": "%jupyter.command.jupyter.runcurrentcell.title%",
+                "command": "deepnote.runcurrentcell",
+                "title": "%deepnote.command.deepnote.runcurrentcell.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugcell",
-                "title": "%jupyter.command.jupyter.debugcell.title%",
+                "command": "deepnote.debugcell",
+                "title": "%deepnote.command.deepnote.debugcell.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugstepover",
-                "title": "%jupyter.command.jupyter.debugstepover.title%",
+                "command": "deepnote.debugstepover",
+                "title": "%deepnote.command.deepnote.debugstepover.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugstop",
-                "title": "%jupyter.command.jupyter.debugstop.title%",
+                "command": "deepnote.debugstop",
+                "title": "%deepnote.command.deepnote.debugstop.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugcontinue",
-                "title": "%jupyter.command.jupyter.debugcontinue.title%",
+                "command": "deepnote.debugcontinue",
+                "title": "%deepnote.command.deepnote.debugcontinue.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.insertCellBelowPosition",
-                "title": "%jupyter.command.jupyter.insertCellBelowPosition.title%",
+                "command": "deepnote.insertCellBelowPosition",
+                "title": "%deepnote.command.deepnote.insertCellBelowPosition.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.insertCellBelow",
-                "title": "%jupyter.command.jupyter.insertCellBelow.title%",
+                "command": "deepnote.insertCellBelow",
+                "title": "%deepnote.command.deepnote.insertCellBelow.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.insertCellAbove",
-                "title": "%jupyter.command.jupyter.insertCellAbove.title%",
+                "command": "deepnote.insertCellAbove",
+                "title": "%deepnote.command.deepnote.insertCellAbove.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.deleteCells",
-                "title": "%jupyter.command.jupyter.deleteCells.title%",
+                "command": "deepnote.deleteCells",
+                "title": "%deepnote.command.deepnote.deleteCells.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.selectCell",
-                "title": "%jupyter.command.jupyter.selectCell.title%",
+                "command": "deepnote.selectCell",
+                "title": "%deepnote.command.deepnote.selectCell.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.selectCellContents",
-                "title": "%jupyter.command.jupyter.selectCellContents.title%",
+                "command": "deepnote.selectCellContents",
+                "title": "%deepnote.command.deepnote.selectCellContents.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.extendSelectionByCellAbove",
-                "title": "%jupyter.command.jupyter.extendSelectionByCellAbove.title%",
+                "command": "deepnote.extendSelectionByCellAbove",
+                "title": "%deepnote.command.deepnote.extendSelectionByCellAbove.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.extendSelectionByCellBelow",
-                "title": "%jupyter.command.jupyter.extendSelectionByCellBelow.title%",
+                "command": "deepnote.extendSelectionByCellBelow",
+                "title": "%deepnote.command.deepnote.extendSelectionByCellBelow.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.moveCellsUp",
-                "title": "%jupyter.command.jupyter.moveCellsUp.title%",
+                "command": "deepnote.moveCellsUp",
+                "title": "%deepnote.command.deepnote.moveCellsUp.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.moveCellsDown",
-                "title": "%jupyter.command.jupyter.moveCellsDown.title%",
+                "command": "deepnote.moveCellsDown",
+                "title": "%deepnote.command.deepnote.moveCellsDown.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.changeCellToMarkdown",
-                "title": "%jupyter.command.jupyter.changeCellToMarkdown.title%",
+                "command": "deepnote.changeCellToMarkdown",
+                "title": "%deepnote.command.deepnote.changeCellToMarkdown.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.changeCellToCode",
-                "title": "%jupyter.command.jupyter.changeCellToCode.title%",
+                "command": "deepnote.changeCellToCode",
+                "title": "%deepnote.command.deepnote.changeCellToCode.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.gotoNextCellInFile",
-                "title": "%jupyter.command.jupyter.gotoNextCellInFile.title%",
+                "command": "deepnote.gotoNextCellInFile",
+                "title": "%deepnote.command.deepnote.gotoNextCellInFile.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.gotoPrevCellInFile",
-                "title": "%jupyter.command.jupyter.gotoPrevCellInFile.title%",
+                "command": "deepnote.gotoPrevCellInFile",
+                "title": "%deepnote.command.deepnote.gotoPrevCellInFile.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.runcurrentcelladvance",
-                "title": "%jupyter.command.jupyter.runcurrentcelladvance.title%",
+                "command": "deepnote.runcurrentcelladvance",
+                "title": "%deepnote.command.deepnote.runcurrentcelladvance.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runcurrentcellandallbelow.palette",
-                "title": "%jupyter.command.jupyter.runcurrentcellandallbelow.palette.title%",
+                "command": "deepnote.runcurrentcellandallbelow.palette",
+                "title": "%deepnote.command.deepnote.runcurrentcellandallbelow.palette.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runallcellsabove.palette",
-                "title": "%jupyter.command.jupyter.runallcellsabove.palette.title%",
+                "command": "deepnote.runallcellsabove.palette",
+                "title": "%deepnote.command.deepnote.runallcellsabove.palette.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugcurrentcell.palette",
-                "title": "%jupyter.command.jupyter.debugcurrentcell.palette.title%",
+                "command": "deepnote.debugcurrentcell.palette",
+                "title": "%deepnote.command.deepnote.debugcurrentcell.palette.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.execSelectionInteractive",
-                "title": "%jupyter.command.jupyter.execSelectionInteractive.title%",
+                "command": "deepnote.execSelectionInteractive",
+                "title": "%deepnote.command.deepnote.execSelectionInteractive.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.createnewinteractive",
-                "title": "%jupyter.command.jupyter.createnewinteractive.title%",
+                "command": "deepnote.createnewinteractive",
+                "title": "%deepnote.command.deepnote.createnewinteractive.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runFileInteractive",
-                "title": "%jupyter.command.jupyter.runFileInteractive.title%",
+                "command": "deepnote.runFileInteractive",
+                "title": "%deepnote.command.deepnote.runFileInteractive.title%",
                 "icon": "$(play)",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.debugFileInteractive",
-                "title": "%jupyter.command.jupyter.debugFileInteractive.title%",
+                "command": "deepnote.debugFileInteractive",
+                "title": "%deepnote.command.deepnote.debugFileInteractive.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.runallcells",
-                "title": "%jupyter.command.jupyter.runallcells.title%",
+                "command": "deepnote.runallcells",
+                "title": "%deepnote.command.deepnote.runallcells.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runallcellsabove",
-                "title": "%jupyter.command.jupyter.runallcellsabove.title%",
+                "command": "deepnote.runallcellsabove",
+                "title": "%deepnote.command.deepnote.runallcellsabove.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runcellandallbelow",
-                "title": "%jupyter.command.jupyter.runcellandallbelow.title%",
+                "command": "deepnote.runcellandallbelow",
+                "title": "%deepnote.command.deepnote.runcellandallbelow.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runcell",
-                "title": "%jupyter.command.jupyter.runcell.title%",
+                "command": "deepnote.runcell",
+                "title": "%deepnote.command.deepnote.runcell.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runtoline",
-                "title": "%jupyter.command.jupyter.runtoline.title%",
+                "command": "deepnote.runtoline",
+                "title": "%deepnote.command.deepnote.runtoline.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.runfromline",
-                "title": "%jupyter.command.jupyter.runfromline.title%",
+                "command": "deepnote.runfromline",
+                "title": "%deepnote.command.deepnote.runfromline.title%",
                 "category": "Jupyter",
                 "enablement": "isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.importnotebookfile",
-                "title": "%jupyter.command.jupyter.importnotebookfile.title%",
+                "command": "deepnote.importnotebookfile",
+                "title": "%deepnote.command.deepnote.importnotebookfile.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.exportfileasnotebook",
-                "title": "%jupyter.command.jupyter.exportfileasnotebook.title%",
+                "command": "deepnote.exportfileasnotebook",
+                "title": "%deepnote.command.deepnote.exportfileasnotebook.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension"
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension"
             },
             {
-                "command": "jupyter.interruptkernel",
-                "title": "%jupyter.command.jupyter.interruptkernel.title%",
-                "shortTitle": "%jupyter.command.jupyter.interruptkernel.shorttitle%",
+                "command": "deepnote.interruptkernel",
+                "title": "%deepnote.command.deepnote.interruptkernel.title%",
+                "shortTitle": "%deepnote.command.deepnote.interruptkernel.shorttitle%",
                 "category": "Jupyter",
                 "icon": {
                     "light": "resources/light/interrupt.svg",
                     "dark": "resources/dark/interrupt.svg"
                 },
-                "enablement": "isWorkspaceTrusted && jupyter.interactive.canInterruptNotebookKernel"
+                "enablement": "isWorkspaceTrusted && deepnote.interactive.canInterruptNotebookKernel"
             },
             {
-                "command": "jupyter.restartkernel",
-                "title": "%jupyter.command.jupyter.restartkernel.title%",
-                "shortTitle": "%jupyter.command.jupyter.restartkernel.shorttitle%",
+                "command": "deepnote.restartkernel",
+                "title": "%deepnote.command.deepnote.restartkernel.title%",
+                "shortTitle": "%deepnote.command.deepnote.restartkernel.shorttitle%",
                 "category": "Jupyter",
                 "icon": {
                     "light": "resources/light/restart-kernel.svg",
                     "dark": "resources/dark/restart-kernel.svg"
                 },
-                "enablement": "isWorkspaceTrusted && (jupyter.interactive.canRestartNotebookKernel || (notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.notebookeditor.canrestartNotebookkernel))"
+                "enablement": "isWorkspaceTrusted && (deepnote.interactive.canRestartNotebookKernel || (notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.notebookeditor.canrestartNotebookkernel))"
             },
             {
-                "command": "jupyter.restartkernelandrunallcells",
-                "title": "%jupyter.command.jupyter.restartkernelandrunallcells.title%",
-                "shortTitle": "%jupyter.command.jupyter.restartkernelandrunallcells.shorttitle%",
+                "command": "deepnote.restartkernelandrunallcells",
+                "title": "%deepnote.command.deepnote.restartkernelandrunallcells.title%",
+                "shortTitle": "%deepnote.command.deepnote.restartkernelandrunallcells.shorttitle%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && (jupyter.interactive.canRestartNotebookKernel || (notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.notebookeditor.canrestartNotebookkernel))"
+                "enablement": "isWorkspaceTrusted && (deepnote.interactive.canRestartNotebookKernel || (notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.notebookeditor.canrestartNotebookkernel))"
             },
             {
-                "command": "jupyter.restartkernelandrunuptoselectedcell",
-                "title": "%jupyter.command.jupyter.restartkernelandrunuptoselectedcell.title%",
-                "shortTitle": "%jupyter.command.jupyter.restartkernelandrunuptoselectedcell.title%",
+                "command": "deepnote.restartkernelandrunuptoselectedcell",
+                "title": "%deepnote.command.deepnote.restartkernelandrunuptoselectedcell.title%",
+                "shortTitle": "%deepnote.command.deepnote.restartkernelandrunuptoselectedcell.title%",
                 "category": "Jupyter",
-                "enablement": "isWorkspaceTrusted && (notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.notebookeditor.canrestartNotebookkernel)"
+                "enablement": "isWorkspaceTrusted && (notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.notebookeditor.canrestartNotebookkernel)"
             },
             {
-                "command": "jupyter.notebookeditor.addcellbelow",
-                "title": "%jupyter.command.jupyter.notebookeditor.addcellbelow.title%",
+                "command": "deepnote.notebookeditor.addcellbelow",
+                "title": "%deepnote.command.deepnote.notebookeditor.addcellbelow.title%",
                 "category": "Notebook",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.notebookeditor.removeallcells",
-                "title": "%jupyter.command.jupyter.notebookeditor.removeallcells.title%",
+                "command": "deepnote.notebookeditor.removeallcells",
+                "title": "%deepnote.command.deepnote.notebookeditor.removeallcells.title%",
                 "category": "Notebook",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.notebookeditor.runfocusedcell",
-                "title": "%jupyter.command.jupyter.notebookeditor.runfocusedcell.title%",
+                "command": "deepnote.notebookeditor.runfocusedcell",
+                "title": "%deepnote.command.deepnote.notebookeditor.runfocusedcell.title%",
                 "category": "Notebook",
                 "enablement": "notebookEditorFocused"
             },
             {
-                "command": "jupyter.expandallcells",
-                "title": "%jupyter.command.jupyter.expandallcells.title%",
-                "shortTitle": "%jupyter.command.jupyter.expandallcells.shorttitle%",
+                "command": "deepnote.expandallcells",
+                "title": "%deepnote.command.deepnote.expandallcells.title%",
+                "shortTitle": "%deepnote.command.deepnote.expandallcells.shorttitle%",
                 "category": "Jupyter",
                 "icon": "$(expand-all)"
             },
             {
-                "command": "jupyter.collapseallcells",
-                "title": "%jupyter.command.jupyter.collapseallcells.title%",
-                "shortTitle": "%jupyter.command.jupyter.collapseallcells.shorttitle%",
+                "command": "deepnote.collapseallcells",
+                "title": "%deepnote.command.deepnote.collapseallcells.title%",
+                "shortTitle": "%deepnote.command.deepnote.collapseallcells.shorttitle%",
                 "category": "Jupyter",
                 "icon": "$(collapse-all)"
             },
             {
-                "command": "jupyter.addcellbelow",
-                "title": "%jupyter.command.jupyter.addcellbelow.title%",
+                "command": "deepnote.addcellbelow",
+                "title": "%deepnote.command.deepnote.addcellbelow.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.createnewnotebook",
-                "title": "%jupyter.command.jupyter.createnewnotebook.title%",
+                "command": "deepnote.createnewnotebook",
+                "title": "%deepnote.command.deepnote.createnewnotebook.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.scrolltocell",
-                "title": "%jupyter.command.jupyter.scrolltocell.title%",
+                "command": "deepnote.scrolltocell",
+                "title": "%deepnote.command.deepnote.scrolltocell.title%",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.latestExtension",
+                "command": "deepnote.latestExtension",
                 "title": "DataScience.latestExtension",
                 "category": "Jupyter",
-                "enablement": "!jupyter.webExtension"
+                "enablement": "!deepnote.webExtension"
             },
             {
-                "command": "jupyter.showDataViewer",
-                "title": "%jupyter.command.jupyter.showDataViewer.title%",
-                "enablement": "!jupyter.webExtension",
+                "command": "deepnote.showDataViewer",
+                "title": "%deepnote.command.deepnote.showDataViewer.title%",
+                "enablement": "!deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.clearSavedJupyterUris",
-                "title": "%jupyter.command.jupyter.clearSavedJupyterUris.title%",
+                "command": "deepnote.clearSavedJupyterUris",
+                "title": "%deepnote.command.deepnote.clearSavedJupyterUris.title%",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.openVariableView",
-                "title": "%jupyter.command.jupyter.openVariableView.title%",
-                "shortTitle": "%jupyter.command.jupyter.openVariableView.shorttitle%",
+                "command": "deepnote.openVariableView",
+                "title": "%deepnote.command.deepnote.openVariableView.title%",
+                "shortTitle": "%deepnote.command.deepnote.openVariableView.shorttitle%",
                 "icon": "$(variable-group)",
                 "category": "Jupyter",
                 "enablement": "notebookType == jupyter-notebook && isWorkspaceTrusted || isCompositeNotebook && isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.openOutlineView",
-                "title": "%jupyter.command.jupyter.openOutlineView.title%",
-                "shortTitle": "%jupyter.command.jupyter.openOutlineView.shorttitle%",
+                "command": "deepnote.openOutlineView",
+                "title": "%deepnote.command.deepnote.openOutlineView.title%",
+                "shortTitle": "%deepnote.command.deepnote.openOutlineView.shorttitle%",
                 "icon": "$(list-unordered)",
                 "category": "Jupyter",
                 "enablement": "notebookType == jupyter-notebook"
             },
             {
-                "command": "jupyter.refreshDataViewer",
+                "command": "deepnote.refreshDataViewer",
                 "title": "%DataScience.refreshDataViewerCommandPalette%",
                 "category": "Jupyter",
-                "enablement": "jupyter.dataViewerActive && isWorkspaceTrusted"
+                "enablement": "deepnote.dataViewerActive && isWorkspaceTrusted"
             },
             {
-                "command": "jupyter.interactive.clearAllCells",
+                "command": "deepnote.interactive.clearAllCells",
                 "title": "%DataScience.interactiveClearAllCells%",
                 "icon": "$(close)",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.interactive.goToCode",
+                "command": "deepnote.interactive.goToCode",
                 "title": "%DataScience.interactiveGoToCode%",
                 "icon": "$(go-to-file)",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.interactive.exportasnotebook",
+                "command": "deepnote.interactive.exportasnotebook",
                 "title": "%DataScience.exportDialogTitle%",
                 "shortTitle": "%DataScience.exportAsNotebook.shorttitle%",
                 "icon": "$(save-as)",
@@ -745,7 +745,7 @@
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.interactive.exportas",
+                "command": "deepnote.interactive.exportas",
                 "title": "%DataScience.notebookExport%",
                 "icon": {
                     "light": "resources/light/export_to_python.svg",
@@ -755,19 +755,19 @@
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.interactive.copyCell",
+                "command": "deepnote.interactive.copyCell",
                 "title": "%DataScience.interactiveCopyCell%",
                 "icon": "$(copy)",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.runInDedicatedExtensionHost",
+                "command": "deepnote.runInDedicatedExtensionHost",
                 "title": "%DataScience.runInDedicatedExtensionHost%",
-                "enablement": "!jupyter.webExtension",
+                "enablement": "!deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.continueEditSessionInCodespace",
+                "command": "deepnote.continueEditSessionInCodespace",
                 "title": "Continue On Codespace",
                 "shortTitle": "Continue On",
                 "icon": "$(vm)",
@@ -775,54 +775,54 @@
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.selectPrecedentCells",
+                "command": "deepnote.selectPrecedentCells",
                 "title": "Select Precedent Cells",
                 "icon": "$(gather)",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.selectDependentCells",
+                "command": "deepnote.selectDependentCells",
                 "title": "Select Dependent Cells",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.runPrecedentCells",
+                "command": "deepnote.runPrecedentCells",
                 "title": "Execute with Precedent Cells",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.runDependentCells",
+                "command": "deepnote.runDependentCells",
                 "title": "Execute with Dependent Cells",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.debugCellSymbols",
+                "command": "deepnote.debugCellSymbols",
                 "title": "Debug Cell Symbols",
                 "icon": "$(debug-alt-small)",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.listPipPackages",
+                "command": "deepnote.listPipPackages",
                 "title": "List Pip Packages",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             },
             {
-                "command": "jupyter.listVariables",
+                "command": "deepnote.listVariables",
                 "title": "List Variables",
-                "enablement": "isWorkspaceTrusted && !jupyter.webExtension",
+                "enablement": "isWorkspaceTrusted && !deepnote.webExtension",
                 "category": "Jupyter"
             }
         ],
         "submenus": [
             {
                 "id": "editor.interactiveWindow.context",
-                "label": "%jupyter.command.editor.interactiveWindow.context.label%"
+                "label": "%deepnote.command.editor.interactiveWindow.context.label%"
             },
             {
                 "id": "deepnote.explorer.context",
@@ -863,8 +863,8 @@
                     "group": "Jupyter2"
                 },
                 {
-                    "when": "editorFocus && editorLangId == python && jupyter.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
-                    "command": "jupyter.exportfileasnotebook",
+                    "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
+                    "command": "deepnote.exportfileasnotebook",
                     "group": "Jupyter3@2"
                 },
                 {
@@ -875,37 +875,37 @@
             ],
             "editor.interactiveWindow.context": [
                 {
-                    "when": "editorFocus && editorLangId == python && jupyter.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
-                    "command": "jupyter.runallcells",
+                    "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
+                    "command": "deepnote.runallcells",
                     "group": "Jupyter2"
                 },
                 {
-                    "when": "editorFocus && editorLangId == python && jupyter.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
-                    "command": "jupyter.runcurrentcell",
+                    "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
+                    "command": "deepnote.runcurrentcell",
                     "group": "Jupyter2"
                 },
                 {
-                    "when": "editorFocus && editorLangId == python && jupyter.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
-                    "command": "jupyter.runcurrentcelladvance",
+                    "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
+                    "command": "deepnote.runcurrentcelladvance",
                     "group": "Jupyter2"
                 },
                 {
-                    "command": "jupyter.runFileInteractive",
+                    "command": "deepnote.runFileInteractive",
                     "group": "Jupyter2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runfromline",
+                    "command": "deepnote.runfromline",
                     "group": "Jupyter2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runtoline",
+                    "command": "deepnote.runtoline",
                     "group": "Jupyter2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.execSelectionInteractive",
+                    "command": "deepnote.execSelectionInteractive",
                     "group": "Jupyter2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 }
@@ -920,33 +920,33 @@
             ],
             "editor/title": [
                 {
-                    "command": "jupyter.restartkernel",
-                    "title": "%jupyter.command.jupyter.restartkernel.title%",
+                    "command": "deepnote.restartkernel",
+                    "title": "%deepnote.command.deepnote.restartkernel.title%",
                     "group": "navigation@1",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && isWorkspaceTrusted && jupyter.notebookeditor.canrestartNotebookkernel && config.notebook.globalToolbar != true"
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && isWorkspaceTrusted && deepnote.notebookeditor.canrestartNotebookkernel && config.notebook.globalToolbar != true"
                 },
                 {
-                    "command": "jupyter.openVariableView",
-                    "title": "%jupyter.command.jupyter.openVariableView.title%",
+                    "command": "deepnote.openVariableView",
+                    "title": "%deepnote.command.deepnote.openVariableView.title%",
                     "group": "navigation@2",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && isWorkspaceTrusted && config.notebook.globalToolbar != true && jupyter.ispythonnotebook"
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && isWorkspaceTrusted && config.notebook.globalToolbar != true && deepnote.ispythonnotebook"
                 },
                 {
-                    "command": "jupyter.openOutlineView",
-                    "title": "%jupyter.command.jupyter.openOutlineView.title%",
+                    "command": "deepnote.openOutlineView",
+                    "title": "%deepnote.command.deepnote.openOutlineView.title%",
                     "group": "navigation@3",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && config.jupyter.showOutlineButtonInNotebookToolbar && config.notebook.globalToolbar != true"
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && config.deepnote.showOutlineButtonInNotebookToolbar && config.notebook.globalToolbar != true"
                 },
                 {
-                    "command": "jupyter.notebookeditor.export",
+                    "command": "deepnote.notebookeditor.export",
                     "title": "%DataScience.notebookExportAs%",
                     "group": "navigation@4",
                     "when": "notebookType == 'jupyter-notebook' && isWorkspaceTrusted && config.notebook.globalToolbar != true"
                 },
                 {
-                    "command": "jupyter.continueEditSessionInCodespace",
+                    "command": "deepnote.continueEditSessionInCodespace",
                     "group": "navigation@5",
-                    "when": "notebookType == 'jupyter-notebook' && jupyter.kernelSource == 'github-codespaces' && config.notebook.globalToolbar != true"
+                    "when": "notebookType == 'jupyter-notebook' && deepnote.kernelSource == 'github-codespaces' && config.notebook.globalToolbar != true"
                 }
             ],
             "notebook/toolbar": [
@@ -1021,130 +1021,130 @@
                     "when": "notebookType == 'deepnote'"
                 },
                 {
-                    "command": "jupyter.restartkernel",
+                    "command": "deepnote.restartkernel",
                     "group": "navigation/execute@5",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && jupyter.kernel.isjupyter"
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && deepnote.kernel.isjupyter"
                 },
                 {
-                    "command": "jupyter.openVariableView",
+                    "command": "deepnote.openVariableView",
                     "group": "navigation@1",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && jupyter.ispythonnotebook && jupyter.kernel.isjupyter"
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && deepnote.ispythonnotebook && deepnote.kernel.isjupyter"
                 },
                 {
-                    "command": "jupyter.openOutlineView",
+                    "command": "deepnote.openOutlineView",
                     "group": "navigation@2",
-                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && config.jupyter.showOutlineButtonInNotebookToolbar"
+                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && config.deepnote.showOutlineButtonInNotebookToolbar"
                 },
                 {
-                    "command": "jupyter.continueEditSessionInCodespace",
+                    "command": "deepnote.continueEditSessionInCodespace",
                     "group": "navigation@3",
-                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && jupyter.kernelSource == 'github-codespaces'"
+                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && deepnote.kernelSource == 'github-codespaces'"
                 },
                 {
-                    "command": "jupyter.notebookeditor.export",
+                    "command": "deepnote.notebookeditor.export",
                     "group": "Jupyter",
                     "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.replayPylanceLogStep",
+                    "command": "deepnote.replayPylanceLogStep",
                     "group": "navigation@1",
-                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && jupyter.replayLogLoaded"
+                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && deepnote.replayLogLoaded"
                 }
             ],
             "notebook/cell/title": [
                 {
-                    "command": "jupyter.runByLine",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == jupyter-notebook && notebookType != deepnote && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in jupyter.notebookeditor.runByLineDocuments || !notebookKernel && notebookType == jupyter-notebook && notebookType != deepnote && jupyter.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted",
+                    "command": "deepnote.runByLine",
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && notebookType == jupyter-notebook && notebookType != deepnote && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted && resource not in deepnote.notebookeditor.runByLineDocuments || !notebookKernel && notebookType == jupyter-notebook && notebookType != deepnote && deepnote.ispythonnotebook && notebookCellType == code && isWorkspaceTrusted",
                     "group": "inline/cell@0"
                 },
                 {
-                    "command": "jupyter.runByLineNext",
-                    "when": "notebookCellResource in jupyter.notebookeditor.runByLineCells && notebookType != deepnote",
+                    "command": "deepnote.runByLineNext",
+                    "when": "notebookCellResource in deepnote.notebookeditor.runByLineCells && notebookType != deepnote",
                     "group": "inline/cell@0"
                 },
                 {
-                    "command": "jupyter.runByLineStop",
-                    "when": "notebookCellResource in jupyter.notebookeditor.runByLineCells && notebookType != deepnote && notebookCellToolbarLocation == left",
+                    "command": "deepnote.runByLineStop",
+                    "when": "notebookCellResource in deepnote.notebookeditor.runByLineCells && notebookType != deepnote && notebookCellToolbarLocation == left",
                     "group": "inline/cell@1"
                 },
                 {
-                    "command": "jupyter.runByLineStop",
-                    "when": "notebookCellResource in jupyter.notebookeditor.runByLineCells && notebookType != deepnote && notebookCellToolbarLocation == right",
+                    "command": "deepnote.runByLineStop",
+                    "when": "notebookCellResource in deepnote.notebookeditor.runByLineCells && notebookType != deepnote && notebookCellToolbarLocation == right",
                     "group": "inline/cell@0"
                 },
                 {
-                    "command": "jupyter.selectPrecedentCells",
-                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && config.jupyter.executionAnalysis.enabled",
+                    "command": "deepnote.selectPrecedentCells",
+                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && config.deepnote.executionAnalysis.enabled",
                     "group": "executionAnalysis@0"
                 },
                 {
-                    "command": "jupyter.selectDependentCells",
-                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && config.jupyter.executionAnalysis.enabled",
+                    "command": "deepnote.selectDependentCells",
+                    "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted && config.deepnote.executionAnalysis.enabled",
                     "group": "executionAnalysis@1"
                 }
             ],
             "notebook/cell/execute": [
                 {
-                    "command": "jupyter.runAndDebugCell",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && resource not in jupyter.notebookeditor.debugDocuments || !notebookKernel && jupyter.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted",
+                    "command": "deepnote.runAndDebugCell",
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && resource not in deepnote.notebookeditor.debugDocuments || !notebookKernel && deepnote.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted",
                     "group": "jupyterCellExecute@0"
                 },
                 {
-                    "command": "jupyter.runPrecedentCells",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && config.jupyter.executionAnalysis.enabled",
+                    "command": "deepnote.runPrecedentCells",
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && config.deepnote.executionAnalysis.enabled",
                     "group": "jupyterCellExecute@1"
                 },
                 {
-                    "command": "jupyter.runDependentCells",
-                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && jupyter.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && config.jupyter.executionAnalysis.enabled",
+                    "command": "deepnote.runDependentCells",
+                    "when": "notebookKernel =~ /^ms-toolsai.jupyter\\// && deepnote.ispythonnotebook && notebookType != deepnote && notebookCellType == code && isWorkspaceTrusted && config.deepnote.executionAnalysis.enabled",
                     "group": "jupyterCellExecute@2"
                 }
             ],
             "interactive/toolbar": [
                 {
-                    "command": "jupyter.interactive.clearAllCells",
+                    "command": "deepnote.interactive.clearAllCells",
                     "group": "navigation@0",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.restartkernel",
+                    "command": "deepnote.restartkernel",
                     "group": "navigation@1",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.openVariableView",
+                    "command": "deepnote.openVariableView",
                     "group": "navigation@3",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.interactive.exportasnotebook",
+                    "command": "deepnote.interactive.exportasnotebook",
                     "group": "navigation@4",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.interactive.exportas",
+                    "command": "deepnote.interactive.exportas",
                     "group": "navigation@5",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.expandallcells",
+                    "command": "deepnote.expandallcells",
                     "group": "navigation@6",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.collapseallcells",
+                    "command": "deepnote.collapseallcells",
                     "group": "navigation@7",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 }
             ],
             "interactive/cell/title": [
                 {
-                    "command": "jupyter.interactive.copyCell",
+                    "command": "deepnote.interactive.copyCell",
                     "group": "inline@0",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 },
                 {
-                    "command": "jupyter.interactive.goToCode",
+                    "command": "deepnote.interactive.goToCode",
                     "group": "inline@1",
                     "when": "isWorkspaceTrusted && notebookKernel =~ /^ms-toolsai.jupyter\\// || isWorkspaceTrusted && !notebookKernel"
                 }
@@ -1157,390 +1157,390 @@
                 },
                 {
                     "when": "resourceLangId == python && !notebookEditorFocused && isWorkspaceTrusted",
-                    "command": "jupyter.runFileInteractive",
+                    "command": "deepnote.runFileInteractive",
                     "group": "Jupyter2"
                 },
                 {
                     "when": "resourceExtname == .ipynb && isWorkspaceTrusted",
-                    "command": "jupyter.importnotebookfile",
+                    "command": "deepnote.importnotebookfile",
                     "group": "Jupyter"
                 }
             ],
             "commandPalette": [
                 {
-                    "command": "jupyter.replayPylanceLog",
-                    "title": "%jupyter.commandPalette.jupyter.replayPylanceLog.title%",
-                    "when": "jupyter.development && isWorkspaceTrusted"
+                    "command": "deepnote.replayPylanceLog",
+                    "title": "%deepnote.commandPalette.deepnote.replayPylanceLog.title%",
+                    "when": "deepnote.development && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.manageAccessToKernels",
-                    "title": "%jupyter.command.manageAccessToKernels%"
+                    "command": "deepnote.manageAccessToKernels",
+                    "title": "%deepnote.command.manageAccessToKernels%"
                 },
                 {
-                    "command": "jupyter.interactive.copyCell",
+                    "command": "deepnote.interactive.copyCell",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.exportAsPythonScript",
-                    "title": "%jupyter.command.jupyter.exportAsPythonScript.title%",
+                    "command": "deepnote.exportAsPythonScript",
+                    "title": "%deepnote.command.deepnote.exportAsPythonScript.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.isnativeactive && isWorkspaceTrusted && jupyter.ispythonnotebook && isWorkspaceTrusted"
+                    "when": "deepnote.isnativeactive && isWorkspaceTrusted && deepnote.ispythonnotebook && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.refreshDataViewer",
+                    "command": "deepnote.refreshDataViewer",
                     "category": "Jupyter",
                     "when": "isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.exportToHTML",
-                    "title": "%jupyter.command.jupyter.exportToHTML.title%",
+                    "command": "deepnote.exportToHTML",
+                    "title": "%deepnote.command.deepnote.exportToHTML.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.isnativeactive && isWorkspaceTrusted"
+                    "when": "deepnote.isnativeactive && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.exportToPDF",
-                    "title": "%jupyter.command.jupyter.exportToPDF.title%",
+                    "command": "deepnote.exportToPDF",
+                    "title": "%deepnote.command.deepnote.exportToPDF.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.isnativeactive && isWorkspaceTrusted"
+                    "when": "deepnote.isnativeactive && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.insertCellBelowPosition",
-                    "title": "%jupyter.command.jupyter.insertCellBelowPosition.title%",
+                    "command": "deepnote.insertCellBelowPosition",
+                    "title": "%deepnote.command.deepnote.insertCellBelowPosition.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.insertCellBelow",
-                    "title": "%jupyter.command.jupyter.insertCellBelow.title%",
+                    "command": "deepnote.insertCellBelow",
+                    "title": "%deepnote.command.deepnote.insertCellBelow.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.insertCellAbove",
-                    "title": "%jupyter.command.jupyter.insertCellAbove.title%",
+                    "command": "deepnote.insertCellAbove",
+                    "title": "%deepnote.command.deepnote.insertCellAbove.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.deleteCells",
-                    "title": "%jupyter.command.jupyter.deleteCells.title%",
+                    "command": "deepnote.deleteCells",
+                    "title": "%deepnote.command.deepnote.deleteCells.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.selectCell",
-                    "title": "%jupyter.command.jupyter.selectCell.title%",
+                    "command": "deepnote.selectCell",
+                    "title": "%deepnote.command.deepnote.selectCell.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.selectCellContents",
-                    "title": "%jupyter.command.jupyter.selectCellContents.title%",
+                    "command": "deepnote.selectCellContents",
+                    "title": "%deepnote.command.deepnote.selectCellContents.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.extendSelectionByCellAbove",
-                    "title": "%jupyter.command.jupyter.extendSelectionByCellAbove.title%",
+                    "command": "deepnote.extendSelectionByCellAbove",
+                    "title": "%deepnote.command.deepnote.extendSelectionByCellAbove.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.extendSelectionByCellBelow",
-                    "title": "%jupyter.command.jupyter.extendSelectionByCellBelow.title%",
+                    "command": "deepnote.extendSelectionByCellBelow",
+                    "title": "%deepnote.command.deepnote.extendSelectionByCellBelow.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.moveCellsUp",
-                    "title": "%jupyter.command.jupyter.moveCellsUp.title%",
+                    "command": "deepnote.moveCellsUp",
+                    "title": "%deepnote.command.deepnote.moveCellsUp.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.moveCellsDown",
-                    "title": "%jupyter.command.jupyter.moveCellsDown.title%",
+                    "command": "deepnote.moveCellsDown",
+                    "title": "%deepnote.command.deepnote.moveCellsDown.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.changeCellToMarkdown",
-                    "title": "%jupyter.command.jupyter.changeCellToMarkdown.title%",
+                    "command": "deepnote.changeCellToMarkdown",
+                    "title": "%deepnote.command.deepnote.changeCellToMarkdown.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.changeCellToCode",
-                    "title": "%jupyter.command.jupyter.changeCellToCode.title%",
+                    "command": "deepnote.changeCellToCode",
+                    "title": "%deepnote.command.deepnote.changeCellToCode.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.gotoNextCellInFile",
-                    "title": "%jupyter.command.jupyter.gotoNextCellInFile.title%",
+                    "command": "deepnote.gotoNextCellInFile",
+                    "title": "%deepnote.command.deepnote.gotoNextCellInFile.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.gotoPrevCellInFile",
-                    "title": "%jupyter.command.jupyter.gotoPrevCellInFile.title%",
+                    "command": "deepnote.gotoPrevCellInFile",
+                    "title": "%deepnote.command.deepnote.gotoPrevCellInFile.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && !notebookEditorFocused"
+                    "when": "deepnote.hascodecells && !notebookEditorFocused"
                 },
                 {
-                    "command": "jupyter.runcurrentcell",
-                    "title": "%jupyter.command.jupyter.runcurrentcell.title%",
+                    "command": "deepnote.runcurrentcell",
+                    "title": "%deepnote.command.deepnote.runcurrentcell.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive && !jupyter.havenativecells && isWorkspaceTrusted"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive && !deepnote.havenativecells && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runcurrentcelladvance",
-                    "title": "%jupyter.command.jupyter.runcurrentcelladvance.title%",
+                    "command": "deepnote.runcurrentcelladvance",
+                    "title": "%deepnote.command.deepnote.runcurrentcelladvance.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive && !jupyter.havenativecells && isWorkspaceTrusted"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive && !deepnote.havenativecells && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runcurrentcellandallbelow.palette",
-                    "title": "%jupyter.command.jupyter.runcurrentcellandallbelow.palette.title%",
+                    "command": "deepnote.runcurrentcellandallbelow.palette",
+                    "title": "%deepnote.command.deepnote.runcurrentcellandallbelow.palette.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive && !jupyter.havenativecells && isWorkspaceTrusted"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive && !deepnote.havenativecells && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runallcellsabove.palette",
-                    "title": "%jupyter.command.jupyter.runallcellsabove.palette.title%",
+                    "command": "deepnote.runallcellsabove.palette",
+                    "title": "%deepnote.command.deepnote.runallcellsabove.palette.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive && !jupyter.havenativecells && isWorkspaceTrusted"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive && !deepnote.havenativecells && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.debugcurrentcell.palette",
-                    "title": "%jupyter.command.jupyter.debugcurrentcell.palette.title%",
+                    "command": "deepnote.debugcurrentcell.palette",
+                    "title": "%deepnote.command.deepnote.debugcurrentcell.palette.title%",
                     "category": "Jupyter",
-                    "when": "editorLangId == python && jupyter.hascodecells && isWorkspaceTrusted"
+                    "when": "editorLangId == python && deepnote.hascodecells && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.createnewinteractive",
-                    "title": "%jupyter.command.jupyter.createnewinteractive.title%",
+                    "command": "deepnote.createnewinteractive",
+                    "title": "%deepnote.command.deepnote.createnewinteractive.title%",
                     "category": "Jupyter",
                     "when": "isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.runallcells",
-                    "title": "%jupyter.command.jupyter.runallcells.title%",
+                    "command": "deepnote.runallcells",
+                    "title": "%deepnote.command.deepnote.runallcells.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive && isWorkspaceTrusted"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.scrolltocell",
-                    "title": "%jupyter.command.jupyter.scrolltocell.title%",
+                    "command": "deepnote.scrolltocell",
+                    "title": "%deepnote.command.deepnote.scrolltocell.title%",
                     "category": "Jupyter",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.debugcell",
-                    "title": "%jupyter.command.jupyter.debugcell.title%",
+                    "command": "deepnote.debugcell",
+                    "title": "%deepnote.command.deepnote.debugcell.title%",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.runcell",
-                    "title": "%jupyter.command.jupyter.runcell.title%",
+                    "command": "deepnote.runcell",
+                    "title": "%deepnote.command.deepnote.runcell.title%",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.runFileInteractive",
-                    "title": "%jupyter.command.jupyter.runFileInteractive.title%",
+                    "command": "deepnote.runFileInteractive",
+                    "title": "%deepnote.command.deepnote.runFileInteractive.title%",
                     "category": "Jupyter",
                     "when": "editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.debugFileInteractive",
-                    "title": "%jupyter.command.jupyter.debugFileInteractive.title%",
+                    "command": "deepnote.debugFileInteractive",
+                    "title": "%deepnote.command.deepnote.debugFileInteractive.title%",
                     "category": "Jupyter",
                     "when": "editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.exportfileasnotebook",
-                    "title": "%jupyter.command.jupyter.exportfileasnotebook.title%",
+                    "command": "deepnote.exportfileasnotebook",
+                    "title": "%deepnote.command.deepnote.exportfileasnotebook.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.ispythonorinteractiveeactive && !notebookEditorFocused && isWorkspaceTrusted"
+                    "when": "deepnote.ispythonorinteractiveeactive && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.restartkernel",
-                    "title": "%jupyter.command.jupyter.restartkernel.title%",
+                    "command": "deepnote.restartkernel",
+                    "title": "%deepnote.command.deepnote.restartkernel.title%",
                     "category": "Jupyter",
-                    "when": "(jupyter.ispythonorinteractiveeactive || jupyter.isnativeactive) && isWorkspaceTrusted"
+                    "when": "(deepnote.ispythonorinteractiveeactive || deepnote.isnativeactive) && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.notebookeditor.removeallcells",
-                    "title": "%jupyter.command.jupyter.notebookeditor.removeallcells.title%",
+                    "command": "deepnote.notebookeditor.removeallcells",
+                    "title": "%deepnote.command.deepnote.notebookeditor.removeallcells.title%",
                     "category": "Notebook",
-                    "when": "jupyter.havenativecells && jupyter.isnativeactive && isWorkspaceTrusted"
+                    "when": "deepnote.havenativecells && deepnote.isnativeactive && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.notebookeditor.addcellbelow",
-                    "title": "%jupyter.command.jupyter.notebookeditor.addcellbelow.title%",
+                    "command": "deepnote.notebookeditor.addcellbelow",
+                    "title": "%deepnote.command.deepnote.notebookeditor.addcellbelow.title%",
                     "category": "Notebook",
-                    "when": "jupyter.isnativeactive && isWorkspaceTrusted"
+                    "when": "deepnote.isnativeactive && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.expandallcells",
-                    "title": "%jupyter.command.jupyter.expandallcells.title%",
-                    "shortTitle": "%jupyter.command.jupyter.expandallcells.shorttitle%",
+                    "command": "deepnote.expandallcells",
+                    "title": "%deepnote.command.deepnote.expandallcells.title%",
+                    "shortTitle": "%deepnote.command.deepnote.expandallcells.shorttitle%",
                     "category": "Jupyter",
-                    "when": "jupyter.isinteractiveactive"
+                    "when": "deepnote.isinteractiveactive"
                 },
                 {
-                    "command": "jupyter.collapseallcells",
-                    "title": "%jupyter.command.jupyter.collapseallcells.title%",
-                    "shortTitle": "%jupyter.command.jupyter.collapseallcells.shorttitle%",
+                    "command": "deepnote.collapseallcells",
+                    "title": "%deepnote.command.deepnote.collapseallcells.title%",
+                    "shortTitle": "%deepnote.command.deepnote.collapseallcells.shorttitle%",
                     "category": "Jupyter",
-                    "when": "jupyter.isinteractiveactive"
+                    "when": "deepnote.isinteractiveactive"
                 },
                 {
-                    "command": "jupyter.runcellandallbelow",
+                    "command": "deepnote.runcellandallbelow",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.runallcellsabove",
+                    "command": "deepnote.runallcellsabove",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.debugcontinue",
+                    "command": "deepnote.debugcontinue",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.debugstop",
+                    "command": "deepnote.debugstop",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.debugstepover",
+                    "command": "deepnote.debugstepover",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.debugcell",
+                    "command": "deepnote.debugcell",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.addcellbelow",
-                    "title": "%jupyter.command.jupyter.addcellbelow.title%",
+                    "command": "deepnote.addcellbelow",
+                    "title": "%deepnote.command.deepnote.addcellbelow.title%",
                     "category": "Jupyter",
-                    "when": "jupyter.hascodecells && jupyter.ispythonornativeactive"
+                    "when": "deepnote.hascodecells && deepnote.ispythonornativeactive"
                 },
                 {
-                    "command": "jupyter.createnewnotebook",
+                    "command": "deepnote.createnewnotebook",
                     "category": "Jupyter",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.runtoline",
+                    "command": "deepnote.runtoline",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.runfromline",
+                    "command": "deepnote.runfromline",
                     "category": "Jupyter",
                     "when": "config.noExists"
                 },
                 {
-                    "command": "jupyter.execSelectionInteractive",
+                    "command": "deepnote.execSelectionInteractive",
                     "category": "Jupyter",
                     "when": "editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.latestExtension",
+                    "command": "deepnote.latestExtension",
                     "title": "%DataScience.latestExtension%",
                     "category": "Jupyter",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.export",
+                    "command": "deepnote.export",
                     "title": "%DataScience.notebookExportAs%",
                     "category": "Jupyter",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.notebookeditor.export",
+                    "command": "deepnote.notebookeditor.export",
                     "title": "%DataScience.notebookExportAs%",
                     "category": "Notebook",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.showDataViewer",
+                    "command": "deepnote.showDataViewer",
                     "category": "Jupyter",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.openVariableView",
-                    "title": "%jupyter.command.jupyter.openVariableView.title%",
+                    "command": "deepnote.openVariableView",
+                    "title": "%deepnote.command.deepnote.openVariableView.title%",
                     "category": "Jupyter",
                     "when": "notebookType == jupyter-notebook && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.openOutlineView",
-                    "title": "%jupyter.command.jupyter.openOutlineView.title%",
+                    "command": "deepnote.openOutlineView",
+                    "title": "%deepnote.command.deepnote.openOutlineView.title%",
                     "category": "Jupyter",
                     "when": "notebookType == jupyter-notebook && isWorkspaceTrusted"
                 },
                 {
-                    "command": "jupyter.interactive.goToCode",
+                    "command": "deepnote.interactive.goToCode",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.interactive.clearAllCells",
+                    "command": "deepnote.interactive.clearAllCells",
                     "when": "editorFocus && editorLangId == python || activeEditor == 'workbench.editor.interactive'"
                 },
                 {
-                    "command": "jupyter.clearSavedJupyterUris",
-                    "title": "%jupyter.command.jupyter.clearSavedJupyterUris.title%"
+                    "command": "deepnote.clearSavedJupyterUris",
+                    "title": "%deepnote.command.deepnote.clearSavedJupyterUris.title%"
                 },
                 {
-                    "command": "jupyter.selectPrecedentCells",
-                    "when": "config.jupyter.executionAnalysis.enabled"
+                    "command": "deepnote.selectPrecedentCells",
+                    "when": "config.deepnote.executionAnalysis.enabled"
                 },
                 {
-                    "command": "jupyter.selectDependentCells",
-                    "when": "config.jupyter.executionAnalysis.enabled"
+                    "command": "deepnote.selectDependentCells",
+                    "when": "config.deepnote.executionAnalysis.enabled"
                 },
                 {
-                    "command": "jupyter.runPrecedentCells",
-                    "when": "config.jupyter.executionAnalysis.enabled"
+                    "command": "deepnote.runPrecedentCells",
+                    "when": "config.deepnote.executionAnalysis.enabled"
                 },
                 {
-                    "command": "jupyter.runDependentCells",
-                    "when": "config.jupyter.executionAnalysis.enabled"
+                    "command": "deepnote.runDependentCells",
+                    "when": "config.deepnote.executionAnalysis.enabled"
                 },
                 {
-                    "command": "jupyter.debugCellSymbols",
-                    "when": "config.jupyter.executionAnalysis.enabled"
+                    "command": "deepnote.debugCellSymbols",
+                    "when": "config.deepnote.executionAnalysis.enabled"
                 },
                 {
-                    "command": "jupyter.listPipPackages",
+                    "command": "deepnote.listPipPackages",
                     "when": "false"
                 },
                 {
-                    "command": "jupyter.listVariables",
+                    "command": "deepnote.listVariables",
                     "when": "false"
                 }
             ],
             "debug/variables/context": [
                 {
-                    "command": "jupyter.showDataViewer",
+                    "command": "deepnote.showDataViewer",
                     "group": "1_view",
                     "when": "debugProtocolVariableMenuContext == 'viewableInDataViewer'"
                 }
             ],
             "editor/title/run": [
                 {
-                    "command": "jupyter.runFileInteractive",
+                    "command": "deepnote.runFileInteractive",
                     "group": "jupyter",
-                    "title": "%jupyter.command.jupyter.runFileInteractive.title%",
+                    "title": "%deepnote.command.deepnote.runFileInteractive.title%",
                     "when": "resourceLangId == python && !isInDiffEditor && isWorkspaceTrusted"
                 }
             ],
@@ -1613,19 +1613,19 @@
                     "description": "Disable SSL certificate verification (for development only)",
                     "scope": "application"
                 },
-                "jupyter.experiments.enabled": {
+                "deepnote.experiments.enabled": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.experiments.enabled.description%",
+                    "description": "%deepnote.configuration.deepnote.experiments.enabled.description%",
                     "scope": "machine"
                 },
-                "jupyter.showVariableViewWhenDebugging": {
+                "deepnote.showVariableViewWhenDebugging": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.showVariableViewWhenDebugging.description%",
+                    "description": "%deepnote.configuration.deepnote.showVariableViewWhenDebugging.description%",
                     "scope": "resource"
                 },
-                "jupyter.logging.level": {
+                "deepnote.logging.level": {
                     "type": "string",
                     "default": "info",
                     "enum": [
@@ -1637,16 +1637,16 @@
                         "trace"
                     ],
                     "enumDescriptions": [
-                        "%jupyter.configuration.jupyter.logging.level.off%",
-                        "%jupyter.configuration.jupyter.logging.level.error%",
-                        "%jupyter.configuration.jupyter.logging.level.warn%",
-                        "%jupyter.configuration.jupyter.logging.level.info%",
-                        "%jupyter.configuration.jupyter.logging.level.debug%",
-                        "%jupyter.configuration.jupyter.logging.level.trace%"
+                        "%deepnote.configuration.deepnote.logging.level.off%",
+                        "%deepnote.configuration.deepnote.logging.level.error%",
+                        "%deepnote.configuration.deepnote.logging.level.warn%",
+                        "%deepnote.configuration.deepnote.logging.level.info%",
+                        "%deepnote.configuration.deepnote.logging.level.debug%",
+                        "%deepnote.configuration.deepnote.logging.level.trace%"
                     ],
-                    "description": "%jupyter.configuration.jupyter.logging.level.description%"
+                    "description": "%deepnote.configuration.deepnote.logging.level.description%"
                 },
-                "jupyter.experiments.optInto": {
+                "deepnote.experiments.optInto": {
                     "type": "array",
                     "default": [],
                     "items": {
@@ -1654,10 +1654,10 @@
                             "DoNotWaitForZmqPortsToBeUsed"
                         ]
                     },
-                    "markdownDescription": "%jupyter.configuration.jupyter.experiments.optInto.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.experiments.optInto.markdownDescription%",
                     "scope": "application"
                 },
-                "jupyter.experiments.optOutFrom": {
+                "deepnote.experiments.optOutFrom": {
                     "type": "array",
                     "default": [],
                     "items": {
@@ -1665,10 +1665,10 @@
                             "DoNotWaitForZmqPortsToBeUsed"
                         ]
                     },
-                    "markdownDescription": "%jupyter.configuration.jupyter.experiments.optOutFrom.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.experiments.optOutFrom.markdownDescription%",
                     "scope": "application"
                 },
-                "jupyter.widgetScriptSources": {
+                "deepnote.widgetScriptSources": {
                     "type": "array",
                     "default": [],
                     "items": {
@@ -1676,121 +1676,121 @@
                             {
                                 "type": "string",
                                 "const": "jsdelivr.com",
-                                "description": "%jupyter.configuration.jupyter.widgetScriptSources.items.enumDescriptions.0%"
+                                "description": "%deepnote.configuration.deepnote.widgetScriptSources.items.enumDescriptions.0%"
                             },
                             {
                                 "type": "string",
                                 "const": "unpkg.com",
-                                "description": "%jupyter.configuration.jupyter.widgetScriptSources.items.enumDescriptions.1%"
+                                "description": "%deepnote.configuration.deepnote.widgetScriptSources.items.enumDescriptions.1%"
                             },
                             {
                                 "type": "string",
-                                "description": "%jupyter.configuration.jupyter.widgetScriptSources.items.custom%",
+                                "description": "%deepnote.configuration.deepnote.widgetScriptSources.items.custom%",
                                 "format": "uri"
                             }
                         ]
                     },
                     "uniqueItems": true,
-                    "markdownDescription": "%jupyter.configuration.jupyter.widgetScriptSources.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.widgetScriptSources.markdownDescription%",
                     "scope": "resource"
                 },
-                "jupyter.askForLargeDataFrames": {
+                "deepnote.askForLargeDataFrames": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.askForLargeDataFrames.description%",
+                    "description": "%deepnote.configuration.deepnote.askForLargeDataFrames.description%",
                     "scope": "application"
                 },
-                "jupyter.askForKernelRestart": {
+                "deepnote.askForKernelRestart": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.askForKernelRestart.description%"
+                    "description": "%deepnote.configuration.deepnote.askForKernelRestart.description%"
                 },
-                "jupyter.exportWithOutputEnabled": {
+                "deepnote.exportWithOutputEnabled": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.exportWithOutputEnabled.description%",
+                    "description": "%deepnote.configuration.deepnote.exportWithOutputEnabled.description%",
                     "scope": "resource"
                 },
-                "jupyter.jupyterLaunchTimeout": {
+                "deepnote.jupyterLaunchTimeout": {
                     "type": "number",
                     "default": 60000,
-                    "description": "%jupyter.configuration.jupyter.jupyterLaunchTimeout.description%"
+                    "description": "%deepnote.configuration.deepnote.jupyterLaunchTimeout.description%"
                 },
-                "jupyter.jupyterLaunchRetries": {
+                "deepnote.jupyterLaunchRetries": {
                     "type": "number",
                     "default": 3,
-                    "description": "%jupyter.configuration.jupyter.jupyterLaunchRetries.description%"
+                    "description": "%deepnote.configuration.deepnote.jupyterLaunchRetries.description%"
                 },
-                "jupyter.jupyterCommandLineArguments": {
+                "deepnote.jupyterCommandLineArguments": {
                     "type": "array",
                     "default": [],
-                    "description": "%jupyter.configuration.jupyter.jupyterCommandLineArguments.description%",
+                    "description": "%deepnote.configuration.deepnote.jupyterCommandLineArguments.description%",
                     "scope": "resource"
                 },
-                "jupyter.notebookFileRoot": {
+                "deepnote.notebookFileRoot": {
                     "type": "string",
                     "default": "${fileDirname}",
-                    "markdownDescription": "%jupyter.configuration.jupyter.notebookFileRoot.description%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.notebookFileRoot.description%",
                     "scope": "resource"
                 },
-                "jupyter.useDefaultConfigForJupyter": {
+                "deepnote.useDefaultConfigForJupyter": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.useDefaultConfigForJupyter.description%"
+                    "description": "%deepnote.configuration.deepnote.useDefaultConfigFordeepnote.description%"
                 },
-                "jupyter.jupyterInterruptTimeout": {
+                "deepnote.jupyterInterruptTimeout": {
                     "type": "number",
                     "default": 10000,
-                    "description": "%jupyter.configuration.jupyter.jupyterInterruptTimeout.description%"
+                    "description": "%deepnote.configuration.deepnote.jupyterInterruptTimeout.description%"
                 },
-                "jupyter.interactiveWindow.textEditor.executeSelection": {
+                "deepnote.interactiveWindow.textEditor.executeSelection": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.sendSelectionToInteractiveWindow.description%",
+                    "description": "%deepnote.configuration.deepnote.sendSelectionToInteractiveWindow.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.textEditor.normalizeSelection": {
+                "deepnote.interactiveWindow.textEditor.normalizeSelection": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.normalizeSelectionForInteractiveWindow.description%",
+                    "description": "%deepnote.configuration.deepnote.normalizeSelectionForInteractiveWindow.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.splitRunFileIntoCells": {
+                "deepnote.interactiveWindow.splitRunFileIntoCells": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.splitRunFileIntoCells.description%",
+                    "description": "%deepnote.configuration.deepnote.splitRunFileIntoCells.description%",
                     "scope": "resource"
                 },
-                "jupyter.variableExplorerExclude": {
+                "deepnote.variableExplorerExclude": {
                     "type": "string",
                     "default": "module;function;builtin_function_or_method;ABCMeta;type;ModelMetaclass",
-                    "description": "%jupyter.configuration.jupyter.variableExplorerExclude.description%",
+                    "description": "%deepnote.configuration.deepnote.variableExplorerExclude.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.cellMarker.codeRegex": {
+                "deepnote.interactiveWindow.cellMarker.codeRegex": {
                     "type": "string",
                     "default": "^(#\\s*%%|#\\s*\\<codecell\\>|#\\s*In\\[\\d*?\\]|#\\s*In\\[ \\])",
-                    "description": "%jupyter.configuration.jupyter.codeRegularExpression.description%",
+                    "description": "%deepnote.configuration.deepnote.codeRegularExpression.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.cellMarker.default": {
+                "deepnote.interactiveWindow.cellMarker.default": {
                     "type": "string",
                     "default": "# %%",
-                    "description": "%jupyter.configuration.jupyter.defaultCellMarker.description%",
+                    "description": "%deepnote.configuration.deepnote.defaultCellMarker.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.cellMarker.markdownRegex": {
+                "deepnote.interactiveWindow.cellMarker.markdownRegex": {
                     "type": "string",
                     "default": "^(#\\s*%%\\s*\\[markdown\\]|#\\s*\\<markdowncell\\>)",
-                    "description": "%jupyter.configuration.jupyter.markdownRegularExpression.description%",
+                    "description": "%deepnote.configuration.deepnote.markdownRegularExpression.description%",
                     "scope": "resource"
                 },
-                "jupyter.themeMatplotlibPlots": {
+                "deepnote.themeMatplotlibPlots": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.themeMatplotlibPlots.description%"
+                    "description": "%deepnote.configuration.deepnote.themeMatplotlibPlots.description%"
                 },
-                "jupyter.interactiveWindow.cellMarker.decorateCells": {
+                "deepnote.interactiveWindow.cellMarker.decorateCells": {
                     "type": "string",
                     "enum": [
                         "currentCell",
@@ -1798,68 +1798,68 @@
                         "None"
                     ],
                     "default": "currentCell",
-                    "description": "%jupyter.configuration.jupyter.decorateCells.description%",
+                    "description": "%deepnote.configuration.deepnote.decorateCells.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.codeLens.enable": {
+                "deepnote.interactiveWindow.codeLens.enable": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.enableCellCodeLens.description%",
+                    "description": "%deepnote.configuration.deepnote.enableCellCodeLens.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.textEditor.autoMoveToNextCell": {
+                "deepnote.interactiveWindow.textEditor.autoMoveToNextCell": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.enableAutoMoveToNextCell.description%",
+                    "description": "%deepnote.configuration.deepnote.enableAutoMoveToNextCell.description%",
                     "scope": "resource"
                 },
-                "jupyter.allowUnauthorizedRemoteConnection": {
+                "deepnote.allowUnauthorizedRemoteConnection": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.allowUnauthorizedRemoteConnection.description%"
+                    "description": "%deepnote.configuration.deepnote.allowUnauthorizedRemoteConnection.description%"
                 },
-                "jupyter.interactiveWindow.codeLens.commands": {
+                "deepnote.interactiveWindow.codeLens.commands": {
                     "type": "string",
-                    "default": "jupyter.runcell, jupyter.runallcellsabove, jupyter.debugcell",
-                    "description": "%jupyter.configuration.jupyter.codeLenses.description%",
+                    "default": "deepnote.runcell, deepnote.runallcellsabove, deepnote.debugcell",
+                    "description": "%deepnote.configuration.deepnote.codeLenses.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.codeLens.debugCommands": {
+                "deepnote.interactiveWindow.codeLens.debugCommands": {
                     "type": "string",
-                    "default": "jupyter.debugcontinue, jupyter.debugstop, jupyter.debugstepover",
-                    "description": "%jupyter.configuration.jupyter.debugCodeLenses.description%",
+                    "default": "deepnote.debugcontinue, deepnote.debugstop, deepnote.debugstepover",
+                    "description": "%deepnote.configuration.deepnote.debugCodeLenses.description%",
                     "scope": "resource"
                 },
-                "jupyter.debugpyDistPath": {
+                "deepnote.debugpyDistPath": {
                     "type": "string",
                     "default": "",
-                    "description": "%jupyter.configuration.jupyter.debugpyDistPath.description%",
+                    "description": "%deepnote.configuration.deepnote.debugpyDistPath.description%",
                     "scope": "resource"
                 },
-                "jupyter.stopOnFirstLineWhileDebugging": {
+                "deepnote.stopOnFirstLineWhileDebugging": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.stopOnFirstLineWhileDebugging.description%",
+                    "description": "%deepnote.configuration.deepnote.stopOnFirstLineWhileDebugging.description%",
                     "scope": "resource"
                 },
-                "jupyter.disableJupyterAutoStart": {
+                "deepnote.disableJupyterAutoStart": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.disableJupyterAutoStart.description%"
+                    "description": "%deepnote.configuration.deepnote.disableJupyterAutoStart.description%"
                 },
-                "jupyter.interactiveWindow.codeLens.enableGotoCell": {
+                "deepnote.interactiveWindow.codeLens.enableGotoCell": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.addGotoCodeLenses.description%",
+                    "description": "%deepnote.configuration.deepnote.addGotoCodeLenses.description%",
                     "scope": "resource"
                 },
-                "jupyter.kernels.excludePythonEnvironments": {
+                "deepnote.kernels.excludePythonEnvironments": {
                     "type": "array",
                     "items": {
                         "type": "string"
                     },
                     "default": [],
-                    "markdownDescription": "%jupyter.configuration.jupyter.kernels.filter.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.kernels.filter.markdownDescription%",
                     "scope": "machine-overridable",
                     "examples": [
                         [
@@ -1868,16 +1868,16 @@
                         ]
                     ]
                 },
-                "jupyter.kernels.trusted": {
+                "deepnote.kernels.trusted": {
                     "type": "array",
                     "items": {
                         "type": "string"
                     },
                     "default": [],
-                    "markdownDescription": "%jupyter.configuration.jupyter.kernels.trusted.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.kernels.trusted.markdownDescription%",
                     "scope": "machine"
                 },
-                "jupyter.interactiveWindow.creationMode": {
+                "deepnote.interactiveWindow.creationMode": {
                     "type": "string",
                     "enum": [
                         "perFile",
@@ -1885,25 +1885,25 @@
                         "multiple"
                     ],
                     "scope": "resource",
-                    "description": "%jupyter.configuration.jupyter.interactiveWindowMode.description%",
+                    "description": "%deepnote.configuration.deepnote.interactiveWindowMode.description%",
                     "default": "multiple"
                 },
-                "jupyter.interactiveWindow.notebookRepl": {
+                "deepnote.interactiveWindow.notebookRepl": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.interactiveWindowNotebookRepl.description%",
+                    "description": "%deepnote.configuration.deepnote.interactiveWindowNotebookRepl.description%",
                     "tags": [
                         "experimental",
                         "onExP"
                     ]
                 },
-                "jupyter.interactiveWindow.textEditor.cellFolding": {
+                "deepnote.interactiveWindow.textEditor.cellFolding": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.pythonCellFolding.description%",
+                    "description": "%deepnote.configuration.deepnote.pythonCellFolding.description%",
                     "scope": "resource"
                 },
-                "jupyter.interactiveWindow.viewColumn": {
+                "deepnote.interactiveWindow.viewColumn": {
                     "type": "string",
                     "enum": [
                         "beside",
@@ -1911,15 +1911,15 @@
                         "secondGroup"
                     ],
                     "scope": "resource",
-                    "description": "%jupyter.configuration.jupyter.interactiveWindowViewColumn.description%",
+                    "description": "%deepnote.configuration.deepnote.interactiveWindowViewColumn.description%",
                     "default": "secondGroup"
                 },
-                "jupyter.interactiveWindow.textEditor.magicCommandsAsComments": {
+                "deepnote.interactiveWindow.textEditor.magicCommandsAsComments": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.magicCommandsAsComments.description%"
+                    "description": "%deepnote.configuration.deepnote.magicCommandsAsComments.description%"
                 },
-                "jupyter.pythonExportMethod": {
+                "deepnote.pythonExportMethod": {
                     "type": "string",
                     "enum": [
                         "direct",
@@ -1927,64 +1927,64 @@
                         "nbconvert"
                     ],
                     "default": "direct",
-                    "description": "%jupyter.configuration.jupyter.pythonExportMethod.description%",
+                    "description": "%deepnote.configuration.deepnote.pythonExportMethod.description%",
                     "scope": "application"
                 },
-                "jupyter.runStartupCommands": {
+                "deepnote.runStartupCommands": {
                     "type": "array",
                     "default": "",
-                    "description": "%jupyter.configuration.jupyter.runStartupCommands.description%",
+                    "description": "%deepnote.configuration.deepnote.runStartupCommands.description%",
                     "scope": "application"
                 },
-                "jupyter.debugJustMyCode": {
+                "deepnote.debugJustMyCode": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.debugJustMyCode.description%",
+                    "description": "%deepnote.configuration.deepnote.debugJustMyCode.description%",
                     "scope": "resource"
                 },
-                "jupyter.showOutlineButtonInNotebookToolbar": {
+                "deepnote.showOutlineButtonInNotebookToolbar": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.showOutlineButtonInNotebookToolbar.description%"
+                    "description": "%deepnote.configuration.deepnote.showOutlineButtonInNotebookToolbar.description%"
                 },
-                "jupyter.interactiveWindow.textEditor.autoAddNewCell": {
+                "deepnote.interactiveWindow.textEditor.autoAddNewCell": {
                     "type": "boolean",
                     "default": true,
-                    "description": "%jupyter.configuration.jupyter.newCellOnRunLast.description%",
+                    "description": "%deepnote.configuration.deepnote.newCellOnRunLast.description%",
                     "scope": "resource"
                 },
-                "jupyter.pythonCompletionTriggerCharacters": {
+                "deepnote.pythonCompletionTriggerCharacters": {
                     "type": "string",
                     "default": ".%'\"",
-                    "deprecationMessage": "%jupyter.configuration.jupyter.pythonCompletionTriggerCharacters.deprecationMessage%",
-                    "description": "%jupyter.configuration.jupyter.pythonCompletionTriggerCharacters.description%",
+                    "deprecationMessage": "%deepnote.configuration.deepnote.pythonCompletionTriggerCharacters.deprecationMessage%",
+                    "description": "%deepnote.configuration.deepnote.pythonCompletionTriggerCharacters.description%",
                     "scope": "application"
                 },
-                "jupyter.logKernelOutputSeparately": {
+                "deepnote.logKernelOutputSeparately": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.logKernelOutputSeparately.description%"
+                    "description": "%deepnote.configuration.deepnote.logKernelOutputSeparately.description%"
                 },
-                "jupyter.excludeUserSitePackages": {
+                "deepnote.excludeUserSitePackages": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.excludeUserSitePackages.description%",
+                    "description": "%deepnote.configuration.deepnote.excludeUserSitePackages.description%",
                     "scope": "window"
                 },
-                "jupyter.enableExtendedKernelCompletions": {
+                "deepnote.enableExtendedKernelCompletions": {
                     "type": "boolean",
                     "default": false,
-                    "deprecationMessage": "%jupyter.configuration.jupyter.enableExtendedKernelCompletions.deprecationMessage%",
-                    "markdownDescription": "%jupyter.configuration.jupyter.enableExtendedKernelCompletions.markdownDescription%",
+                    "deprecationMessage": "%deepnote.configuration.deepnote.enableExtendedKernelCompletions.deprecationMessage%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.enableExtendedKernelCompletions.markdownDescription%",
                     "scope": "application"
                 },
-                "jupyter.enableExtendedPythonKernelCompletions": {
+                "deepnote.enableExtendedPythonKernelCompletions": {
                     "type": "boolean",
                     "default": false,
-                    "markdownDescription": "%jupyter.configuration.jupyter.enableExtendedKernelCompletions.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.enableExtendedKernelCompletions.markdownDescription%",
                     "scope": "application"
                 },
-                "jupyter.executionAnalysis.enabled": {
+                "deepnote.executionAnalysis.enabled": {
                     "type": "boolean",
                     "default": false,
                     "description": "Experimental feature to enable execution analysis in notebooks",
@@ -1993,20 +1993,20 @@
                         "experimental"
                     ]
                 },
-                "jupyter.enableKernelCompletions": {
+                "deepnote.enableKernelCompletions": {
                     "type": "boolean",
                     "default": true,
-                    "markdownDescription": "%jupyter.configuration.jupyter.enableKernelCompletions.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.enableKernelCompletions.markdownDescription%",
                     "scope": "application"
                 },
-                "jupyter.formatStackTraces": {
+                "deepnote.formatStackTraces": {
                     "type": "boolean",
                     "default": false,
-                    "description": "%jupyter.configuration.jupyter.formatStackTraces.description%",
-                    "deprecationMessage": "%jupyter.configuration.jupyter.formatStackTraces.deprecationMessage%",
+                    "description": "%deepnote.configuration.deepnote.formatStackTraces.description%",
+                    "deprecationMessage": "%deepnote.configuration.deepnote.formatStackTraces.deprecationMessage%",
                     "scope": "application"
                 },
-                "jupyter.completionTriggerCharacters": {
+                "deepnote.completionTriggerCharacters": {
                     "type": "object",
                     "patternProperties": {
                         "^[A-Za-z_][A-Za-z0-9]*": {
@@ -2067,7 +2067,7 @@
                             "<"
                         ]
                     },
-                    "markdownDescription": "%jupyter.configuration.jupyter.completionTriggerCharacters.markdownDescription%",
+                    "markdownDescription": "%deepnote.configuration.deepnote.completionTriggerCharacters.markdownDescription%",
                     "scope": "application",
                     "examples": [
                         {
@@ -2250,7 +2250,7 @@
                     "type": "webview",
                     "id": "jupyterViewVariables",
                     "name": "Jupyter Variables",
-                    "when": "jupyter.hasNativeNotebookOrInteractiveWindowOpen"
+                    "when": "deepnote.hasNativeNotebookOrInteractiveWindowOpen"
                 }
             ]
         },
@@ -2264,17 +2264,17 @@
         "debuggers": [
             {
                 "type": "Python Kernel Debug Adapter",
-                "label": "%jupyter.debuggers.kernel%"
+                "label": "%deepnote.debuggers.kernel%"
             },
             {
                 "type": "Python Interactive Window Debug Adapter",
-                "label": "%jupyter.debuggers.interactive%"
+                "label": "%deepnote.debuggers.interactive%"
             }
         ],
         "jupyterVariableViewers": [
             {
-                "command": "jupyter.showJupyterDataViewer",
-                "title": "%jupyter.command.jupyter.showDataViewer.title%",
+                "command": "deepnote.showJupyterDataViewer",
+                "title": "%deepnote.command.deepnote.showDataViewer.title%",
                 "dataTypes": [
                     "DataFrame",
                     "list",
@@ -2290,9 +2290,9 @@
         "languageModelTools": [
             {
                 "name": "configure_notebook",
-                "displayName": "%jupyter.languageModelTools.configure_notebook.displayName%",
+                "displayName": "%deepnote.languageModelTools.configure_notebook.displayName%",
                 "modelDescription": "Tool used to configure a Notebook. ALWAYS use this tool before running/executing any Notebook Cells for the first time or before listing/installing packages in Notebooks for the first time. I.e. there is no need to use this tool more than once for the same notebook.",
-                "userDescription": "%jupyter.languageModelTools.configure_notebook.userDescription%",
+                "userDescription": "%deepnote.languageModelTools.configure_notebook.userDescription%",
                 "toolReferenceName": "configureNotebook",
                 "tags": [
                     "python environment",
@@ -2367,7 +2367,7 @@
                 "name": "notebook_list_packages",
                 "displayName": "List Notebook Kernel Packages",
                 "modelDescription": "List the installed packages that are currently available in the selected kernel for a notebook editor. This tool should be used when working with a jupyter notebook with python code cells. Do not use this tool if not already working with a notebook, or for a language other than python. If the tool configure_notebooks exists, then ensure to call configure_notebooks before using this tool.",
-                "userDescription": "%jupyter.languageModelTools.notebook_list_packages.userDescription%",
+                "userDescription": "%deepnote.languageModelTools.notebook_list_packages.userDescription%",
                 "toolReferenceName": "listNotebookPackages",
                 "tags": [
                     "python environment",
@@ -2395,7 +2395,7 @@
                 "name": "notebook_install_packages",
                 "displayName": "Install Packages for Notebook",
                 "modelDescription": "Install a list of packages on a notebook kernel to be used within that notebook. This tool should be used when working with a jupyter notebook with python code cells. Do not use this tool if not already working with a notebook, or for a language other than python. If the tool configure_notebooks exists, then ensure to call configure_notebooks before using this tool.",
-                "userDescription": "%jupyter.languageModelTools.notebook_install_packages.userDescription%",
+                "userDescription": "%deepnote.languageModelTools.notebook_install_packages.userDescription%",
                 "toolReferenceName": "installNotebookPackages",
                 "tags": [
                     "python environment",
diff --git a/package.nls.json b/package.nls.json
index 6c7b95ee23..a449eda77a 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -13,17 +13,17 @@
         ]
     },
     "contributes.walkthroughs.jupyterWelcome.steps.ipynb.newUntitledIpynb.media.altText": "Creating a new Jupyter notebook",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.selectKernel.title": "Select a Jupyter Kernel",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.selectKernel.description": {
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.selectKernel.title": "Select a Jupyter Kernel",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.selectKernel.description": {
         "message": "Click Select Kernel at the top right of the notebook and choose the environment in which to run your kernel. Or, with a notebook opened and in focus, open the [Command Palette](command:workbench.action.showCommands) and run the command: \n``Notebook: Select Notebook Kernel``. \n[Open Command Palette to Select a Jupyter Kernel](command:workbench.action.showCommands)",
         "comment": ["{Locked='command:workbench.action.showCommands'}"]
     },
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.selectKernel.media.altText": "Selecting or changing a notebook kernel",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.exploreAndDebug.title": "Explore data and debug",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.exploreAndDebug.description": "📅 You can use the [Data Viewer](https://code.visualstudio.com/docs/datascience/data-science-tutorial#_prepare-the-data) to view, sort, and filter the rows of data. After loading your data, click \"Variables\" at the top right of the notebook and click the Data Viewer icon to the left of the data table. \n \n[Learn about Data Viewer](https://code.visualstudio.com/docs/datascience/data-science-tutorial#_prepare-the-data)\n \n📒 Debug your notebook using the [Run by Line](https://code.visualstudio.com/docs/datascience/jupyter-notebooks#_run-by-line) mode to execute a cell one line at a time. Click the Run by Line icon from your cell (play button with lines) or hit F10. \n \n[Learn about Run by Line](https://code.visualstudio.com/docs/datascience/jupyter-notebooks#_run-by-line)",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.exploreAndDebug.media.altText": "Opening data viewer",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.dataScienceLearnMore.title": "Find out more!",
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.dataScienceLearnMore.description": {
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.selectKernel.media.altText": "Selecting or changing a notebook kernel",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.exploreAndDebug.title": "Explore data and debug",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.exploreAndDebug.description": "📅 You can use the [Data Viewer](https://code.visualstudio.com/docs/datascience/data-science-tutorial#_prepare-the-data) to view, sort, and filter the rows of data. After loading your data, click \"Variables\" at the top right of the notebook and click the Data Viewer icon to the left of the data table. \n \n[Learn about Data Viewer](https://code.visualstudio.com/docs/datascience/data-science-tutorial#_prepare-the-data)\n \n📒 Debug your notebook using the [Run by Line](https://code.visualstudio.com/docs/datascience/jupyter-notebooks#_run-by-line) mode to execute a cell one line at a time. Click the Run by Line icon from your cell (play button with lines) or hit F10. \n \n[Learn about Run by Line](https://code.visualstudio.com/docs/datascience/jupyter-notebooks#_run-by-line)",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.exploreAndDebug.media.altText": "Opening data viewer",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.dataScienceLearnMore.title": "Find out more!",
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.dataScienceLearnMore.description": {
         "message": "🎨 Explore all the features the Jupyter Extension has to offer by looking for \"Jupyter\" in the [Command Palette](command:workbench.action.showCommands). \n 📈 Learn more about getting started with data science in [Python](command:workbench.action.openWalkthrough?%7B%22category%22%3A%22ms-python.python%23pythonDataScienceWelcome%22%2C%22step%22%3A%22ms-python.python%23python.createNewNotebook%22%7D) by installing the Python Extension ([search Python extension](command:workbench.extensions.search?\"ms-python.python\")). \n 📃 Find out more features in our [Tutorials](https://code.visualstudio.com/docs/datascience/jupyter-notebooks).  \n[Learn more](https://aka.ms/AAdar6q)",
         "comment": [
             "{Locked='command:workbench.action.showCommands'}",
@@ -32,197 +32,197 @@
             "{Locked='docs/datascience/jupyter-notebooks'}"
         ]
     },
-    "contributes.walkthroughs.jupyterWelcome.steps.jupyter.dataScienceLearnMore.media.altText": "Image representing our documentation page and mailing list resources.",
-    "jupyter.command.dataScience.clearCache.title": "Clear Cache",
-    "jupyter.command.dataScience.clearUserProviderJupyterServerCache.title": "Clear User Jupyter Server Cache",
-    "jupyter.command.jupyter.replayPylanceLog.title": "Replay Pylance Log",
-    "jupyter.command.jupyter.replayPylanceLogStep.title": "Step Pylance Log",
-    "jupyter.command.jupyter.exportAsPythonScript.title": "Export to Python Script",
-    "jupyter.command.jupyter.exportToHTML.title": "Export to HTML",
-    "jupyter.command.jupyter.exportToPDF.title": "Export to PDF",
-    "jupyter.command.jupyter.filterKernels.title": "Filter Kernels",
-    "jupyter.command.jupyter.runByLine.title": "Run by Line",
-    "jupyter.command.jupyter.debugCell.title": "Debug Cell",
-    "jupyter.command.jupyter.runByLineNext.title": "Run Next Line",
-    "jupyter.command.jupyter.runByLineStop.title": "Continue Execution",
-    "jupyter.command.editor.interactiveWindow.context.label": "Run in Interactive Window",
-    "jupyter.command.jupyter.runFileInteractive.title": "Run Current File in Interactive Window",
-    "jupyter.command.jupyter.debugFileInteractive.title": "Debug Current File in Interactive Window",
-    "jupyter.command.jupyter.runallcells.title": "Run All Cells",
-    "jupyter.command.jupyter.runallcellsabove.title": "Run Above",
-    "jupyter.command.jupyter.runcellandallbelow.title": "Run Below",
-    "jupyter.command.jupyter.runallcellsabove.palette.title": "Run Cells Above Current Cell",
-    "jupyter.command.jupyter.runcurrentcellandallbelow.palette.title": "Run Current Cell and Below",
-    "jupyter.command.jupyter.debugcurrentcell.palette.title": "Debug Current Cell",
-    "jupyter.command.jupyter.debugcell.title": "Debug Cell",
-    "jupyter.command.jupyter.debugstepover.title": "Step Over",
-    "jupyter.command.jupyter.debugcontinue.title": "Continue",
-    "jupyter.command.jupyter.debugstop.title": "Stop",
-    "jupyter.command.jupyter.runtoline.title": "Run To Line in Interactive Window",
-    "jupyter.command.jupyter.runfromline.title": "Run From Line in Interactive Window",
-    "jupyter.command.jupyter.runcurrentcell.title": "Run Current Cell",
-    "jupyter.command.jupyter.runcurrentcelladvance.title": "Run Current Cell And Advance",
-    "jupyter.command.jupyter.execSelectionInteractive.title": "Run Selection/Line in Interactive Window",
-    "jupyter.command.jupyter.runcell.title": "Run Cell",
-    "jupyter.command.jupyter.insertCellBelowPosition.title": "Insert Cell Below Position",
-    "jupyter.command.jupyter.insertCellBelow.title": "Insert Cell Below",
-    "jupyter.command.jupyter.insertCellAbove.title": "Insert Cell Above",
-    "jupyter.command.jupyter.deleteCells.title": "Delete Selected Cells",
-    "jupyter.command.jupyter.selectCell.title": "Select Cell",
-    "jupyter.command.jupyter.selectCellContents.title": "Select Cell Contents",
-    "jupyter.command.jupyter.extendSelectionByCellAbove.title": "Extend Selection By Cell Above",
-    "jupyter.command.jupyter.extendSelectionByCellBelow.title": "Extend Selection By Cell Below",
-    "jupyter.command.jupyter.moveCellsUp.title": "Move Selected Cells Up",
-    "jupyter.command.jupyter.moveCellsDown.title": "Move Selected Cells Down",
-    "jupyter.command.jupyter.changeCellToMarkdown.title": "Change Cell to Markdown",
-    "jupyter.command.jupyter.changeCellToCode.title": "Change Cell to Code",
-    "jupyter.command.jupyter.gotoNextCellInFile.title": "Go to Next Cell",
-    "jupyter.command.jupyter.gotoPrevCellInFile.title": "Go to Previous Cell",
-    "jupyter.command.jupyter.createnewinteractive.title": "Create Interactive Window",
-    "jupyter.command.jupyter.importnotebookfile.title": "Import Notebook to Script",
-    "jupyter.command.jupyter.exportfileasnotebook.title": {
+    "contributes.walkthroughs.jupyterWelcome.steps.deepnote.dataScienceLearnMore.media.altText": "Image representing our documentation page and mailing list resources.",
+    "deepnote.command.dataScience.clearCache.title": "Clear Cache",
+    "deepnote.command.dataScience.clearUserProviderJupyterServerCache.title": "Clear User Jupyter Server Cache",
+    "deepnote.command.deepnote.replayPylanceLog.title": "Replay Pylance Log",
+    "deepnote.command.deepnote.replayPylanceLogStep.title": "Step Pylance Log",
+    "deepnote.command.deepnote.exportAsPythonScript.title": "Export to Python Script",
+    "deepnote.command.deepnote.exportToHTML.title": "Export to HTML",
+    "deepnote.command.deepnote.exportToPDF.title": "Export to PDF",
+    "deepnote.command.deepnote.filterKernels.title": "Filter Kernels",
+    "deepnote.command.deepnote.runByLine.title": "Run by Line",
+    "deepnote.command.deepnote.debugCell.title": "Debug Cell",
+    "deepnote.command.deepnote.runByLineNext.title": "Run Next Line",
+    "deepnote.command.deepnote.runByLineStop.title": "Continue Execution",
+    "deepnote.command.editor.interactiveWindow.context.label": "Run in Interactive Window",
+    "deepnote.command.deepnote.runFileInteractive.title": "Run Current File in Interactive Window",
+    "deepnote.command.deepnote.debugFileInteractive.title": "Debug Current File in Interactive Window",
+    "deepnote.command.deepnote.runallcells.title": "Run All Cells",
+    "deepnote.command.deepnote.runallcellsabove.title": "Run Above",
+    "deepnote.command.deepnote.runcellandallbelow.title": "Run Below",
+    "deepnote.command.deepnote.runallcellsabove.palette.title": "Run Cells Above Current Cell",
+    "deepnote.command.deepnote.runcurrentcellandallbelow.palette.title": "Run Current Cell and Below",
+    "deepnote.command.deepnote.debugcurrentcell.palette.title": "Debug Current Cell",
+    "deepnote.command.deepnote.debugcell.title": "Debug Cell",
+    "deepnote.command.deepnote.debugstepover.title": "Step Over",
+    "deepnote.command.deepnote.debugcontinue.title": "Continue",
+    "deepnote.command.deepnote.debugstop.title": "Stop",
+    "deepnote.command.deepnote.runtoline.title": "Run To Line in Interactive Window",
+    "deepnote.command.deepnote.runfromline.title": "Run From Line in Interactive Window",
+    "deepnote.command.deepnote.runcurrentcell.title": "Run Current Cell",
+    "deepnote.command.deepnote.runcurrentcelladvance.title": "Run Current Cell And Advance",
+    "deepnote.command.deepnote.execSelectionInteractive.title": "Run Selection/Line in Interactive Window",
+    "deepnote.command.deepnote.runcell.title": "Run Cell",
+    "deepnote.command.deepnote.insertCellBelowPosition.title": "Insert Cell Below Position",
+    "deepnote.command.deepnote.insertCellBelow.title": "Insert Cell Below",
+    "deepnote.command.deepnote.insertCellAbove.title": "Insert Cell Above",
+    "deepnote.command.deepnote.deleteCells.title": "Delete Selected Cells",
+    "deepnote.command.deepnote.selectCell.title": "Select Cell",
+    "deepnote.command.deepnote.selectCellContents.title": "Select Cell Contents",
+    "deepnote.command.deepnote.extendSelectionByCellAbove.title": "Extend Selection By Cell Above",
+    "deepnote.command.deepnote.extendSelectionByCellBelow.title": "Extend Selection By Cell Below",
+    "deepnote.command.deepnote.moveCellsUp.title": "Move Selected Cells Up",
+    "deepnote.command.deepnote.moveCellsDown.title": "Move Selected Cells Down",
+    "deepnote.command.deepnote.changeCellToMarkdown.title": "Change Cell to Markdown",
+    "deepnote.command.deepnote.changeCellToCode.title": "Change Cell to Code",
+    "deepnote.command.deepnote.gotoNextCellInFile.title": "Go to Next Cell",
+    "deepnote.command.deepnote.gotoPrevCellInFile.title": "Go to Previous Cell",
+    "deepnote.command.deepnote.createnewinteractive.title": "Create Interactive Window",
+    "deepnote.command.deepnote.importnotebookfile.title": "Import Notebook to Script",
+    "deepnote.command.deepnote.exportfileasnotebook.title": {
         "message": "Export Current Python File as Jupyter Notebook",
         "comment": ["{Locked='Notebook'}"]
     },
-    "jupyter.command.jupyter.notebookeditor.removeallcells.title": {
+    "deepnote.command.deepnote.notebookeditor.removeallcells.title": {
         "message": "Delete All Notebook Editor Cells",
         "comment": ["{Locked='Notebook'}"]
     },
-    "jupyter.command.jupyter.notebookeditor.addcellbelow.title": {
+    "deepnote.command.deepnote.notebookeditor.addcellbelow.title": {
         "message": "Add Empty Cell to Notebook File",
         "comment": ["{Locked='Notebook'}"]
     },
-    "jupyter.command.jupyter.notebookeditor.runfocusedcell.title": "Run Focused Cell",
-    "jupyter.command.jupyter.interruptkernel.title": "Interrupt Kernel",
-    "jupyter.command.jupyter.interruptkernel.shorttitle": "Interrupt",
-    "jupyter.command.jupyter.restartkernel.title": "Restart Kernel",
-    "jupyter.command.jupyter.restartkernel.shorttitle": "Restart",
-    "jupyter.command.jupyter.restartkernelandrunallcells.title": "Restart Kernel and Run All Cells",
-    "jupyter.command.jupyter.restartkernelandrunallcells.shorttitle": "Restart and Run All",
-    "jupyter.command.jupyter.restartkernelandrunuptoselectedcell.title": "Restart Kernel and Run Up To Selected Cell",
-    "jupyter.command.jupyter.expandallcells.title": "Expand All Cell Inputs",
-    "jupyter.command.jupyter.collapseallcells.title": "Collapse All Cell Inputs",
-    "jupyter.command.jupyter.expandallcells.shorttitle": "Expand",
-    "jupyter.command.jupyter.collapseallcells.shorttitle": "Collapse",
-    "jupyter.command.jupyter.addcellbelow.title": "Add Empty Cell to File",
-    "jupyter.command.jupyter.createnewnotebook.title": "Create New Jupyter Notebook",
-    "jupyter.command.jupyter.scrolltocell.title": "Scroll Cell Into View",
-    "jupyter.command.jupyter.selectJupyterInterpreter.title": "Select Interpreter to Start Jupyter Server",
-    "jupyter.command.jupyter.showDataViewer.title": "View Value in Data Viewer",
-    "jupyter.command.jupyter.viewOutput.title": "Show Output",
-    "jupyter.command.jupyter.clearSavedJupyterUris.title": "Clear Jupyter Remote Server List",
-    "jupyter.command.jupyter.openVariableView.title": "Open Jupyter Variables View",
-    "jupyter.command.jupyter.openVariableView.shorttitle": "Jupyter Variables",
-    "jupyter.command.jupyter.openOutlineView.title": "Show Table Of Contents (Outline View)",
-    "jupyter.command.jupyter.openOutlineView.shorttitle": "Outline",
-    "jupyter.command.manageAccessToKernels": "Manage Access To Jupyter Kernels",
-    "jupyter.commandPalette.jupyter.replayPylanceLog.title": "Replay Pylance Log",
-    "jupyter.notebookRenderer.IPyWidget.displayName": "Jupyter IPyWidget Renderer",
-    "jupyter.notebookRenderer.Error.displayName": "Jupyter Error Renderer",
-    "jupyter.debuggers.kernel": "Python Kernel Debug Adapter",
-    "jupyter.debuggers.interactive": "Python Interactive Window",
-    "jupyter.configuration.jupyter.experiments.enabled.description": "Enables/disables A/B tests.",
-    "jupyter.configuration.jupyter.showVariableViewWhenDebugging.description": "Bring up the Variable View when starting a Run by Line session.",
-    "jupyter.configuration.jupyter.logging.level.off": "No messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.trace": "All messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.debug": "Debug and higher severity messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.info": "Information, warning, and error messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.warn": "Warning and error messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.error": "Only error messages are logged with this level.",
-    "jupyter.configuration.jupyter.logging.level.description": "The logging level the extension logs at.",
-    "jupyter.configuration.jupyter.experiments.optInto.markdownDescription": "List of experiments to opt into. If empty, the user is assigned the default experiment groups. [Learn more](https://github.com/microsoft/vscode-jupyter/wiki/Experiments).",
-    "jupyter.configuration.jupyter.experiments.optOutFrom.markdownDescription": "List of experiments to opt out of. If empty, the user is assigned the default experiment groups. [Learn more](https://github.com/microsoft/vscode-jupyter/wiki/Experiments).",
-    "jupyter.configuration.jupyter.widgetScriptSources.items.enumDescriptions.0": "Loads widget (javascript) scripts from https://www.jsdelivr.com/",
-    "jupyter.configuration.jupyter.widgetScriptSources.items.enumDescriptions.1": "Loads widget (javascript) scripts from https://unpkg.com/",
-    "jupyter.configuration.jupyter.widgetScriptSources.items.custom": "Loads widget (javascript) scripts from a custom CDN, following the provided URL template. ",
-    "jupyter.configuration.jupyter.widgetScriptSources.markdownDescription": {
+    "deepnote.command.deepnote.notebookeditor.runfocusedcell.title": "Run Focused Cell",
+    "deepnote.command.deepnote.interruptkernel.title": "Interrupt Kernel",
+    "deepnote.command.deepnote.interruptkernel.shorttitle": "Interrupt",
+    "deepnote.command.deepnote.restartkernel.title": "Restart Kernel",
+    "deepnote.command.deepnote.restartkernel.shorttitle": "Restart",
+    "deepnote.command.deepnote.restartkernelandrunallcells.title": "Restart Kernel and Run All Cells",
+    "deepnote.command.deepnote.restartkernelandrunallcells.shorttitle": "Restart and Run All",
+    "deepnote.command.deepnote.restartkernelandrunuptoselectedcell.title": "Restart Kernel and Run Up To Selected Cell",
+    "deepnote.command.deepnote.expandallcells.title": "Expand All Cell Inputs",
+    "deepnote.command.deepnote.collapseallcells.title": "Collapse All Cell Inputs",
+    "deepnote.command.deepnote.expandallcells.shorttitle": "Expand",
+    "deepnote.command.deepnote.collapseallcells.shorttitle": "Collapse",
+    "deepnote.command.deepnote.addcellbelow.title": "Add Empty Cell to File",
+    "deepnote.command.deepnote.createnewnotebook.title": "Create New Jupyter Notebook",
+    "deepnote.command.deepnote.scrolltocell.title": "Scroll Cell Into View",
+    "deepnote.command.deepnote.selectJupyterInterpreter.title": "Select Interpreter to Start Jupyter Server",
+    "deepnote.command.deepnote.showDataViewer.title": "View Value in Data Viewer",
+    "deepnote.command.deepnote.viewOutput.title": "Show Output",
+    "deepnote.command.deepnote.clearSavedJupyterUris.title": "Clear Jupyter Remote Server List",
+    "deepnote.command.deepnote.openVariableView.title": "Open Jupyter Variables View",
+    "deepnote.command.deepnote.openVariableView.shorttitle": "Jupyter Variables",
+    "deepnote.command.deepnote.openOutlineView.title": "Show Table Of Contents (Outline View)",
+    "deepnote.command.deepnote.openOutlineView.shorttitle": "Outline",
+    "deepnote.command.manageAccessToKernels": "Manage Access To Jupyter Kernels",
+    "deepnote.commandPalette.deepnote.replayPylanceLog.title": "Replay Pylance Log",
+    "deepnote.notebookRenderer.IPyWidget.displayName": "Jupyter IPyWidget Renderer",
+    "deepnote.notebookRenderer.Error.displayName": "Jupyter Error Renderer",
+    "deepnote.debuggers.kernel": "Python Kernel Debug Adapter",
+    "deepnote.debuggers.interactive": "Python Interactive Window",
+    "deepnote.configuration.deepnote.experiments.enabled.description": "Enables/disables A/B tests.",
+    "deepnote.configuration.deepnote.showVariableViewWhenDebugging.description": "Bring up the Variable View when starting a Run by Line session.",
+    "deepnote.configuration.deepnote.logging.level.off": "No messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.trace": "All messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.debug": "Debug and higher severity messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.info": "Information, warning, and error messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.warn": "Warning and error messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.error": "Only error messages are logged with this level.",
+    "deepnote.configuration.deepnote.logging.level.description": "The logging level the extension logs at.",
+    "deepnote.configuration.deepnote.experiments.optInto.markdownDescription": "List of experiments to opt into. If empty, the user is assigned the default experiment groups. [Learn more](https://github.com/microsoft/vscode-jupyter/wiki/Experiments).",
+    "deepnote.configuration.deepnote.experiments.optOutFrom.markdownDescription": "List of experiments to opt out of. If empty, the user is assigned the default experiment groups. [Learn more](https://github.com/microsoft/vscode-jupyter/wiki/Experiments).",
+    "deepnote.configuration.deepnote.widgetScriptSources.items.enumDescriptions.0": "Loads widget (javascript) scripts from https://www.jsdelivr.com/",
+    "deepnote.configuration.deepnote.widgetScriptSources.items.enumDescriptions.1": "Loads widget (javascript) scripts from https://unpkg.com/",
+    "deepnote.configuration.deepnote.widgetScriptSources.items.custom": "Loads widget (javascript) scripts from a custom CDN, following the provided URL template. ",
+    "deepnote.configuration.deepnote.widgetScriptSources.markdownDescription": {
         "message": "Defines the location and order of the sources where script files for widgets are downloaded from (e.g., ipywidgets, bqplot, beakerx, ipyleaflet, etc). Not selecting any of these could result in widgets not rendering or functioning correctly. See [here](https://aka.ms/PVSCIPyWidgets) for more information. Once updated, you will need to restart the Kernel. Custom values will be interpreted as URL templates where: \n- `${packageName}` will be replaced with the package name \n- `{fileName}` will be replaced with the file name \n- `${fileNameWithExt}` will be replaced with the file name including `.js` extension \n- `${moduleVersion}` will be replaced with the exact module version \n- `${moduleVersionSpec}` will be replaced with the module version specifier that may include `^` to indicate a range of compatible versions",
         "comment": [
             "{Locked='${...}'}",
             "Do not translate what's inside of the '${..}'. It is an internal syntax for the extension"
         ]
     },
-    "jupyter.configuration.jupyter.askForLargeDataFrames.description": "Warn the user before trying to open really large data frames.",
-    "jupyter.configuration.jupyter.askForKernelRestart.description": "Warn the user before restarting a kernel.",
-    "jupyter.configuration.jupyter.exportWithOutputEnabled.description": "Enable exporting a Python file into a Jupyter notebook and run all cells when doing so.",
-    "jupyter.configuration.jupyter.jupyterLaunchTimeout.description": "Amount of time (in ms) to wait for the Jupyter Notebook server to start.",
-    "jupyter.configuration.jupyter.jupyterLaunchRetries.description": "Number of times to attempt to connect to the Jupyter Notebook",
-    "jupyter.configuration.jupyter.jupyterCommandLineArguments.description": "If and when a Jupyter server is started, these arguments will be passed to the Jupyter Notebook CLI. By default, this list is generated by the Jupyter extension.",
-    "jupyter.configuration.jupyter.notebookFileRoot.description": "Set the root directory for Jupyter Notebooks and the Interactive Window running locally.  \n\n**Note:** This does not apply to Remote Jupyter Kernels.",
-    "jupyter.configuration.jupyter.useDefaultConfigForJupyter.description": "When running Jupyter locally, create a default empty Jupyter config",
-    "jupyter.configuration.jupyter.jupyterInterruptTimeout.description": "Amount of time (in ms) to wait for an interrupt before asking to restart the Jupyter kernel.",
-    "jupyter.configuration.jupyter.sendSelectionToInteractiveWindow.description": "When pressing shift+enter, send selected code in a Python file to the Jupyter interactive window as opposed to the Python terminal.",
-    "jupyter.configuration.jupyter.normalizeSelectionForInteractiveWindow.description": "Selected text will be normalized before it is executed in the Interactive Window.",
-    "jupyter.configuration.jupyter.splitRunFileIntoCells.description": "A file run in the Interactive Window will be run in individual cells if it has them.",
-    "jupyter.configuration.jupyter.sendSelectionToInteractiveWindow.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.textEditor.executeSelection.",
-    "jupyter.configuration.jupyter.variableExplorerExclude.description": "Types to exclude from showing in the Interactive variable explorer",
-    "jupyter.configuration.jupyter.codeRegularExpression.description": "Regular expression used to identify code cells. All code until the next match is considered part of this cell.",
-    "jupyter.configuration.jupyter.codeRegularExpression.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.cellMarker.codeRegex.",
-    "jupyter.configuration.jupyter.defaultCellMarker.description": "Cell marker used for delineating a cell in a Python file.",
-    "jupyter.configuration.jupyter.defaultCellMarker.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.cellMarker.default",
-    "jupyter.configuration.jupyter.markdownRegularExpression.description": "Regular expression used to identify markdown cells. All comments after this expression are considered part of the markdown.",
-    "jupyter.configuration.jupyter.markdownRegularExpression.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.cellMarker.markdownRegex.",
-    "jupyter.configuration.jupyter.themeMatplotlibPlots.description": "In the Interactive window and Notebook Editor theme matplotlib outputs to match the VS Code editor theme.",
-    "jupyter.configuration.jupyter.decorateCells.description": "Draw a highlight behind the currently active cell, or all cells, in a Python file.",
-    "jupyter.configuration.jupyter.decorateCells.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.cellMarker.decorateCells.",
-    "jupyter.configuration.jupyter.enableCellCodeLens.description": "Enables code lens for 'cells' in a Python file.",
-    "jupyter.configuration.jupyter.enableCellCodeLens.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.codeLens.enable.",
-    "jupyter.configuration.jupyter.enableAutoMoveToNextCell.description": "Enables moving to the next cell when clicking on a 'Run Cell' code lens.",
-    "jupyter.configuration.jupyter.enableAutoMoveToNextCell.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.textEditor.autoMoveToNextCell.",
-    "jupyter.configuration.jupyter.allowUnauthorizedRemoteConnection.description": "Allow for connecting the Interactive window to a https Jupyter server that does not have valid certificates. This can be a security risk, so only use it for known and trusted servers.",
-    "jupyter.configuration.jupyter.codeLenses.description": "Set of commands to put as code lens above a cell.",
-    "jupyter.configuration.jupyter.codeLenses.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.codeLens.commands.",
-    "jupyter.configuration.jupyter.debugCodeLenses.description": "Set of debug commands to put as code lens above a cell while debugging.",
-    "jupyter.configuration.jupyter.debugCodeLenses.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.codeLens.debugCommands.",
-    "jupyter.configuration.jupyter.debugpyDistPath.description": "Path to debugpy bits for debugging cells.",
-    "jupyter.configuration.jupyter.stopOnFirstLineWhileDebugging.description": "When debugging a cell, stop on the first line.",
-    "jupyter.configuration.jupyter.disableJupyterAutoStart.description": "When true, disables Jupyter from being automatically started for you. You must instead run a cell to start Jupyter.",
-    "jupyter.configuration.jupyter.addGotoCodeLenses.description": {
+    "deepnote.configuration.deepnote.askForLargeDataFrames.description": "Warn the user before trying to open really large data frames.",
+    "deepnote.configuration.deepnote.askForKernelRestart.description": "Warn the user before restarting a kernel.",
+    "deepnote.configuration.deepnote.exportWithOutputEnabled.description": "Enable exporting a Python file into a Jupyter notebook and run all cells when doing so.",
+    "deepnote.configuration.deepnote.jupyterLaunchTimeout.description": "Amount of time (in ms) to wait for the Jupyter Notebook server to start.",
+    "deepnote.configuration.deepnote.jupyterLaunchRetries.description": "Number of times to attempt to connect to the Jupyter Notebook",
+    "deepnote.configuration.deepnote.jupyterCommandLineArguments.description": "If and when a Jupyter server is started, these arguments will be passed to the Jupyter Notebook CLI. By default, this list is generated by the Jupyter extension.",
+    "deepnote.configuration.deepnote.notebookFileRoot.description": "Set the root directory for Jupyter Notebooks and the Interactive Window running locally.  \n\n**Note:** This does not apply to Remote Jupyter Kernels.",
+    "deepnote.configuration.deepnote.useDefaultConfigFordeepnote.description": "When running Jupyter locally, create a default empty Jupyter config",
+    "deepnote.configuration.deepnote.jupyterInterruptTimeout.description": "Amount of time (in ms) to wait for an interrupt before asking to restart the Jupyter kernel.",
+    "deepnote.configuration.deepnote.sendSelectionToInteractiveWindow.description": "When pressing shift+enter, send selected code in a Python file to the Jupyter interactive window as opposed to the Python terminal.",
+    "deepnote.configuration.deepnote.normalizeSelectionForInteractiveWindow.description": "Selected text will be normalized before it is executed in the Interactive Window.",
+    "deepnote.configuration.deepnote.splitRunFileIntoCells.description": "A file run in the Interactive Window will be run in individual cells if it has them.",
+    "deepnote.configuration.deepnote.sendSelectionToInteractiveWindow.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.textEditor.executeSelection.",
+    "deepnote.configuration.deepnote.variableExplorerExclude.description": "Types to exclude from showing in the Interactive variable explorer",
+    "deepnote.configuration.deepnote.codeRegularExpression.description": "Regular expression used to identify code cells. All code until the next match is considered part of this cell.",
+    "deepnote.configuration.deepnote.codeRegularExpression.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.cellMarker.codeRegex.",
+    "deepnote.configuration.deepnote.defaultCellMarker.description": "Cell marker used for delineating a cell in a Python file.",
+    "deepnote.configuration.deepnote.defaultCellMarker.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.cellMarker.default",
+    "deepnote.configuration.deepnote.markdownRegularExpression.description": "Regular expression used to identify markdown cells. All comments after this expression are considered part of the markdown.",
+    "deepnote.configuration.deepnote.markdownRegularExpression.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.cellMarker.markdownRegex.",
+    "deepnote.configuration.deepnote.themeMatplotlibPlots.description": "In the Interactive window and Notebook Editor theme matplotlib outputs to match the VS Code editor theme.",
+    "deepnote.configuration.deepnote.decorateCells.description": "Draw a highlight behind the currently active cell, or all cells, in a Python file.",
+    "deepnote.configuration.deepnote.decorateCells.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.cellMarker.decorateCells.",
+    "deepnote.configuration.deepnote.enableCellCodeLens.description": "Enables code lens for 'cells' in a Python file.",
+    "deepnote.configuration.deepnote.enableCellCodeLens.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.codeLens.enable.",
+    "deepnote.configuration.deepnote.enableAutoMoveToNextCell.description": "Enables moving to the next cell when clicking on a 'Run Cell' code lens.",
+    "deepnote.configuration.deepnote.enableAutoMoveToNextCell.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.textEditor.autoMoveToNextCell.",
+    "deepnote.configuration.deepnote.allowUnauthorizedRemoteConnection.description": "Allow for connecting the Interactive window to a https Jupyter server that does not have valid certificates. This can be a security risk, so only use it for known and trusted servers.",
+    "deepnote.configuration.deepnote.codeLenses.description": "Set of commands to put as code lens above a cell.",
+    "deepnote.configuration.deepnote.codeLenses.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.codeLens.commands.",
+    "deepnote.configuration.deepnote.debugCodeLenses.description": "Set of debug commands to put as code lens above a cell while debugging.",
+    "deepnote.configuration.deepnote.debugCodeLenses.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.codeLens.debugCommands.",
+    "deepnote.configuration.deepnote.debugpyDistPath.description": "Path to debugpy bits for debugging cells.",
+    "deepnote.configuration.deepnote.stopOnFirstLineWhileDebugging.description": "When debugging a cell, stop on the first line.",
+    "deepnote.configuration.deepnote.disableJupyterAutoStart.description": "When true, disables Jupyter from being automatically started for you. You must instead run a cell to start deepnote.",
+    "deepnote.configuration.deepnote.addGotoCodeLenses.description": {
         "message": "After running a cell, add a 'Goto' code lens on the cell. Note, disabling all code lenses disables this code lens as well.",
         "comment": ["{Locked='Goto'}"]
     },
-    "jupyter.configuration.jupyter.addGotoCodeLenses.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.codeLens.enableGotoCell.",
-    "jupyter.configuration.jupyter.kernels.filter.markdownDescription": "List of Python environments to be excluded from the kernel picker.",
-    "jupyter.configuration.jupyter.interactiveWindowMode.description": {
+    "deepnote.configuration.deepnote.addGotoCodeLenses.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.codeLens.enableGotoCell.",
+    "deepnote.configuration.deepnote.kernels.filter.markdownDescription": "List of Python environments to be excluded from the kernel picker.",
+    "deepnote.configuration.deepnote.interactiveWindowMode.description": {
         "message": "Behavior of the Interactive Window. 'perFile' will create a new interactive window for every file that runs a cell. 'single' allows a single window. 'multiple' allows the creation of multiple.",
         "comment": ["{Locked='perFile'}", "{Locked=\"'single'\"}", "{Locked=\"'multiple'\"}"]
     },
-    "jupyter.configuration.jupyter.interactiveWindowNotebookRepl.description": "Experimental. The interactive window will use a notebook as the editor model.",
-    "jupyter.configuration.jupyter.interactiveWindowMode.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.creationMode.",
-    "jupyter.configuration.jupyter.pythonCellFolding.description": "Enable folding regions for code cells in Python files. This setting requires a reload of VS Code.",
-    "jupyter.configuration.jupyter.pythonCellFolding.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.textEditor.cellFolding.",
-    "jupyter.configuration.jupyter.interactiveWindowViewColumn.description": {
+    "deepnote.configuration.deepnote.interactiveWindowNotebookRepl.description": "Experimental. The interactive window will use a notebook as the editor model.",
+    "deepnote.configuration.deepnote.interactiveWindowMode.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.creationMode.",
+    "deepnote.configuration.deepnote.pythonCellFolding.description": "Enable folding regions for code cells in Python files. This setting requires a reload of VS Code.",
+    "deepnote.configuration.deepnote.pythonCellFolding.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.textEditor.cellFolding.",
+    "deepnote.configuration.deepnote.interactiveWindowViewColumn.description": {
         "message": "Where to open an Interactive Window that is not associated with a Python file. 'beside' will open the interactive window to the right of the active editor. 'active' will open the interactive window in place of the active editor. 'secondGroup' will open the interactive window in the second editor group.",
         "comment": ["{Locked='beside'}", "{Locked=\"'active'\"}", "{Locked=\"'secondGroup'\"}"]
     },
-    "jupyter.configuration.jupyter.interactiveWindowViewColumn.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.viewColumn.",
-    "jupyter.configuration.jupyter.magicCommandsAsComments.description": "Uncomment shell assignments (#!), line magic (#!%) and cell magic (#!%%) when parsing code cells.",
-    "jupyter.configuration.jupyter.magicCommandsAsComments.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.textEditor.magicCommandsAsComments.",
-    "jupyter.configuration.jupyter.pythonExportMethod.description": {
+    "deepnote.configuration.deepnote.interactiveWindowViewColumn.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.viewColumn.",
+    "deepnote.configuration.deepnote.magicCommandsAsComments.description": "Uncomment shell assignments (#!), line magic (#!%) and cell magic (#!%%) when parsing code cells.",
+    "deepnote.configuration.deepnote.magicCommandsAsComments.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.textEditor.magicCommandsAsComments.",
+    "deepnote.configuration.deepnote.pythonExportMethod.description": {
         "message": "The method to use when exporting a notebook to a Python file. 'direct' will copy over the code directly as is. 'commentMagics' will comment out lines starting with line magics (%), cell magics (%%), and shell commands(!). 'nbconvert' will install nbconvert and use that for the conversion which can translate iPython syntax into Python syntax.",
         "comment": ["{Locked=\"'direct'\"}", "{Locked=\"'commentMagics'\"}", "{Locked=\"'nbconvert'\"}"]
     },
-    "jupyter.configuration.jupyter.runStartupCommands.description": {
+    "deepnote.configuration.deepnote.runStartupCommands.description": {
         "message": "A series of Python instructions or iPython magic commands. Can be either an array of strings or a single string with commands separated by '\\n'. Commands will be silently executed whenever a Jupyter kernel is started or restarted. For instance, set this to '%load_ext autoreload\n%autoreload 2' to automatically reload changes made to imported files without having to restart the Jupyter kernel.",
         "comment": ["{Locked='%load_ext autoreload\\n%autoreload 2'}"]
     },
-    "jupyter.configuration.jupyter.debugJustMyCode.description": "When debugging, only step through user-written code. Disable this to allow stepping into library code.",
-    "jupyter.configuration.jupyter.showOutlineButtonInNotebookToolbar.description": "Show the Outline button in the Jupyter notebook toolbar.",
-    "jupyter.configuration.jupyter.newCellOnRunLast.description": "Append a new empty cell to an interactive window file on running the currently last cell.",
-    "jupyter.configuration.jupyter.newCellOnRunLast.deprecationMessage": "This setting has been deprecated in favor of jupyter.interactiveWindow.textEditor.autoAddNewCell.",
-    "jupyter.configuration.jupyter.pythonCompletionTriggerCharacters.description": "Characters which trigger auto completion on a Python Jupyter kernel.",
-    "jupyter.configuration.jupyter.pythonCompletionTriggerCharacters.deprecationMessage": "This setting has been deprecated in favor of jupyter.completionTriggerCharacters.",
-    "jupyter.configuration.jupyter.completionTriggerCharacters.markdownDescription": "Mapping of characters which trigger auto completion in a Jupyter kernel language. Following is an example of trigger characters for rust and julia kernel languages:\n```json \n{\n  \"julia\": [\".\"],\n  \"rust\": [\".\",\":\"] \n}\n```",
-    "jupyter.configuration.jupyter.logKernelOutputSeparately.description": "Creates separate output panels for kernels/Jupyter server console output",
-    "jupyter.configuration.jupyter.excludeUserSitePackages.description": {
+    "deepnote.configuration.deepnote.debugJustMyCode.description": "When debugging, only step through user-written code. Disable this to allow stepping into library code.",
+    "deepnote.configuration.deepnote.showOutlineButtonInNotebookToolbar.description": "Show the Outline button in the Jupyter notebook toolbar.",
+    "deepnote.configuration.deepnote.newCellOnRunLast.description": "Append a new empty cell to an interactive window file on running the currently last cell.",
+    "deepnote.configuration.deepnote.newCellOnRunLast.deprecationMessage": "This setting has been deprecated in favor of deepnote.interactiveWindow.textEditor.autoAddNewCell.",
+    "deepnote.configuration.deepnote.pythonCompletionTriggerCharacters.description": "Characters which trigger auto completion on a Python Jupyter kernel.",
+    "deepnote.configuration.deepnote.pythonCompletionTriggerCharacters.deprecationMessage": "This setting has been deprecated in favor of deepnote.completionTriggerCharacters.",
+    "deepnote.configuration.deepnote.completionTriggerCharacters.markdownDescription": "Mapping of characters which trigger auto completion in a Jupyter kernel language. Following is an example of trigger characters for rust and julia kernel languages:\n```json \n{\n  \"julia\": [\".\"],\n  \"rust\": [\".\",\":\"] \n}\n```",
+    "deepnote.configuration.deepnote.logKernelOutputSeparately.description": "Creates separate output panels for kernels/Jupyter server console output",
+    "deepnote.configuration.deepnote.excludeUserSitePackages.description": {
         "message": "Add PYTHONNOUSERSITE to kernels before starting. This prevents global/user site-packages from being used in the PYTHONPATH of the kernel.",
         "comment": ["{Locked='PYTHONNOUSERSITE'}", "{Locked='PYTHONPATH'}"]
     },
-    "jupyter.configuration.jupyter.enableExtendedKernelCompletions.markdownDescription": "Enables Jedi support for extended IntelliSense completions in running Python Jupyter kernels for Python (see this [setting](https://ipython.readthedocs.io/en/stable/config/options/terminal.html?highlight=use_jedi#configtrait-Completer.use_jedi)). This can greatly impact notebook cell execution performance. Use with caution.",
-    "jupyter.configuration.jupyter.enableExtendedKernelCompletions.deprecationMessage": "This setting has been deprecated in favor of jupyter.enableExtendedPythonKernelCompletions.",
-    "jupyter.configuration.jupyter.enableKernelCompletions.markdownDescription": "Enable code completions in Notebooks and Interactive Windows using results from the associated Jupyter kernel.",
-    "jupyter.configuration.jupyter.formatStackTraces.description": "Inject stack frame links into the stored traceback for the notebook.",
-    "jupyter.configuration.jupyter.formatStackTraces.deprecationMessage": "This setting has been deprecated and will be removed in a future release.",
+    "deepnote.configuration.deepnote.enableExtendedKernelCompletions.markdownDescription": "Enables Jedi support for extended IntelliSense completions in running Python Jupyter kernels for Python (see this [setting](https://ipython.readthedocs.io/en/stable/config/options/terminal.html?highlight=use_jedi#configtrait-Completer.use_jedi)). This can greatly impact notebook cell execution performance. Use with caution.",
+    "deepnote.configuration.deepnote.enableExtendedKernelCompletions.deprecationMessage": "This setting has been deprecated in favor of deepnote.enableExtendedPythonKernelCompletions.",
+    "deepnote.configuration.deepnote.enableKernelCompletions.markdownDescription": "Enable code completions in Notebooks and Interactive Windows using results from the associated Jupyter kernel.",
+    "deepnote.configuration.deepnote.formatStackTraces.description": "Inject stack frame links into the stored traceback for the notebook.",
+    "deepnote.configuration.deepnote.formatStackTraces.deprecationMessage": "This setting has been deprecated and will be removed in a future release.",
     "DataScience.exportDialogTitle": {
         "message": "Export to Jupyter Notebook",
         "comment": ["{Locked='Notebook'}"]
@@ -233,7 +233,7 @@
     "DataScience.notebookExportAs.shorttitle": "Export",
     "DataScience.interactiveCopyCell": "Copy Cell",
     "DataScience.runInDedicatedExtensionHost": "Run in Dedicated Extension Host",
-    "jupyter.configuration.jupyter.kernels.trusted.markdownDescription": "Enter fully qualified paths to kernel specification files that are to be trusted. E.g., 'C:\\Program Data\\Jupyter\\kernels\\python3\\kernel.json'.  \n**Note**: Kernels can execute code with user privileges. Click [here](https://aka.ms/JupyterTrustedKernelPaths) for further details.",
+    "deepnote.configuration.deepnote.kernels.trusted.markdownDescription": "Enter fully qualified paths to kernel specification files that are to be trusted. E.g., 'C:\\Program Data\\Jupyter\\kernels\\python3\\kernel.json'.  \n**Note**: Kernels can execute code with user privileges. Click [here](https://aka.ms/JupyterTrustedKernelPaths) for further details.",
     "DataScience.latestExtension": "Download the latest version of the Jupyter Extension",
     "DataScience.refreshDataViewerCommandPalette": "Refresh Data Viewer",
     "DataScience.interactiveClearAllCells": "Clear All",
@@ -241,10 +241,10 @@
     "DataScience.installPythonTitle": "Install Python",
     "DataScience.installPythonExtensionViaKernelPickerTitle": "Install Python Extension",
     "DataScience.switchToRemoteKernelsTitle": "Connect to a Jupyter Server",
-    "jupyter.languageModelTools.configure_notebook.displayName": "Configure Jupyter Notebook",
-    "jupyter.languageModelTools.configure_notebook.userDescription": "Ensure Notebook is ready for use, such as running cells.",
-    "jupyter.languageModelTools.notebook_list_packages.userDescription": "Lists Python packages available in the selected Notebook Kernel.",
-    "jupyter.languageModelTools.notebook_install_packages.userDescription": "Installs Python packages in the selected Notebook Kernel.",
+    "deepnote.languageModelTools.configure_notebook.displayName": "Configure Jupyter Notebook",
+    "deepnote.languageModelTools.configure_notebook.userDescription": "Ensure Notebook is ready for use, such as running cells.",
+    "deepnote.languageModelTools.notebook_list_packages.userDescription": "Lists Python packages available in the selected Notebook Kernel.",
+    "deepnote.languageModelTools.notebook_install_packages.userDescription": "Installs Python packages in the selected Notebook Kernel.",
     "deepnote.notebook.displayName": "Deepnote Notebook",
     "deepnote.commands.refreshExplorer.title": "Refresh Explorer",
     "deepnote.commands.openNotebook.title": "Open Notebook",
diff --git a/src/commands.ts b/src/commands.ts
index 92237164fa..983371cd54 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -43,12 +43,12 @@ export interface ICommandNameArgumentTypeMapping {
     ['workbench.extensions.search']: [string];
     ['editor.action.formatDocument']: [];
     ['editor.action.rename']: [];
-    ['jupyter.selectJupyterInterpreter']: [];
+    ['deepnote.selectJupyterInterpreter']: [];
     ['dataScience.ClearUserProviderJupyterServerCache']: [];
     ['jupyterViewVariables.focus']: [];
-    ['jupyter.selectLocalJupyterServer']: [] | [undefined | string];
-    ['workbench.action.openSettings']: ['jupyter.kernels.excludePythonEnvironments'];
-    ['jupyter.getUsedAzMLServerHandles']: [];
+    ['deepnote.selectLocalJupyterServer']: [] | [undefined | string];
+    ['workbench.action.openSettings']: ['deepnote.kernels.excludePythonEnvironments'];
+    ['deepnote.getUsedAzMLServerHandles']: [];
     [DSCommands.RunCurrentCell]: [];
     [DSCommands.RunCurrentCellAdvance]: [];
     [DSCommands.CreateNewInteractive]: [];
@@ -76,7 +76,7 @@ export interface ICommandNameArgumentTypeMapping {
     ['notebook.cell.collapseCellOutput']: [];
     ['notebook.cell.expandCellOutput']: [];
     ['vscode.openWith']: [Uri, string];
-    ['jupyter.filterKernels']: [never];
+    ['deepnote.filterKernels']: [never];
     ['workbench.action.quickOpen']: [string];
     ['workbench.extensions.installExtension']: [
         Uri | 'ms-toolsai.jupyter' | 'ms-python.python',
@@ -85,9 +85,9 @@ export interface ICommandNameArgumentTypeMapping {
     ['workbench.action.files.openFolder']: [];
     ['workbench.action.openWorkspace']: [];
     ['extension.open']: [string];
-    ['setContext']: [string, ContextKeyValue] | ['jupyter.vscode.channel', Channel];
-    ['jupyter.reloadVSCode']: [string];
-    ['jupyter.runInDedicatedExtensionHost']: [string];
+    ['setContext']: [string, ContextKeyValue] | ['deepnote.vscode.channel', Channel];
+    ['deepnote.reloadVSCode']: [string];
+    ['deepnote.runInDedicatedExtensionHost']: [string];
     ['revealLine']: [{ lineNumber: number; at: 'top' | 'center' | 'bottom' }];
     ['python._loadLanguageServerExtension']: {}[];
     ['python.SelectAndInsertDebugConfiguration']: [TextDocument, Position, CancellationToken];
diff --git a/src/extension.common.ts b/src/extension.common.ts
index 5f98c14739..59ab159eec 100644
--- a/src/extension.common.ts
+++ b/src/extension.common.ts
@@ -172,7 +172,7 @@ export async function postActivateLegacy(context: IExtensionContext, serviceCont
     sendTelemetryEvent(Telemetry.ExperimentLoad, { duration });
 
     // "initialize" "services"
-    commands.executeCommand('setContext', 'jupyter.vscode.channel', getVSCodeChannel()).then(noop, noop);
+    commands.executeCommand('setContext', 'deepnote.vscode.channel', getVSCodeChannel()).then(noop, noop);
 
     // "activate" everything else
     serviceContainer.get<IExtensionActivationManager>(IExtensionActivationManager).activate();
diff --git a/src/extension.node.ts b/src/extension.node.ts
index 4582cc1135..ef0eeb864e 100644
--- a/src/extension.node.ts
+++ b/src/extension.node.ts
@@ -222,9 +222,9 @@ async function activateLegacy(
             workspace.getConfiguration('jupyter').get<boolean>('development', false));
     serviceManager.addSingletonInstance<boolean>(IsDevMode, isDevMode);
     if (isDevMode) {
-        commands.executeCommand('setContext', 'jupyter.development', true).then(noop, noop);
+        commands.executeCommand('setContext', 'deepnote.development', true).then(noop, noop);
     }
-    commands.executeCommand('setContext', 'jupyter.webExtension', false).then(noop, noop);
+    commands.executeCommand('setContext', 'deepnote.webExtension', false).then(noop, noop);
 
     // Set the logger home dir (we can compute this in a node app)
     setHomeDirectory(homedir());
diff --git a/src/extension.web.ts b/src/extension.web.ts
index 46035197f6..e05a1575d7 100644
--- a/src/extension.web.ts
+++ b/src/extension.web.ts
@@ -178,9 +178,9 @@ async function activateLegacy(
 
     serviceManager.addSingletonInstance<boolean>(IsDevMode, isDevMode);
     if (isDevMode) {
-        commands.executeCommand('setContext', 'jupyter.development', true).then(noop, noop);
+        commands.executeCommand('setContext', 'deepnote.development', true).then(noop, noop);
     }
-    commands.executeCommand('setContext', 'jupyter.webExtension', true).then(noop, noop);
+    commands.executeCommand('setContext', 'deepnote.webExtension', true).then(noop, noop);
 
     // Register the rest of the types (platform is first because it's needed by others)
     registerPlatformTypes(serviceManager);
diff --git a/src/interactive-window/editor-integration/cellRangeCache.ts b/src/interactive-window/editor-integration/cellRangeCache.ts
index 96db3db495..9f133c4cff 100644
--- a/src/interactive-window/editor-integration/cellRangeCache.ts
+++ b/src/interactive-window/editor-integration/cellRangeCache.ts
@@ -61,7 +61,7 @@ export class CellRangeCache implements ICellRangeCache {
         ) {
             // set the context to false so our command doesn't run for other files
             const hasCellsContext = new ContextKey(EditorContexts.HasCodeCells);
-            hasCellsContext.set(false).catch((ex) => logger.warn('Failed to set jupyter.HasCodeCells context', ex));
+            hasCellsContext.set(false).catch((ex) => logger.warn('Failed to set deepnote.HasCodeCells context', ex));
             this.updateContextKeys(false);
         } else {
             this.updateContextKeys(activeEditor.document);
@@ -71,7 +71,7 @@ export class CellRangeCache implements ICellRangeCache {
     private onSettingChanged(e: ConfigurationChangeEvent) {
         this.cache.clear();
 
-        if (e.affectsConfiguration('jupyter.interactiveWindow.textEditor.executeSelection')) {
+        if (e.affectsConfiguration('deepnote.interactiveWindow.textEditor.executeSelection')) {
             const settings = this.configService.getSettings(undefined);
             this.cachedOwnsSetting = settings.sendSelectionToInteractiveWindow;
             this.updateContextKeys();
diff --git a/src/interactive-window/editor-integration/cellRangeCache.unit.test.ts b/src/interactive-window/editor-integration/cellRangeCache.unit.test.ts
index 252604fbcf..8f156f190e 100644
--- a/src/interactive-window/editor-integration/cellRangeCache.unit.test.ts
+++ b/src/interactive-window/editor-integration/cellRangeCache.unit.test.ts
@@ -53,8 +53,8 @@ suite('DataScienceCodeLensProvider Unit Tests', () => {
         createCodeLensFactory().getCellRanges(document.object);
 
         // verify context keys set
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.ownsSelection', true)).atLeast(1);
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.hascodecells', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.ownsSelection', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.hascodecells', true)).atLeast(1);
     });
 
     test('Having no code lenses will set context keys to false', async () => {
@@ -68,8 +68,8 @@ suite('DataScienceCodeLensProvider Unit Tests', () => {
         createCodeLensFactory().getCellRanges(document.object);
 
         // verify context keys set
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.ownsSelection', true)).atLeast(1);
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.hascodecells', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.ownsSelection', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.hascodecells', true)).atLeast(1);
     });
 
     test('Having no code lenses but ownership setting true will set context keys correctly', async () => {
@@ -83,7 +83,7 @@ suite('DataScienceCodeLensProvider Unit Tests', () => {
         createCodeLensFactory().getCellRanges(document.object);
 
         // verify context keys set
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.ownsSelection', true)).atLeast(1);
-        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'jupyter.hascodecells', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.ownsSelection', true)).atLeast(1);
+        verify(mockedVSCodeNamespaces.commands.executeCommand('setContext', 'deepnote.hascodecells', true)).atLeast(1);
     });
 });
diff --git a/src/kernels/errors/kernelErrorHandler.ts b/src/kernels/errors/kernelErrorHandler.ts
index c8cca83f24..71751b7eea 100644
--- a/src/kernels/errors/kernelErrorHandler.ts
+++ b/src/kernels/errors/kernelErrorHandler.ts
@@ -601,7 +601,7 @@ function getCombinedErrorMessage(prefix: string = '', message: string = '') {
     if (
         !doesErrorHaveMarkdownLinks(errorMessage) &&
         errorMessage.length &&
-        errorMessage.indexOf('command:jupyter.viewOutput') === -1
+        errorMessage.indexOf('command:deepnote.viewOutput') === -1
     ) {
         return `${errorMessage.endsWith('.') ? errorMessage : errorMessage + '.'} \n${
             DataScience.viewJupyterLogForFurtherInfo
diff --git a/src/kernels/errors/kernelErrorHandler.unit.test.ts b/src/kernels/errors/kernelErrorHandler.unit.test.ts
index 31c2181ca5..852d58aaa3 100644
--- a/src/kernels/errors/kernelErrorHandler.unit.test.ts
+++ b/src/kernels/errors/kernelErrorHandler.unit.test.ts
@@ -814,7 +814,7 @@ Failed to run jupyter as observable with args notebook --no-browser --notebook-d
                 [
                     'Failed to start the Kernel. ',
                     'hello word does not have attribute named abc. ',
-                    'View Jupyter [log](command:jupyter.viewOutput) for further details.'
+                    'View Jupyter [log](command:deepnote.viewOutput) for further details.'
                 ].join('\n')
             );
         });
@@ -837,7 +837,7 @@ Failed to run jupyter as observable with args notebook --no-browser --notebook-d
                 [
                     'Failed to restart the Kernel. ',
                     'hello word does not have attribute named abc. ',
-                    'View Jupyter [log](command:jupyter.viewOutput) for further details.'
+                    'View Jupyter [log](command:deepnote.viewOutput) for further details.'
                 ].join('\n')
             );
         });
@@ -1101,7 +1101,7 @@ Failed to run jupyter as observable with args notebook --no-browser --notebook-d
             verify(uriStorage.remove(deepEqual(serverProviderHandle))).never();
         });
         function verifyErrorMessage(message: string, linkInfo?: string) {
-            message = message.includes('command:jupyter.viewOutput')
+            message = message.includes('command:deepnote.viewOutput')
                 ? message
                 : `${message} \n${DataScience.viewJupyterLogForFurtherInfo}`;
             if (linkInfo) {
diff --git a/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.node.ts b/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.node.ts
index 6c2eac26b6..1b6ed72055 100644
--- a/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.node.ts
+++ b/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.node.ts
@@ -19,7 +19,7 @@ export class JupyterInterpreterSelectionCommand implements IExtensionSyncActivat
     ) {}
     public activate() {
         this.disposables.push(
-            commands.registerCommand('jupyter.selectJupyterInterpreter', () => {
+            commands.registerCommand('deepnote.selectJupyterInterpreter', () => {
                 this.service.selectInterpreter().catch(noop);
             })
         );
diff --git a/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.unit.test.ts b/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.unit.test.ts
index fef8e649b4..7cd50ca8f4 100644
--- a/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.unit.test.ts
+++ b/src/kernels/jupyter/interpreter/jupyterInterpreterSelectionCommand.unit.test.ts
@@ -25,17 +25,17 @@ suite('Jupyter Interpreter Command', () => {
     test('Activation should register command', async () => {
         const disposable = mock(Disposable);
         when(
-            mockedVSCodeNamespaces.commands.registerCommand('jupyter.selectJupyterInterpreter', anything())
+            mockedVSCodeNamespaces.commands.registerCommand('deepnote.selectJupyterInterpreter', anything())
         ).thenReturn(instance(disposable));
 
         await interpreterCommand.activate();
 
-        verify(mockedVSCodeNamespaces.commands.registerCommand('jupyter.selectJupyterInterpreter', anything())).once();
+        verify(mockedVSCodeNamespaces.commands.registerCommand('deepnote.selectJupyterInterpreter', anything())).once();
     });
     test('Command handler must be jupyter interpreter selection', async () => {
         const disposable = mock(Disposable);
         let handler: Function | undefined;
-        when(mockedVSCodeNamespaces.commands.registerCommand('jupyter.selectJupyterInterpreter', anything())).thenCall(
+        when(mockedVSCodeNamespaces.commands.registerCommand('deepnote.selectJupyterInterpreter', anything())).thenCall(
             (_, cb: Function) => {
                 handler = cb;
                 return instance(disposable);
@@ -44,7 +44,7 @@ suite('Jupyter Interpreter Command', () => {
 
         await interpreterCommand.activate();
 
-        verify(mockedVSCodeNamespaces.commands.registerCommand('jupyter.selectJupyterInterpreter', anything())).once();
+        verify(mockedVSCodeNamespaces.commands.registerCommand('deepnote.selectJupyterInterpreter', anything())).once();
         assert.isFunction(handler);
 
         // Invoking handler must select jupyter interpreter.
diff --git a/src/notebooks/controllers/commands/installPythonControllerCommands.ts b/src/notebooks/controllers/commands/installPythonControllerCommands.ts
index 0fd36cd124..c0fff7844f 100644
--- a/src/notebooks/controllers/commands/installPythonControllerCommands.ts
+++ b/src/notebooks/controllers/commands/installPythonControllerCommands.ts
@@ -60,7 +60,7 @@ export class InstallPythonControllerCommands implements IExtensionSyncActivation
             await commands.executeCommand('python.installPython');
         } else if (selection === Common.reload) {
             sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'reload' });
-            await commands.executeCommand('jupyter.reloadVSCode', DataScience.reloadRequired);
+            await commands.executeCommand('deepnote.reloadVSCode', DataScience.reloadRequired);
         } else {
             sendTelemetryEvent(Telemetry.PythonNotInstalled, undefined, { action: 'dismissed' });
         }
diff --git a/src/notebooks/controllers/ipywidgets/message/ipyWidgetMessageDispatcher.ts b/src/notebooks/controllers/ipywidgets/message/ipyWidgetMessageDispatcher.ts
index c990b2e1ca..7e9dfb86b0 100644
--- a/src/notebooks/controllers/ipywidgets/message/ipyWidgetMessageDispatcher.ts
+++ b/src/notebooks/controllers/ipywidgets/message/ipyWidgetMessageDispatcher.ts
@@ -92,7 +92,7 @@ export class IPyWidgetMessageDispatcher implements IIPyWidgetMessageDispatcher {
         // Always register this comm target.
         // Possible auto start is disabled, and when cell is executed with widget stuff, this comm target will not have
         // been registered, in which case kaboom. As we know this is always required, pre-register this.
-        this.pendingTargetNames.add('jupyter.widget');
+        this.pendingTargetNames.add('deepnote.widget');
         kernelProvider.onDidStartKernel(
             (e) => {
                 if (e.notebook === document) {
diff --git a/src/notebooks/controllers/kernelSource/kernelSourceCommandHandler.ts b/src/notebooks/controllers/kernelSource/kernelSourceCommandHandler.ts
index 39e1feb8f7..581171ecf2 100644
--- a/src/notebooks/controllers/kernelSource/kernelSourceCommandHandler.ts
+++ b/src/notebooks/controllers/kernelSource/kernelSourceCommandHandler.ts
@@ -80,7 +80,7 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
                             {
                                 label: DataScience.localPythonEnvironments,
                                 documentation: Uri.parse('https://aka.ms/vscodeJupyterExtKernelPickerPythonEnv'),
-                                command: 'jupyter.kernel.selectLocalPythonEnvironment'
+                                command: 'deepnote.kernel.selectLocalPythonEnvironment'
                             }
                         ];
                     }
@@ -93,7 +93,7 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
                             {
                                 label: DataScience.localPythonEnvironments,
                                 documentation: Uri.parse('https://aka.ms/vscodeJupyterExtKernelPickerPythonEnv'),
-                                command: 'jupyter.kernel.selectLocalPythonEnvironment'
+                                command: 'deepnote.kernel.selectLocalPythonEnvironment'
                             }
                         ];
                     }
@@ -131,7 +131,7 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
                         {
                             label: DataScience.localKernelSpecs,
                             documentation: Uri.parse('https://aka.ms/vscodeJupyterExtKernelPickerJupyterKernels'),
-                            command: 'jupyter.kernel.selectLocalKernelSpec'
+                            command: 'deepnote.kernel.selectLocalKernelSpec'
                         }
                     ];
 
@@ -143,21 +143,21 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
             this.kernelFinder.onDidChangeKernels(() => registerKernelSpecsSource(), this, this.localDisposables);
             this.localDisposables.push(
                 commands.registerCommand(
-                    'jupyter.kernel.selectLocalKernelSpec',
+                    'deepnote.kernel.selectLocalKernelSpec',
                     this.onSelectLocalKernel.bind(this, ContributedKernelFinderKind.LocalKernelSpec),
                     this
                 )
             );
             this.localDisposables.push(
                 commands.registerCommand(
-                    'jupyter.kernel.selectLocalPythonEnvironment',
+                    'deepnote.kernel.selectLocalPythonEnvironment',
                     this.onSelectLocalKernel.bind(this, ContributedKernelFinderKind.LocalPythonEnvironment),
                     this
                 )
             );
         }
         this.localDisposables.push(
-            commands.registerCommand('jupyter.kernel.selectJupyterServerKernel', this.onSelectRemoteKernel, this)
+            commands.registerCommand('deepnote.kernel.selectJupyterServerKernel', this.onSelectRemoteKernel, this)
         );
         const uriRegistration =
             ServiceContainer.instance.get<IJupyterServerProviderRegistry>(IJupyterServerProviderRegistry);
@@ -188,7 +188,7 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
                                 return collection.documentation;
                             },
                             command: {
-                                command: 'jupyter.kernel.selectJupyterServerKernel',
+                                command: 'deepnote.kernel.selectJupyterServerKernel',
                                 arguments: [collection.extensionId, collection.id],
                                 title: collection.label
                             }
@@ -207,7 +207,7 @@ export class KernelSourceCommandHandler implements IExtensionSyncActivationServi
                                 return collection.documentation;
                             },
                             command: {
-                                command: 'jupyter.kernel.selectJupyterServerKernel',
+                                command: 'deepnote.kernel.selectJupyterServerKernel',
                                 arguments: [collection.extensionId, collection.id],
                                 title: collection.label
                             }
diff --git a/src/notebooks/outputs/linkProvider.ts b/src/notebooks/outputs/linkProvider.ts
index ebe2cd7392..d7a57f4b20 100644
--- a/src/notebooks/outputs/linkProvider.ts
+++ b/src/notebooks/outputs/linkProvider.ts
@@ -6,8 +6,8 @@ export const LineQueryRegex = /line=(\d+)/;
 // The following list of commands represent those that can be executed
 // in a markdown cell using the syntax: https://command:[my.vscode.command].
 export const linkCommandAllowList = [
-    'jupyter.latestExtension',
-    'jupyter.viewOutput',
+    'deepnote.latestExtension',
+    'deepnote.viewOutput',
     'workbench.action.openSettings',
-    'jupyter.enableLoadingWidgetScriptsFromThirdPartySource'
+    'deepnote.enableLoadingWidgetScriptsFromThirdPartySource'
 ];
diff --git a/src/platform/common/application/commands/reloadCommand.node.ts b/src/platform/common/application/commands/reloadCommand.node.ts
index 2744d8e427..6827f638bc 100644
--- a/src/platform/common/application/commands/reloadCommand.node.ts
+++ b/src/platform/common/application/commands/reloadCommand.node.ts
@@ -13,7 +13,7 @@ import { commands, window } from 'vscode';
 @injectable()
 export class ReloadVSCodeCommandHandler implements IExtensionSyncActivationService {
     public activate() {
-        commands.registerCommand('jupyter.reloadVSCode', this.onReloadVSCode, this);
+        commands.registerCommand('deepnote.reloadVSCode', this.onReloadVSCode, this);
     }
     private async onReloadVSCode(message: string) {
         const item = await window.showInformationMessage(message, Common.reload);
diff --git a/src/platform/common/application/commands/reloadCommand.unit.test.ts b/src/platform/common/application/commands/reloadCommand.unit.test.ts
index 7954d8dc21..a58c2c7761 100644
--- a/src/platform/common/application/commands/reloadCommand.unit.test.ts
+++ b/src/platform/common/application/commands/reloadCommand.unit.test.ts
@@ -19,7 +19,7 @@ suite('Common Commands ReloadCommand', () => {
     teardown(() => resetVSCodeMocks());
 
     test('Confirm command handler is added', async () => {
-        verify(mockedVSCodeNamespaces.commands.registerCommand('jupyter.reloadVSCode', anything(), anything())).once();
+        verify(mockedVSCodeNamespaces.commands.registerCommand('deepnote.reloadVSCode', anything(), anything())).once();
     });
     test('Display prompt to reload VS Code with message passed into command', async () => {
         const message = 'Hello World!';
diff --git a/src/platform/common/application/commands/runInDedicatedExtensionHost.node.ts b/src/platform/common/application/commands/runInDedicatedExtensionHost.node.ts
index bf9c27d4cd..f21ce30f9e 100644
--- a/src/platform/common/application/commands/runInDedicatedExtensionHost.node.ts
+++ b/src/platform/common/application/commands/runInDedicatedExtensionHost.node.ts
@@ -14,7 +14,7 @@ import { workspace } from 'vscode';
 @injectable()
 export class RunInDedicatedExtensionHostCommandHandler implements IExtensionSyncActivationService {
     public activate() {
-        commands.registerCommand('jupyter.runInDedicatedExtensionHost', this.updateAffinity, this);
+        commands.registerCommand('deepnote.runInDedicatedExtensionHost', this.updateAffinity, this);
     }
     private async updateAffinity() {
         const affinity = workspace.getConfiguration('extensions').get('experimental.affinity') as
diff --git a/src/platform/common/cache.ts b/src/platform/common/cache.ts
index 481105a2d9..b02b2de2c9 100644
--- a/src/platform/common/cache.ts
+++ b/src/platform/common/cache.ts
@@ -27,7 +27,7 @@ const GlobalMementoKeyPrefixesToRemove = [
     'LOCAL_KERNEL_PYTHON_AND_RELATED_SPECS_CACHE_KEY_V_2022_10',
     'user-jupyter-server-uri-list-v2',
     'REGISTRATION_ID_EXTENSION_OWNER_MEMENTO_KEY',
-    'jupyter.jupyterServer.uriList',
+    'deepnote.jupyterServer.uriList',
     'CACHE_KEY_FOR_JUPYTER_KERNEL_PATHS_.'
 ];
 @injectable()
diff --git a/src/platform/common/constants.ts b/src/platform/common/constants.ts
index d6557559c5..12457f3757 100644
--- a/src/platform/common/constants.ts
+++ b/src/platform/common/constants.ts
@@ -42,7 +42,7 @@ export namespace Settings {
     export const JupyterServerRemoteLaunchNameSeparator = '\n';
     export const JupyterServerRemoteLaunchService = JVSC_EXTENSION_ID;
     export const JupyterServerUriListMax = 10;
-    // If this timeout expires, ignore the completion request sent to Jupyter.
+    // If this timeout expires, ignore the completion request sent to deepnote.
     export var IntellisenseTimeout = 2_000;
     export const IntellisenseResolveTimeout = 5_000;
 }
@@ -79,7 +79,7 @@ export namespace Identifiers {
     export const MatplotLibDefaultParams = '_VSCode_defaultMatplotlib_Params';
     export const MatplotLibFigureFormats = '_VSCode_matplotLib_FigureFormats';
     export const DefaultCodeCellMarker = '# %%';
-    export const DefaultCommTarget = 'jupyter.widget';
+    export const DefaultCommTarget = 'deepnote.widget';
     export const ALL_VARIABLES = 'ALL_VARIABLES';
     export const KERNEL_VARIABLES = 'KERNEL_VARIABLES';
     export const DEBUGGER_VARIABLES = 'DEBUGGER_VARIABLES';
@@ -170,57 +170,57 @@ export enum CommandSource {
 }
 
 export namespace Commands {
-    export const RunAllCells = 'jupyter.runallcells';
-    export const RunAllCellsAbove = 'jupyter.runallcellsabove';
-    export const RunCellAndAllBelow = 'jupyter.runcellandallbelow';
-    export const RunAllCellsAbovePalette = 'jupyter.runallcellsabove.palette';
-    export const RunCellAndAllBelowPalette = 'jupyter.runcurrentcellandallbelow.palette';
-    export const RunToLine = 'jupyter.runtoline';
-    export const RunFromLine = 'jupyter.runfromline';
-    export const RunCell = 'jupyter.runcell';
-    export const RunCurrentCell = 'jupyter.runcurrentcell';
-    export const RunCurrentCellAdvance = 'jupyter.runcurrentcelladvance';
-    export const CreateNewInteractive = 'jupyter.createnewinteractive';
-    export const ImportNotebookFile = 'jupyter.importnotebookfile';
-    export const ExportFileAsNotebook = 'jupyter.exportfileasnotebook';
-    export const InterruptKernel = 'jupyter.interruptkernel';
-    export const RestartKernel = 'jupyter.restartkernel';
-    export const RestartKernelAndRunAllCells = 'jupyter.restartkernelandrunallcells';
-    export const RestartKernelAndRunUpToSelectedCell = 'jupyter.restartkernelandrunuptoselectedcell';
-    export const NotebookEditorRemoveAllCells = 'jupyter.notebookeditor.removeallcells';
-    export const NotebookEditorRunAllCells = 'jupyter.notebookeditor.runallcells';
-    export const NotebookEditorRunSelectedCell = 'jupyter.notebookeditor.runselectedcell';
-    export const NotebookEditorRunFocusedCell = 'jupyter.notebookeditor.runfocusedcell';
-    export const NotebookEditorAddCellBelow = 'jupyter.notebookeditor.addcellbelow';
-    export const ExpandAllCells = 'jupyter.expandallcells';
-    export const CollapseAllCells = 'jupyter.collapseallcells';
-    export const ExecSelectionInInteractiveWindow = 'jupyter.execSelectionInteractive';
-    export const RunFileInInteractiveWindows = 'jupyter.runFileInteractive';
-    export const DebugFileInInteractiveWindows = 'jupyter.debugFileInteractive';
-    export const AddCellBelow = 'jupyter.addcellbelow';
-    export const DebugCurrentCellPalette = 'jupyter.debugcurrentcell.palette';
-    export const DebugCell = 'jupyter.debugcell';
-    export const DebugStepOver = 'jupyter.debugstepover';
-    export const DebugContinue = 'jupyter.debugcontinue';
-    export const DebugStop = 'jupyter.debugstop';
-    export const RunCurrentCellAndAddBelow = 'jupyter.runcurrentcellandaddbelow';
-    export const InsertCellBelowPosition = 'jupyter.insertCellBelowPosition';
-    export const InsertCellBelow = 'jupyter.insertCellBelow';
-    export const InsertCellAbove = 'jupyter.insertCellAbove';
-    export const DeleteCells = 'jupyter.deleteCells';
-    export const SelectCell = 'jupyter.selectCell';
-    export const SelectCellContents = 'jupyter.selectCellContents';
-    export const ExtendSelectionByCellAbove = 'jupyter.extendSelectionByCellAbove';
-    export const ExtendSelectionByCellBelow = 'jupyter.extendSelectionByCellBelow';
-    export const MoveCellsUp = 'jupyter.moveCellsUp';
-    export const MoveCellsDown = 'jupyter.moveCellsDown';
-    export const ChangeCellToMarkdown = 'jupyter.changeCellToMarkdown';
-    export const ChangeCellToCode = 'jupyter.changeCellToCode';
-    export const GotoNextCellInFile = 'jupyter.gotoNextCellInFile';
-    export const GotoPrevCellInFile = 'jupyter.gotoPrevCellInFile';
-    export const ScrollToCell = 'jupyter.scrolltocell';
-    export const CreateNewNotebook = 'jupyter.createnewnotebook';
-    export const ViewJupyterOutput = 'jupyter.viewOutput';
+    export const RunAllCells = 'deepnote.runallcells';
+    export const RunAllCellsAbove = 'deepnote.runallcellsabove';
+    export const RunCellAndAllBelow = 'deepnote.runcellandallbelow';
+    export const RunAllCellsAbovePalette = 'deepnote.runallcellsabove.palette';
+    export const RunCellAndAllBelowPalette = 'deepnote.runcurrentcellandallbelow.palette';
+    export const RunToLine = 'deepnote.runtoline';
+    export const RunFromLine = 'deepnote.runfromline';
+    export const RunCell = 'deepnote.runcell';
+    export const RunCurrentCell = 'deepnote.runcurrentcell';
+    export const RunCurrentCellAdvance = 'deepnote.runcurrentcelladvance';
+    export const CreateNewInteractive = 'deepnote.createnewinteractive';
+    export const ImportNotebookFile = 'deepnote.importnotebookfile';
+    export const ExportFileAsNotebook = 'deepnote.exportfileasnotebook';
+    export const InterruptKernel = 'deepnote.interruptkernel';
+    export const RestartKernel = 'deepnote.restartkernel';
+    export const RestartKernelAndRunAllCells = 'deepnote.restartkernelandrunallcells';
+    export const RestartKernelAndRunUpToSelectedCell = 'deepnote.restartkernelandrunuptoselectedcell';
+    export const NotebookEditorRemoveAllCells = 'deepnote.notebookeditor.removeallcells';
+    export const NotebookEditorRunAllCells = 'deepnote.notebookeditor.runallcells';
+    export const NotebookEditorRunSelectedCell = 'deepnote.notebookeditor.runselectedcell';
+    export const NotebookEditorRunFocusedCell = 'deepnote.notebookeditor.runfocusedcell';
+    export const NotebookEditorAddCellBelow = 'deepnote.notebookeditor.addcellbelow';
+    export const ExpandAllCells = 'deepnote.expandallcells';
+    export const CollapseAllCells = 'deepnote.collapseallcells';
+    export const ExecSelectionInInteractiveWindow = 'deepnote.execSelectionInteractive';
+    export const RunFileInInteractiveWindows = 'deepnote.runFileInteractive';
+    export const DebugFileInInteractiveWindows = 'deepnote.debugFileInteractive';
+    export const AddCellBelow = 'deepnote.addcellbelow';
+    export const DebugCurrentCellPalette = 'deepnote.debugcurrentcell.palette';
+    export const DebugCell = 'deepnote.debugcell';
+    export const DebugStepOver = 'deepnote.debugstepover';
+    export const DebugContinue = 'deepnote.debugcontinue';
+    export const DebugStop = 'deepnote.debugstop';
+    export const RunCurrentCellAndAddBelow = 'deepnote.runcurrentcellandaddbelow';
+    export const InsertCellBelowPosition = 'deepnote.insertCellBelowPosition';
+    export const InsertCellBelow = 'deepnote.insertCellBelow';
+    export const InsertCellAbove = 'deepnote.insertCellAbove';
+    export const DeleteCells = 'deepnote.deleteCells';
+    export const SelectCell = 'deepnote.selectCell';
+    export const SelectCellContents = 'deepnote.selectCellContents';
+    export const ExtendSelectionByCellAbove = 'deepnote.extendSelectionByCellAbove';
+    export const ExtendSelectionByCellBelow = 'deepnote.extendSelectionByCellBelow';
+    export const MoveCellsUp = 'deepnote.moveCellsUp';
+    export const MoveCellsDown = 'deepnote.moveCellsDown';
+    export const ChangeCellToMarkdown = 'deepnote.changeCellToMarkdown';
+    export const ChangeCellToCode = 'deepnote.changeCellToCode';
+    export const GotoNextCellInFile = 'deepnote.gotoNextCellInFile';
+    export const GotoPrevCellInFile = 'deepnote.gotoPrevCellInFile';
+    export const ScrollToCell = 'deepnote.scrolltocell';
+    export const CreateNewNotebook = 'deepnote.createnewnotebook';
+    export const ViewJupyterOutput = 'deepnote.viewOutput';
     export const RefreshDeepnoteExplorer = 'deepnote.refreshExplorer';
     export const OpenDeepnoteNotebook = 'deepnote.openNotebook';
     export const OpenDeepnoteFile = 'deepnote.openFile';
@@ -249,33 +249,33 @@ export namespace Commands {
     export const DuplicateNotebook = 'deepnote.duplicateNotebook';
     export const AddNotebookToProject = 'deepnote.addNotebookToProject';
     export const OpenInDeepnote = 'deepnote.openInDeepnote';
-    export const ExportAsPythonScript = 'jupyter.exportAsPythonScript';
-    export const ExportToHTML = 'jupyter.exportToHTML';
-    export const ExportToPDF = 'jupyter.exportToPDF';
-    export const Export = 'jupyter.export';
-    export const NativeNotebookExport = 'jupyter.notebookeditor.export';
-    export const LatestExtension = 'jupyter.latestExtension';
-    export const EnableLoadingWidgetsFrom3rdPartySource = 'jupyter.enableLoadingWidgetScriptsFromThirdPartySource';
-    export const ShowDataViewer = 'jupyter.showDataViewer';
-    export const ShowJupyterDataViewer = 'jupyter.showJupyterDataViewer';
-    export const RefreshDataViewer = 'jupyter.refreshDataViewer';
-    export const ClearSavedJupyterUris = 'jupyter.clearSavedJupyterUris';
-    export const OpenVariableView = 'jupyter.openVariableView';
-    export const OpenOutlineView = 'jupyter.openOutlineView';
-    export const InteractiveClearAll = 'jupyter.interactive.clearAllCells';
-    export const InteractiveGoToCode = 'jupyter.interactive.goToCode';
-    export const InteractiveCopyCell = 'jupyter.interactive.copyCell';
-    export const InteractiveExportAsNotebook = 'jupyter.interactive.exportasnotebook';
-    export const InteractiveExportAs = 'jupyter.interactive.exportas';
-    export const RunByLine = 'jupyter.runByLine';
-    export const RunAndDebugCell = 'jupyter.runAndDebugCell';
-    export const RunByLineNext = 'jupyter.runByLineNext';
-    export const RunByLineStop = 'jupyter.runByLineStop';
-    export const ReplayPylanceLog = 'jupyter.replayPylanceLog';
-    export const ReplayPylanceLogStep = 'jupyter.replayPylanceLogStep';
-    export const InstallPythonExtensionViaKernelPicker = 'jupyter.installPythonExtensionViaKernelPicker';
-    export const InstallPythonViaKernelPicker = 'jupyter.installPythonViaKernelPicker';
-    export const ContinueEditSessionInCodespace = 'jupyter.continueEditSessionInCodespace';
+    export const ExportAsPythonScript = 'deepnote.exportAsPythonScript';
+    export const ExportToHTML = 'deepnote.exportToHTML';
+    export const ExportToPDF = 'deepnote.exportToPDF';
+    export const Export = 'deepnote.export';
+    export const NativeNotebookExport = 'deepnote.notebookeditor.export';
+    export const LatestExtension = 'deepnote.latestExtension';
+    export const EnableLoadingWidgetsFrom3rdPartySource = 'deepnote.enableLoadingWidgetScriptsFromThirdPartySource';
+    export const ShowDataViewer = 'deepnote.showDataViewer';
+    export const ShowJupyterDataViewer = 'deepnote.showJupyterDataViewer';
+    export const RefreshDataViewer = 'deepnote.refreshDataViewer';
+    export const ClearSavedJupyterUris = 'deepnote.clearSavedJupyterUris';
+    export const OpenVariableView = 'deepnote.openVariableView';
+    export const OpenOutlineView = 'deepnote.openOutlineView';
+    export const InteractiveClearAll = 'deepnote.interactive.clearAllCells';
+    export const InteractiveGoToCode = 'deepnote.interactive.goToCode';
+    export const InteractiveCopyCell = 'deepnote.interactive.copyCell';
+    export const InteractiveExportAsNotebook = 'deepnote.interactive.exportasnotebook';
+    export const InteractiveExportAs = 'deepnote.interactive.exportas';
+    export const RunByLine = 'deepnote.runByLine';
+    export const RunAndDebugCell = 'deepnote.runAndDebugCell';
+    export const RunByLineNext = 'deepnote.runByLineNext';
+    export const RunByLineStop = 'deepnote.runByLineStop';
+    export const ReplayPylanceLog = 'deepnote.replayPylanceLog';
+    export const ReplayPylanceLogStep = 'deepnote.replayPylanceLogStep';
+    export const InstallPythonExtensionViaKernelPicker = 'deepnote.installPythonExtensionViaKernelPicker';
+    export const InstallPythonViaKernelPicker = 'deepnote.installPythonViaKernelPicker';
+    export const ContinueEditSessionInCodespace = 'deepnote.continueEditSessionInCodespace';
 }
 
 export namespace CodeLensCommands {
@@ -288,30 +288,30 @@ export namespace CodeLensCommands {
 }
 
 export namespace EditorContexts {
-    export const HasCodeCells = 'jupyter.hascodecells';
-    export const IsInteractiveActive = 'jupyter.isinteractiveactive';
-    export const OwnsSelection = 'jupyter.ownsSelection';
-    export const HaveNativeCells = 'jupyter.havenativecells';
-    export const HaveNative = 'jupyter.havenative';
-    export const IsNativeActive = 'jupyter.isnativeactive';
-    export const IsInteractiveOrNativeActive = 'jupyter.isinteractiveornativeactive';
-    export const IsPythonOrNativeActive = 'jupyter.ispythonornativeactive';
-    export const IsPythonOrInteractiveActive = 'jupyter.ispythonorinteractiveeactive';
-    export const IsPythonOrInteractiveOrNativeActive = 'jupyter.ispythonorinteractiveornativeeactive';
-    export const CanRestartNotebookKernel = 'jupyter.notebookeditor.canrestartNotebookkernel';
-    export const CanInterruptNotebookKernel = 'jupyter.notebookeditor.canInterruptNotebookKernel';
-    export const CanRestartInteractiveWindowKernel = 'jupyter.interactive.canRestartNotebookKernel';
-    export const CanInterruptInteractiveWindowKernel = 'jupyter.interactive.canInterruptNotebookKernel';
-    export const RunByLineCells = 'jupyter.notebookeditor.runByLineCells';
-    export const RunByLineDocuments = 'jupyter.notebookeditor.runByLineDocuments';
-    export const DebugDocuments = 'jupyter.notebookeditor.debugDocuments';
-    export const IsPythonNotebook = 'jupyter.ispythonnotebook';
-    export const IsJupyterKernelSelected = 'jupyter.kernel.isjupyter';
-    export const IsDataViewerActive = 'jupyter.dataViewerActive';
-    export const HasNativeNotebookOrInteractiveWindowOpen = 'jupyter.hasNativeNotebookOrInteractiveWindowOpen';
-    export const ZmqAvailable = 'jupyter.zmqavailable';
-    export const ReplayLogLoaded = 'jupyter.replayLogLoaded';
-    export const KernelSource = 'jupyter.kernelSource';
+    export const HasCodeCells = 'deepnote.hascodecells';
+    export const IsInteractiveActive = 'deepnote.isinteractiveactive';
+    export const OwnsSelection = 'deepnote.ownsSelection';
+    export const HaveNativeCells = 'deepnote.havenativecells';
+    export const HaveNative = 'deepnote.havenative';
+    export const IsNativeActive = 'deepnote.isnativeactive';
+    export const IsInteractiveOrNativeActive = 'deepnote.isinteractiveornativeactive';
+    export const IsPythonOrNativeActive = 'deepnote.ispythonornativeactive';
+    export const IsPythonOrInteractiveActive = 'deepnote.ispythonorinteractiveeactive';
+    export const IsPythonOrInteractiveOrNativeActive = 'deepnote.ispythonorinteractiveornativeeactive';
+    export const CanRestartNotebookKernel = 'deepnote.notebookeditor.canrestartNotebookkernel';
+    export const CanInterruptNotebookKernel = 'deepnote.notebookeditor.canInterruptNotebookKernel';
+    export const CanRestartInteractiveWindowKernel = 'deepnote.interactive.canRestartNotebookKernel';
+    export const CanInterruptInteractiveWindowKernel = 'deepnote.interactive.canInterruptNotebookKernel';
+    export const RunByLineCells = 'deepnote.notebookeditor.runByLineCells';
+    export const RunByLineDocuments = 'deepnote.notebookeditor.runByLineDocuments';
+    export const DebugDocuments = 'deepnote.notebookeditor.debugDocuments';
+    export const IsPythonNotebook = 'deepnote.ispythonnotebook';
+    export const IsJupyterKernelSelected = 'deepnote.kernel.isjupyter';
+    export const IsDataViewerActive = 'deepnote.dataViewerActive';
+    export const HasNativeNotebookOrInteractiveWindowOpen = 'deepnote.hasNativeNotebookOrInteractiveWindowOpen';
+    export const ZmqAvailable = 'deepnote.zmqavailable';
+    export const ReplayLogLoaded = 'deepnote.replayLogLoaded';
+    export const KernelSource = 'deepnote.kernelSource';
 }
 
 export namespace RegExpValues {
@@ -523,8 +523,8 @@ export const DataScienceStartupTime = Symbol('DataScienceStartupTime');
 // Default for notebook version (major & minor) used when creating notebooks.
 export const defaultNotebookFormat = { major: 4, minor: 2 };
 
-export const WIDGET_MIMETYPE = 'application/vnd.jupyter.widget-view+json';
-export const WIDGET_STATE_MIMETYPE = 'application/vnd.jupyter.widget-state+json';
+export const WIDGET_MIMETYPE = 'application/vnd.deepnote.widget-view+json';
+export const WIDGET_STATE_MIMETYPE = 'application/vnd.deepnote.widget-state+json';
 export const WIDGET_VERSION_NON_PYTHON_KERNELS = 8;
 
 /**
diff --git a/src/platform/common/utils/localize.ts b/src/platform/common/utils/localize.ts
index b8fb4abb09..12d4a62d01 100644
--- a/src/platform/common/utils/localize.ts
+++ b/src/platform/common/utils/localize.ts
@@ -147,7 +147,7 @@ export namespace DataScience {
     ) => l10n.t("Running cells with '{0}' requires the {1} package.", pythonEnvName, pythonModuleName);
     export const createANewPythonEnvironment = () =>
         l10n.t(
-            '[Create a Python Environment](command:jupyter.createPythonEnvAndSelectController) with the required packages.'
+            '[Create a Python Environment](command:deepnote.createPythonEnvAndSelectController) with the required packages.'
         );
     export const installPackageInstructions = (pythonModuleName: string, commandId: string) =>
         l10n.t("Install '{0}' into the Python environment. \nCommand: '{1}'", pythonModuleName, commandId);
@@ -223,37 +223,37 @@ export namespace DataScience {
     export const sessionStartFailedWithKernel = (kernelName: string) =>
         l10n.t({
             message:
-                "Failed to start the Kernel '{0}'. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Failed to start the Kernel '{0}'. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [kernelName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const failedToStartJupyter = (pythonEnvName: string) =>
         l10n.t({
             message:
-                "Failed to start Jupyter in the environment '{0}'. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Failed to start Jupyter in the environment '{0}'. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [pythonEnvName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const failedToStartJupyterWithErrorInfo = (pythonEnvName: string, errorMessage: string) =>
         l10n.t({
             message:
-                "Failed to start Jupyter in the environment '{0}'. \n{1} \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Failed to start Jupyter in the environment '{0}'. \n{1} \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [pythonEnvName, errorMessage],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const failedToStartJupyterDueToOutdatedTraitlets = (pythonEnvName: string, errorMessage: string) =>
         l10n.t({
             message:
-                "Failed to start Jupyter in the environment '{0}' possibly due to an outdated version of 'traitlets'. \n{1} \nConsider updating the 'traitlets' module to '5.1.1' or later. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Failed to start Jupyter in the environment '{0}' possibly due to an outdated version of 'traitlets'. \n{1} \nConsider updating the 'traitlets' module to '5.1.1' or later. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [pythonEnvName, errorMessage],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
                 "Do not translate the text 'traitlets', that is a Python module name"
             ]
         });
@@ -263,43 +263,43 @@ export namespace DataScience {
     export const rawKernelStartFailedDueToTimeout = (kernelName: string) =>
         l10n.t({
             message:
-                "Unable to start Kernel '{0}' due to a connection timeout. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Unable to start Kernel '{0}' due to a connection timeout. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [kernelName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const rawKernelStartFailedDueToTimeoutWaitingForPort = (kernelName: string) =>
         l10n.t({
             message:
-                "Unable to start Kernel '{0}' due to a timeout waiting for the ports to get used. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "Unable to start Kernel '{0}' due to a timeout waiting for the ports to get used. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [kernelName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const viewJupyterLogForFurtherInfo = l10n.t({
-        message: 'View Jupyter [log](command:jupyter.viewOutput) for further details.',
+        message: 'View Jupyter [log](command:deepnote.viewOutput) for further details.',
         comment: [
-            'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+            'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
         ]
     });
     export const kernelDied = (message: string) =>
         l10n.t({
             message:
-                'The kernel died. Error: {0}... View Jupyter [log](command:jupyter.viewOutput) for further details.',
+                'The kernel died. Error: {0}... View Jupyter [log](command:deepnote.viewOutput) for further details.',
             args: [message],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
             ]
         });
     export const kernelDiedWithoutError = (kernelName: string) =>
         l10n.t({
             message:
-                "The kernel '{0}' died. Click [here](https://aka.ms/vscodeJupyterKernelCrash) for more info. View Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "The kernel '{0}' died. Click [here](https://aka.ms/vscodeJupyterKernelCrash) for more info. View Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [kernelName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
                 'Do not translate the link https://aka.ms/vscodeJupyterKernelCrash'
             ]
         });
@@ -317,24 +317,24 @@ export namespace DataScience {
     export const kernelDiedWithoutErrorAndAutoRestarting = (kernelName: string) =>
         l10n.t({
             message:
-                "The kernel '{0}' died and is being automatically restarted by Jupyter. Click [here](https://aka.ms/vscodeJupyterKernelCrash) for more info. View Jupyter [log](command:jupyter.viewOutput) for further details.",
+                "The kernel '{0}' died and is being automatically restarted by Jupyter. Click [here](https://aka.ms/vscodeJupyterKernelCrash) for more info. View Jupyter [log](command:deepnote.viewOutput) for further details.",
             args: [kernelName],
             comment: [
-                'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
+                'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
                 'Do not translate the link https://aka.ms/vscodeJupyterKernelCrash'
             ]
         });
     export const kernelCrashedDueToCodeInCurrentOrPreviousCell = l10n.t({
         message:
-            "The Kernel crashed while executing code in the current cell or a previous cell. \nPlease review the code in the cell(s) to identify a possible cause of the failure. \nClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \nView Jupyter [log](command:jupyter.viewOutput) for further details.",
+            "The Kernel crashed while executing code in the current cell or a previous cell. \nPlease review the code in the cell(s) to identify a possible cause of the failure. \nClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \nView Jupyter [log](command:deepnote.viewOutput) for further details.",
         comment: [
-            'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
+            'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel',
             'Do not translate the link https://aka.ms/vscodeJupyterKernelCrash'
         ]
     });
     export const kernelDisconnected = (kernelName: string) =>
         l10n.t(
-            "Unable to connect to the kernel '{0}', please verify the Jupyter Server connection. View Jupyter [log](command:jupyter.viewOutput) for further details.",
+            "Unable to connect to the kernel '{0}', please verify the Jupyter Server connection. View Jupyter [log](command:deepnote.viewOutput) for further details.",
             kernelName
         );
     export const cannotRunCellKernelIsDead = (kernelName: string) =>
@@ -533,9 +533,9 @@ export namespace DataScience {
     export const openExportFileYes = l10n.t('Yes');
     export const openExportFileNo = l10n.t('No');
     export const exportFailedGeneralMessage = l10n.t({
-        message: `Please check the 'Jupyter' [output](command:jupyter.viewOutput) panel for further details.`,
+        message: `Please check the 'Jupyter' [output](command:deepnote.viewOutput) panel for further details.`,
         comment: [
-            'Do not translate the text "command:jupyter.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
+            'Do not translate the text "command:deepnote.viewOutput", that is a command Id that will be used by VS Code to open the output panel'
         ]
     });
     export const exportToPDFDependencyMessage = l10n.t(
diff --git a/src/platform/errors/errorUtils.ts b/src/platform/errors/errorUtils.ts
index 8facbea5ac..4726f9fa51 100644
--- a/src/platform/errors/errorUtils.ts
+++ b/src/platform/errors/errorUtils.ts
@@ -563,7 +563,7 @@ export function analyzeKernelErrors(
             .find((line) => line.toLowerCase().includes('error: '));
         // https://github.com/microsoft/vscode-jupyter/issues/8295
         const errorMessageDueToOutdatedTraitlets = "AttributeError: 'Namespace' object has no attribute '_flags'";
-        const telemetrySafeTags = ['jupyter.startup.failure'];
+        const telemetrySafeTags = ['deepnote.startup.failure'];
         let link: string | undefined;
         let reason = KernelFailureReason.jupyterStartFailure;
         // Some times the error message is either in the message or the stderr.
diff --git a/src/platform/interpreter/filter/completionProvider.node.ts b/src/platform/interpreter/filter/completionProvider.node.ts
index b477bce379..a8bc91f683 100644
--- a/src/platform/interpreter/filter/completionProvider.node.ts
+++ b/src/platform/interpreter/filter/completionProvider.node.ts
@@ -68,7 +68,7 @@ export class PythonEnvFilterCompletionProvider implements CompletionItemProvider
         const location = getLocation(document.getText(), document.offsetAt(position));
         // Cursor must be inside the configurations array and not in any nested items.
         // Hence path[0] = array, path[1] = array element index.
-        return location.path[0] === 'jupyter.kernels.excludePythonEnvironments' && location.path.length === 2;
+        return location.path[0] === 'deepnote.kernels.excludePythonEnvironments' && location.path.length === 2;
     }
     private getCurrentItemsInList(document: TextDocument, position: Position): string[] {
         try {
diff --git a/src/platform/interpreter/filter/filterService.ts b/src/platform/interpreter/filter/filterService.ts
index b10da0532d..901d180e8c 100644
--- a/src/platform/interpreter/filter/filterService.ts
+++ b/src/platform/interpreter/filter/filterService.ts
@@ -26,7 +26,7 @@ export class PythonEnvironmentFilter implements IDisposable {
         if (!isWebExtension()) {
             workspace.onDidChangeConfiguration(
                 (e) => {
-                    e.affectsConfiguration('jupyter.kernels.excludePythonEnvironments') && this._onDidChange.fire();
+                    e.affectsConfiguration('deepnote.kernels.excludePythonEnvironments') && this._onDidChange.fire();
                 },
                 this,
                 this.disposables
diff --git a/src/platform/interpreter/filter/uiDeprecationHandler.ts b/src/platform/interpreter/filter/uiDeprecationHandler.ts
index 9001262e21..d4ab7f3a77 100644
--- a/src/platform/interpreter/filter/uiDeprecationHandler.ts
+++ b/src/platform/interpreter/filter/uiDeprecationHandler.ts
@@ -13,10 +13,10 @@ export class PythonFilterUICommandDeprecation implements IExtensionSyncActivatio
     public activate() {
         this.disposables.push(
             commands.registerCommand(
-                'jupyter.filterKernels',
+                'deepnote.filterKernels',
                 () =>
                     commands
-                        .executeCommand('workbench.action.openSettings', 'jupyter.kernels.excludePythonEnvironments')
+                        .executeCommand('workbench.action.openSettings', 'deepnote.kernels.excludePythonEnvironments')
                         .then(noop, noop),
                 this
             )
diff --git a/src/platform/logging/index.ts b/src/platform/logging/index.ts
index 4b34aedb07..af56db850e 100644
--- a/src/platform/logging/index.ts
+++ b/src/platform/logging/index.ts
@@ -58,7 +58,7 @@ export function initializeLoggers(options: {
     globalLoggingLevel = getLoggingLevelFromConfig();
     trackDisposable(
         workspace.onDidChangeConfiguration((e) => {
-            if (e.affectsConfiguration('jupyter.logging')) {
+            if (e.affectsConfiguration('deepnote.logging')) {
                 globalLoggingLevel = getLoggingLevelFromConfig();
             }
         })
diff --git a/src/platform/webviews/webviewHost.ts b/src/platform/webviews/webviewHost.ts
index 643ae042d7..72d0314b52 100644
--- a/src/platform/webviews/webviewHost.ts
+++ b/src/platform/webviews/webviewHost.ts
@@ -324,7 +324,7 @@ export abstract class WebviewHost<IMapping> implements IDisposable {
             event.affectsConfiguration('editor.scrollbar.horizontalScrollbarSize') ||
             event.affectsConfiguration('files.autoSave') ||
             event.affectsConfiguration('files.autoSaveDelay') ||
-            event.affectsConfiguration('jupyter.widgetScriptSources')
+            event.affectsConfiguration('deepnote.widgetScriptSources')
         ) {
             // See if the theme changed
             const newSettings = await this.generateDataScienceExtraSettings();
diff --git a/src/standalone/api/kernels/accessManagement.ts b/src/standalone/api/kernels/accessManagement.ts
index 4964db5859..2e3f5e7b35 100644
--- a/src/standalone/api/kernels/accessManagement.ts
+++ b/src/standalone/api/kernels/accessManagement.ts
@@ -17,7 +17,7 @@ export class KernelApi implements IExtensionSyncActivationService {
         const disposableStore = new DisposableStore();
         disposables.push(disposableStore);
         disposables.push(
-            commands.registerCommand('jupyter.manageAccessToKernels', () => manageKernelAccess(disposableStore))
+            commands.registerCommand('deepnote.manageAccessToKernels', () => manageKernelAccess(disposableStore))
         );
     }
 }
diff --git a/src/standalone/chat/extension.node.ts b/src/standalone/chat/extension.node.ts
index b3b56f54c9..7edce6fd2d 100644
--- a/src/standalone/chat/extension.node.ts
+++ b/src/standalone/chat/extension.node.ts
@@ -78,7 +78,7 @@ export async function activate(context: vscode.ExtensionContext, serviceContaine
     );
 
     context.subscriptions.push(
-        vscode.commands.registerCommand('jupyter.listPipPackages', async (uri) => {
+        vscode.commands.registerCommand('deepnote.listPipPackages', async (uri) => {
             const documentUri = uri ?? vscode.window.activeNotebookEditor?.notebook.uri;
             if (documentUri) {
                 const kernelProvider = serviceContainer.get<IKernelProvider>(IKernelProvider);
@@ -102,7 +102,7 @@ export async function activate(context: vscode.ExtensionContext, serviceContaine
     );
 
     context.subscriptions.push(
-        vscode.commands.registerCommand('jupyter.listVariables', async (uri) => {
+        vscode.commands.registerCommand('deepnote.listVariables', async (uri) => {
             const documentUri = uri ?? vscode.window.activeNotebookEditor?.notebook.uri;
 
             if (!documentUri) {
diff --git a/src/standalone/executionAnalysis/extension.ts b/src/standalone/executionAnalysis/extension.ts
index 11f86a2ec7..4c8880db93 100644
--- a/src/standalone/executionAnalysis/extension.ts
+++ b/src/standalone/executionAnalysis/extension.ts
@@ -22,7 +22,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
 
     context.subscriptions.push(
         vscode.commands.registerCommand(
-            'jupyter.selectDependentCells',
+            'deepnote.selectDependentCells',
             async (cell: vscode.NotebookCell | undefined) => {
                 const matched = findNotebookAndCell(cell);
                 if (!matched) {
@@ -36,7 +36,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     );
 
     context.subscriptions.push(
-        vscode.commands.registerCommand('jupyter.runPrecedentCells', async (cell: vscode.NotebookCell | undefined) => {
+        vscode.commands.registerCommand('deepnote.runPrecedentCells', async (cell: vscode.NotebookCell | undefined) => {
             const matched = findNotebookAndCell(cell);
             if (!matched) {
                 return;
@@ -48,7 +48,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     );
 
     context.subscriptions.push(
-        vscode.commands.registerCommand('jupyter.runDependentCells', async (cell: vscode.NotebookCell | undefined) => {
+        vscode.commands.registerCommand('deepnote.runDependentCells', async (cell: vscode.NotebookCell | undefined) => {
             const matched = findNotebookAndCell(cell);
             if (!matched) {
                 return;
@@ -61,7 +61,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
 
     context.subscriptions.push(
         vscode.commands.registerCommand(
-            'jupyter.selectPrecedentCells',
+            'deepnote.selectPrecedentCells',
             async (cell: vscode.NotebookCell | undefined) => {
                 const matched = findNotebookAndCell(cell);
                 if (!matched) {
@@ -75,7 +75,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     );
 
     context.subscriptions.push(
-        vscode.commands.registerCommand('jupyter.debugCellSymbols', async () => {
+        vscode.commands.registerCommand('deepnote.debugCellSymbols', async () => {
             const notebookEditor = vscode.window.activeNotebookEditor;
             if (notebookEditor) {
                 await symbolsManager.debugSymbols(notebookEditor.notebook);
diff --git a/src/standalone/executionAnalysis/symbols.ts b/src/standalone/executionAnalysis/symbols.ts
index d70a42c205..c417073a70 100644
--- a/src/standalone/executionAnalysis/symbols.ts
+++ b/src/standalone/executionAnalysis/symbols.ts
@@ -714,7 +714,7 @@ export class ExecutionFixCodeActionsProvider implements vscode.CodeActionProvide
         if (matchingRefs.some((r) => r)) {
             const action = new vscode.CodeAction('Run Precedent Cells', vscode.CodeActionKind.QuickFix);
             action.command = {
-                command: 'jupyter.runPrecedentCells',
+                command: 'deepnote.runPrecedentCells',
                 title: 'Run Precedent Cells',
                 arguments: [targetCell]
             };
diff --git a/src/standalone/intellisense/kernelCompletionProvider.ts b/src/standalone/intellisense/kernelCompletionProvider.ts
index 74de39e807..507a04e93b 100644
--- a/src/standalone/intellisense/kernelCompletionProvider.ts
+++ b/src/standalone/intellisense/kernelCompletionProvider.ts
@@ -411,7 +411,7 @@ class KernelSpecificCompletionProvider extends DisposableBase implements Complet
         this.registerCompletionProvider();
         this._register(
             workspace.onDidChangeConfiguration((e) => {
-                if (e.affectsConfiguration('jupyter.enableKernelCompletions')) {
+                if (e.affectsConfiguration('deepnote.enableKernelCompletions')) {
                     if (!isKernelCompletionEnabled(this.kernel.notebook.uri)) {
                         this.completionProvider?.dispose();
                         this.completionProvider = undefined;
@@ -421,8 +421,8 @@ class KernelSpecificCompletionProvider extends DisposableBase implements Complet
                     }
                 }
                 if (
-                    !e.affectsConfiguration('jupyter.completionTriggerCharacters') &&
-                    !e.affectsConfiguration('jupyter.pythonCompletionTriggerCharacters')
+                    !e.affectsConfiguration('deepnote.completionTriggerCharacters') &&
+                    !e.affectsConfiguration('deepnote.pythonCompletionTriggerCharacters')
                 ) {
                     return;
                 }
@@ -595,7 +595,7 @@ function logHowToEnableKernelCompletion(kernel: IKernel) {
     if (kernelLanguage.toLowerCase() === monacoLanguage.toLowerCase()) {
         logger.warn(
             l10n.t(
-                `Kernel completions not enabled for '{0}'. \nTo enable Kernel completion for this language please add the following setting \njupyter.completionTriggerCharacters = {1}: [<List of characters that will trigger completions>]}. \nFor more information please see https://aka.ms/vscodeJupyterCompletion`,
+                `Kernel completions not enabled for '{0}'. \nTo enable Kernel completion for this language please add the following setting \ndeepnote.completionTriggerCharacters = {1}: [<List of characters that will trigger completions>]}. \nFor more information please see https://aka.ms/vscodeJupyterCompletion`,
                 getDisplayNameOrNameOfKernelConnection(kernel.kernelConnectionMetadata),
                 `{${kernelLanguage}`
             )
@@ -603,7 +603,7 @@ function logHowToEnableKernelCompletion(kernel: IKernel) {
     } else {
         logger.warn(
             l10n.t(
-                `Kernel completions not enabled for '{0}'. \nTo enable Kernel completion for this language please add the following setting \njupyter.completionTriggerCharacters = {1}: [<List of characters that will trigger completions>]}. \n or the following: \njupyter.completionTriggerCharacters = {2}: [<List of characters that will trigger completions>]}. \nFor more information please see https://aka.ms/vscodeJupyterCompletion`,
+                `Kernel completions not enabled for '{0}'. \nTo enable Kernel completion for this language please add the following setting \ndeepnote.completionTriggerCharacters = {1}: [<List of characters that will trigger completions>]}. \n or the following: \ndeepnote.completionTriggerCharacters = {2}: [<List of characters that will trigger completions>]}. \nFor more information please see https://aka.ms/vscodeJupyterCompletion`,
                 getDisplayNameOrNameOfKernelConnection(kernel.kernelConnectionMetadata),
                 `{${kernelLanguage}`,
                 `{${monacoLanguage}`
diff --git a/src/standalone/userJupyterServer/serverSelectorForTests.ts b/src/standalone/userJupyterServer/serverSelectorForTests.ts
index cf2b73230e..e404fdd509 100644
--- a/src/standalone/userJupyterServer/serverSelectorForTests.ts
+++ b/src/standalone/userJupyterServer/serverSelectorForTests.ts
@@ -47,7 +47,7 @@ export class JupyterServerSelectorCommand
                 this
             )
         );
-        this._register(commands.registerCommand('jupyter.selectjupyteruri', this.selectJupyterUri, this));
+        this._register(commands.registerCommand('deepnote.selectjupyteruri', this.selectJupyterUri, this));
     }
     private async selectJupyterUri(source: Uri): Promise<void> {
         logger.info(`Setting Jupyter Server URI to remote: ${source}`);
diff --git a/src/test/.vscode/settings.json b/src/test/.vscode/settings.json
index 3315e8f54f..87bc5336c2 100644
--- a/src/test/.vscode/settings.json
+++ b/src/test/.vscode/settings.json
@@ -20,5 +20,5 @@
     // and that slows down tests significantly. We have other tests on CI for testing
     // downloading of LS with this setting enabled.
     "python.languageServer": "Pylance",
-    "jupyter.logging.level": "debug"
+    "deepnote.logging.level": "debug"
 }
diff --git a/src/test/common.node.ts b/src/test/common.node.ts
index 2f2fc39236..4eb676aaaa 100644
--- a/src/test/common.node.ts
+++ b/src/test/common.node.ts
@@ -238,7 +238,7 @@ export function initializeCommonNodeApi() {
                     return JupyterServer.instance.startJupyter(options);
                 }
                 if (!remoteUrisCleared) {
-                    await commands.executeCommand('jupyter.clearSavedJupyterUris');
+                    await commands.executeCommand('deepnote.clearSavedJupyterUris');
                     remoteUrisCleared = true;
                 }
                 const url = options.useCert
@@ -246,14 +246,14 @@ export function initializeCommonNodeApi() {
                     : await JupyterServer.instance.startJupyterWithToken();
                 console.info(`Jupyter started and listening at ${url}`);
                 try {
-                    await commands.executeCommand('jupyter.selectjupyteruri', Uri.parse(url));
+                    await commands.executeCommand('deepnote.selectjupyteruri', Uri.parse(url));
                 } catch (ex) {
                     console.error('Failed to select jupyter server, retry in 1s', ex);
                 }
                 // Todo: Fix in debt week, we need to retry, some changes have caused the first connection attempt to fail on CI.
                 // Possible we're trying to connect before the server is ready.
                 await sleep(5_000);
-                await commands.executeCommand('jupyter.selectjupyteruri', Uri.parse(url));
+                await commands.executeCommand('deepnote.selectjupyteruri', Uri.parse(url));
                 return { url, dispose: noop };
             } else {
                 return { url: '', dispose: noop };
diff --git a/src/test/common.web.ts b/src/test/common.web.ts
index a8da72a009..d065e17589 100644
--- a/src/test/common.web.ts
+++ b/src/test/common.web.ts
@@ -66,7 +66,7 @@ export function initializeCommonWebApi() {
             // Server URI should have been embedded in the constants file
             const uri = Uri.parse(url);
             // Use this URI to set our jupyter server URI
-            await commands.executeCommand('jupyter.selectjupyteruri', uri);
+            await commands.executeCommand('deepnote.selectjupyteruri', uri);
             return { url: url, dispose: noop };
         },
         async initialize() {
diff --git a/src/test/datascience/.vscode/settings.json b/src/test/datascience/.vscode/settings.json
index eb53a69e66..13aa9c09c5 100644
--- a/src/test/datascience/.vscode/settings.json
+++ b/src/test/datascience/.vscode/settings.json
@@ -21,20 +21,20 @@
     //If enabled, ensure we save immediately.
     "files.autoSaveDelay": 1,
     // We don't want jupyter to start when testing (DS functionality or anything else).
-    "jupyter.disableJupyterAutoStart": true,
+    "deepnote.disableJupyterAutoStart": true,
     // In web tests, VS Code will be reading this property (as we're changing the scope of this setting from machine to resource).
-    "jupyter.logging.level": "debug",
+    "deepnote.logging.level": "debug",
     "python.logging.level": "debug",
     "webview.experimental.useIframes": true,
     // Python experiments have to be on for insiders to work
     "python.experiments.enabled": true,
     // See https://github.com/microsoft/vscode-jupyter/issues/10258
-    "jupyter.forceIPyKernelDebugger": false,
+    "deepnote.forceIPyKernelDebugger": false,
     "python.defaultInterpreterPath": "",
     "task.problemMatchers.neverPrompt": {
         "shell": true,
         "npm": true
     },
-    "jupyter.interactiveWindow.creationMode": "multiple",
-    "jupyter.interactiveWindow.textEditor.magicCommandsAsComments": false,
+    "deepnote.interactiveWindow.creationMode": "multiple",
+    "deepnote.interactiveWindow.textEditor.magicCommandsAsComments": false,
 }
diff --git a/src/test/datascience/interactiveDebugging.vscode.test.ts b/src/test/datascience/interactiveDebugging.vscode.test.ts
index d6847b2f7d..4645e67fa8 100644
--- a/src/test/datascience/interactiveDebugging.vscode.test.ts
+++ b/src/test/datascience/interactiveDebugging.vscode.test.ts
@@ -19,31 +19,31 @@ suite('Interactive Window Debugging @debugger', function () {
     async function enableJupyterDebugger(debuggerType: DebuggerType) {
         const enable = debuggerType === 'JupyterProtocolDebugger';
         const settingFileContents = fs.readFileSync(settingsFile).toString();
-        if (enable && settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": true`)) {
+        if (enable && settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": true`)) {
             return;
-        } else if (enable && settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": false`)) {
+        } else if (enable && settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": false`)) {
             fs.writeFileSync(
                 settingsFile,
                 settingFileContents.replace(
-                    `"jupyter.forceIPyKernelDebugger": false`,
-                    `"jupyter.forceIPyKernelDebugger": true`
+                    `"deepnote.forceIPyKernelDebugger": false`,
+                    `"deepnote.forceIPyKernelDebugger": true`
                 )
             );
             return;
-        } else if (enable && !settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": true`)) {
+        } else if (enable && !settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": true`)) {
             throw new Error('Unable to update settings file');
-        } else if (!enable && settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": true`)) {
+        } else if (!enable && settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": true`)) {
             fs.writeFileSync(
                 settingsFile,
                 settingFileContents.replace(
-                    `"jupyter.forceIPyKernelDebugger": true`,
-                    `"jupyter.forceIPyKernelDebugger": false`
+                    `"deepnote.forceIPyKernelDebugger": true`,
+                    `"deepnote.forceIPyKernelDebugger": false`
                 )
             );
             return;
-        } else if (!enable && settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": false`)) {
+        } else if (!enable && settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": false`)) {
             return;
-        } else if (!enable && !settingFileContents.includes(`"jupyter.forceIPyKernelDebugger": true`)) {
+        } else if (!enable && !settingFileContents.includes(`"deepnote.forceIPyKernelDebugger": true`)) {
             throw new Error('Unable to update settings file');
         }
     }
diff --git a/src/test/datascience/interactiveWindow.vscode.common.test.ts b/src/test/datascience/interactiveWindow.vscode.common.test.ts
index 2b4af7905c..98f3074193 100644
--- a/src/test/datascience/interactiveWindow.vscode.common.test.ts
+++ b/src/test/datascience/interactiveWindow.vscode.common.test.ts
@@ -133,14 +133,14 @@ suite(`Interactive window execution @iw`, async function () {
         await verifyCells();
 
         // CLear all cells
-        await vscode.commands.executeCommand('jupyter.interactive.clearAllCells');
+        await vscode.commands.executeCommand('deepnote.interactive.clearAllCells');
         await waitForCondition(async () => notebookDocument.cellCount === 0, 5_000, 'Cells not cleared');
 
         // Restart kernel
         const kernelProvider = api.serviceContainer.get<IKernelProvider>(IKernelProvider);
         const kernel = kernelProvider.get(notebookDocument);
         const handler = createEventHandler(kernel!, 'onRestarted', disposables);
-        await vscode.commands.executeCommand('jupyter.restartkernel');
+        await vscode.commands.executeCommand('deepnote.restartkernel');
         // Wait for restart to finish
         await handler.assertFiredExactly(1, defaultNotebookTestTimeout);
         await activeInteractiveWindow.addCode(source, untitledPythonFile.uri, 0);
diff --git a/src/test/datascience/notebook/exportFull.vscode.test.ts b/src/test/datascience/notebook/exportFull.vscode.test.ts
index 054786fcab..379e211502 100644
--- a/src/test/datascience/notebook/exportFull.vscode.test.ts
+++ b/src/test/datascience/notebook/exportFull.vscode.test.ts
@@ -131,7 +131,7 @@ suite('Export @export', function () {
         });
 
         // Execute our export command
-        await commands.executeCommand('jupyter.exportAsPythonScript');
+        await commands.executeCommand('deepnote.exportAsPythonScript');
 
         // Wait until our active document changes
         await deferred.promise;
@@ -164,7 +164,7 @@ suite('Export @export', function () {
         await settings.update('pythonExportMethod', 'commentMagics', ConfigurationTarget.Global);
 
         // Execute our export command
-        await commands.executeCommand('jupyter.exportAsPythonScript');
+        await commands.executeCommand('deepnote.exportAsPythonScript');
 
         // Wait until our active document changes
         await deferred.promise;
@@ -197,7 +197,7 @@ suite('Export @export', function () {
         await settings.update('pythonExportMethod', 'nbconvert', ConfigurationTarget.Global);
 
         // Execute our export command
-        await commands.executeCommand('jupyter.exportAsPythonScript');
+        await commands.executeCommand('deepnote.exportAsPythonScript');
 
         // Wait until our active document changes
         await deferred.promise;
@@ -249,7 +249,7 @@ suite('Export @export', function () {
             'test.ipynb'
         );
         const importFile = Uri.file(testFilePath);
-        await commands.executeCommand('jupyter.importnotebookfile', importFile);
+        await commands.executeCommand('deepnote.importnotebookfile', importFile);
 
         // Wait until our active document changes
         await deferred.promise;
@@ -287,7 +287,7 @@ suite('Export @export', function () {
             'test.ipynb'
         );
         const importFile = Uri.file(testFilePath);
-        await commands.executeCommand('jupyter.importnotebookfile', importFile);
+        await commands.executeCommand('deepnote.importnotebookfile', importFile);
 
         // Wait until our active document changes
         await deferred.promise;
diff --git a/src/test/index.node.ts b/src/test/index.node.ts
index e700cee708..852b47e642 100644
--- a/src/test/index.node.ts
+++ b/src/test/index.node.ts
@@ -59,7 +59,7 @@ process.on('unhandledRejection', (ex: Error, _a) => {
         (msg.includes('Canceled future for') && msg.includes('message before replies were done')) ||
         (msg.includes('The kernel died. Error') &&
             msg.includes('No module named ipykernel_launcher') &&
-            msg.includes('View Jupyter [log](command:jupyter.viewOutput)')) ||
+            msg.includes('View Jupyter [log](command:deepnote.viewOutput)')) ||
         msg.includes('Channel has been closed') ||
         msg.includes('Error: custom request failed') ||
         msg.includes('ms-python.python') || // We don't care about unhanded promise rejections from the Python extension.
diff --git a/src/test/smoke/datascience.smoke.test.ts b/src/test/smoke/datascience.smoke.test.ts
index 01b156ecfe..aee5002adf 100644
--- a/src/test/smoke/datascience.smoke.test.ts
+++ b/src/test/smoke/datascience.smoke.test.ts
@@ -64,7 +64,7 @@ suite('Smoke Tests', function () {
     //     console.log('Step0');
     //     await sleep(1_000);
     //     console.log('Step1');
-    //     await vscode.commands.executeCommand<void>('jupyter.runallcells', textDocument.uri);
+    //     await vscode.commands.executeCommand<void>('deepnote.runallcells', textDocument.uri);
     //     console.log('Step2');
     //     const checkIfFileHasBeenCreated = () => fs.pathExists(outputFile);
     //     console.log('Step3');
@@ -121,7 +121,7 @@ suite('Smoke Tests', function () {
         return this.skip(); // See https://github.com/microsoft/vscode-jupyter/issues/5478
 
         // Make an interactive window
-        await vscode.commands.executeCommand<void>('jupyter.createnewinteractive');
+        await vscode.commands.executeCommand<void>('deepnote.createnewinteractive');
         assert.ok(vscode.workspace.notebookDocuments.length === 1, 'Unexpected number of notebook documents created');
         // const currentWindow = provider.windows[0];
         // const interpreterForCurrentWindow = currentWindow.notebook?.getMatchingInterpreter();
@@ -139,7 +139,7 @@ suite('Smoke Tests', function () {
         // await vscode.commands.executeCommand<void>('python.setInterpreter', differentInterpreter); // Requires change to Python extension
 
         // // Now make another interactive window and confirm it's using the newly selected interpreter
-        // await vscode.commands.executeCommand<void>('jupyter.createnewinteractive');
+        // await vscode.commands.executeCommand<void>('deepnote.createnewinteractive');
         // assert.ok(provider.windows.length === 2, 'Unexpected number of interactive windows created');
         // const newWindow = provider.windows.find((window) => window !== currentWindow);
         // const interpreterForNewWindow = newWindow?.notebook?.getMatchingInterpreter();
diff --git a/src/test/standardTest.node.ts b/src/test/standardTest.node.ts
index 9435831d7b..8f07510503 100644
--- a/src/test/standardTest.node.ts
+++ b/src/test/standardTest.node.ts
@@ -144,7 +144,7 @@ async function createSettings(): Promise<string> {
     const settingsFile = path.join(userDataDirectory, 'User', 'settings.json');
     const defaultSettings: Record<string, string | boolean | string[]> = {
         'python.insidersChannel': 'off',
-        'jupyter.logging.level': 'debug',
+        'deepnote.logging.level': 'debug',
         'python.logging.level': 'debug',
         'files.autoSave': 'off',
         'python.experiments.enabled': true,
@@ -154,9 +154,9 @@ async function createSettings(): Promise<string> {
         // For instance if the start page UI opens up, then active editor, active notebook and the like are empty.
         'python.showStartPage': false,
         // Disable the restart ask so that restart just happens
-        'jupyter.askForKernelRestart': false,
+        'deepnote.askForKernelRestart': false,
         // To get widgets working.
-        'jupyter.widgetScriptSources': ['jsdelivr.com', 'unpkg.com'],
+        'deepnote.widgetScriptSources': ['jsdelivr.com', 'unpkg.com'],
         'notebook.stickyScroll.enabled': true, // Required for perf tests
         'notebook.outline.showCodeCells': true // Required for perf tests
     };
diff --git a/src/test/web/index.ts b/src/test/web/index.ts
index 81ad1edf59..6d98a5e8c4 100644
--- a/src/test/web/index.ts
+++ b/src/test/web/index.ts
@@ -44,7 +44,7 @@ export async function activate(context: IExtensionContext): Promise<IExtensionAp
     if (activatedResponse) {
         return activatedResponse;
     }
-    vscode.commands.registerCommand('jupyter.web.runTests', async () => {
+    vscode.commands.registerCommand('deepnote.web.runTests', async () => {
         // imports mocha for the browser, defining the `mocha` global.
         require('mocha/mocha');
 
@@ -105,6 +105,6 @@ export async function run(): Promise<void> {
     await api.ready;
     // Run the tests from within the context of the extension bundle.
     // We achieve this by getting the extension to run the tests (then its guaranteed to use the same context as the extension).
-    await vscode.commands.executeCommand('jupyter.web.runTests');
+    await vscode.commands.executeCommand('deepnote.web.runTests');
     console.log('Finished executing tests.');
 }

From fea5d0d3f76d047da0bf6fc114c06f365f948963 Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 11:05:55 +0000
Subject: [PATCH 2/7] Rename more jupyter related named views, commands, etc

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 package.json                                  | 106 +++++-------------
 package.nls.json                              |   8 +-
 src/commands.ts                               |   2 +-
 .../commands/commandRegistry.ts               |   2 +-
 src/platform/webviews/types.ts                |   2 +-
 src/standalone/chat/configureNotebook.node.ts |   2 +-
 .../chat/installPackageTool.node.ts           |   2 +-
 src/standalone/chat/listPackageTool.node.ts   |   2 +-
 src/standalone/chat/restartKernelTool.node.ts |   4 +-
 .../variablesView/variableViewProvider.ts     |   2 +-
 10 files changed, 43 insertions(+), 89 deletions(-)

diff --git a/package.json b/package.json
index 6349ca93f3..b91b3ab390 100644
--- a/package.json
+++ b/package.json
@@ -55,9 +55,9 @@
     ],
     "activationEvents": [
         "onLanguage:python",
-        "onLanguageModelTool:configure_notebook",
-        "onLanguageModelTool:notebook_install_packages",
-        "onLanguageModelTool:notebook_list_packages",
+        "onLanguageModelTool:configure_deepnote_notebook",
+        "onLanguageModelTool:deepnote_notebook_install_packages",
+        "onLanguageModelTool:deepnote_notebook_list_packages",
         "onNotebook:deepnote",
         "onNotebook:interactive"
     ],
@@ -821,7 +821,7 @@
         ],
         "submenus": [
             {
-                "id": "editor.interactiveWindow.context",
+                "id": "deepnote.editor.interactiveWindow.context",
                 "label": "%deepnote.command.editor.interactiveWindow.context.label%"
             },
             {
@@ -859,13 +859,13 @@
             ],
             "editor/context": [
                 {
-                    "submenu": "editor.interactiveWindow.context",
-                    "group": "Jupyter2"
+                    "submenu": "deepnote.editor.interactiveWindow.context",
+                    "group": "Deepnote2"
                 },
                 {
                     "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
                     "command": "deepnote.exportfileasnotebook",
-                    "group": "Jupyter3@2"
+                    "group": "Deepnote3@2"
                 },
                 {
                     "when": "resourceExtname == .deepnote",
@@ -873,40 +873,40 @@
                     "group": "navigation"
                 }
             ],
-            "editor.interactiveWindow.context": [
+            "deepnote.editor.interactiveWindow.context": [
                 {
                     "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
                     "command": "deepnote.runallcells",
-                    "group": "Jupyter2"
+                    "group": "Deepnote2"
                 },
                 {
                     "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
                     "command": "deepnote.runcurrentcell",
-                    "group": "Jupyter2"
+                    "group": "Deepnote2"
                 },
                 {
                     "when": "editorFocus && editorLangId == python && deepnote.hascodecells && !notebookEditorFocused && isWorkspaceTrusted",
                     "command": "deepnote.runcurrentcelladvance",
-                    "group": "Jupyter2"
+                    "group": "Deepnote2"
                 },
                 {
                     "command": "deepnote.runFileInteractive",
-                    "group": "Jupyter2",
+                    "group": "Deepnote2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
                     "command": "deepnote.runfromline",
-                    "group": "Jupyter2",
+                    "group": "Deepnote2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
                     "command": "deepnote.runtoline",
-                    "group": "Jupyter2",
+                    "group": "Deepnote2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
                     "command": "deepnote.execSelectionInteractive",
-                    "group": "Jupyter2",
+                    "group": "Deepnote2",
                     "when": "editorFocus && editorLangId == python && !notebookEditorFocused && isWorkspaceTrusted"
                 }
             ],
@@ -1042,7 +1042,7 @@
                 },
                 {
                     "command": "deepnote.notebookeditor.export",
-                    "group": "Jupyter",
+                    "group": "Deepnote",
                     "when": "notebookType == 'jupyter-notebook' && notebookType != 'deepnote' && isWorkspaceTrusted"
                 },
                 {
@@ -1158,12 +1158,12 @@
                 {
                     "when": "resourceLangId == python && !notebookEditorFocused && isWorkspaceTrusted",
                     "command": "deepnote.runFileInteractive",
-                    "group": "Jupyter2"
+                    "group": "Deepnote2"
                 },
                 {
                     "when": "resourceExtname == .ipynb && isWorkspaceTrusted",
                     "command": "deepnote.importnotebookfile",
-                    "group": "Jupyter"
+                    "group": "Deepnote"
                 }
             ],
             "commandPalette": [
@@ -2248,8 +2248,8 @@
                 },
                 {
                     "type": "webview",
-                    "id": "jupyterViewVariables",
-                    "name": "Jupyter Variables",
+                    "id": "deepnoteViewVariables",
+                    "name": "Deepnote Variables",
                     "when": "deepnote.hasNativeNotebookOrInteractiveWindowOpen"
                 }
             ]
@@ -2289,7 +2289,7 @@
         ],
         "languageModelTools": [
             {
-                "name": "configure_notebook",
+                "name": "configure_deepnote_notebook",
                 "displayName": "%deepnote.languageModelTools.configure_notebook.displayName%",
                 "modelDescription": "Tool used to configure a Notebook. ALWAYS use this tool before running/executing any Notebook Cells for the first time or before listing/installing packages in Notebooks for the first time. I.e. there is no need to use this tool more than once for the same notebook.",
                 "userDescription": "%deepnote.languageModelTools.configure_notebook.userDescription%",
@@ -2318,56 +2318,10 @@
                 "when": "workspacePlatform != webworker"
             },
             {
-                "name": "configure_python_notebook",
-                "displayName": "Start Notebook Kernel",
-                "modelDescription": "Selects a Python Kernel and starts it.",
-                "tags": [
-                    "extension_installed_by_tool",
-                    "install python package",
-                    "notebooks"
-                ],
-                "inputSchema": {
-                    "type": "object",
-                    "properties": {
-                        "filePath": {
-                            "description": "The absolute path of the notebook with the active kernel.",
-                            "type": "string"
-                        }
-                    },
-                    "required": [
-                        "filePath"
-                    ]
-                },
-                "when": "false"
-            },
-            {
-                "name": "configure_non_python_notebook",
-                "displayName": "Start Notebook Kernel",
-                "modelDescription": "Selects the Notebook Kernel and starts it.",
-                "tags": [
-                    "extension_installed_by_tool",
-                    "jupyter",
-                    "notebooks"
-                ],
-                "inputSchema": {
-                    "type": "object",
-                    "properties": {
-                        "filePath": {
-                            "description": "The absolute path of the notebook with the active kernel.",
-                            "type": "string"
-                        }
-                    },
-                    "required": [
-                        "filePath"
-                    ]
-                },
-                "when": "false"
-            },
-            {
-                "name": "notebook_list_packages",
-                "displayName": "List Notebook Kernel Packages",
+                "name": "deepnote_notebook_list_packages",
+                "displayName": "List Deepnote Notebook Kernel Packages",
                 "modelDescription": "List the installed packages that are currently available in the selected kernel for a notebook editor. This tool should be used when working with a jupyter notebook with python code cells. Do not use this tool if not already working with a notebook, or for a language other than python. If the tool configure_notebooks exists, then ensure to call configure_notebooks before using this tool.",
-                "userDescription": "%deepnote.languageModelTools.notebook_list_packages.userDescription%",
+                "userDescription": "%deepnote.languageModelTools.deepnote_notebook_list_packages.userDescription%",
                 "toolReferenceName": "listNotebookPackages",
                 "tags": [
                     "python environment",
@@ -2392,11 +2346,11 @@
                 }
             },
             {
-                "name": "notebook_install_packages",
+                "name": "deepnote_notebook_install_packages",
                 "displayName": "Install Packages for Notebook",
                 "modelDescription": "Install a list of packages on a notebook kernel to be used within that notebook. This tool should be used when working with a jupyter notebook with python code cells. Do not use this tool if not already working with a notebook, or for a language other than python. If the tool configure_notebooks exists, then ensure to call configure_notebooks before using this tool.",
-                "userDescription": "%deepnote.languageModelTools.notebook_install_packages.userDescription%",
-                "toolReferenceName": "installNotebookPackages",
+                "userDescription": "%deepnote.languageModelTools.deepnote_notebook_install_packages.userDescription%",
+                "toolReferenceName": "installDeepnoteNotebookPackages",
                 "tags": [
                     "python environment",
                     "jupyter environment",
@@ -2428,10 +2382,10 @@
                 }
             },
             {
-                "name": "restart_notebook_kernel",
-                "displayName": "Restart Notebook",
+                "name": "restart_deepnote_notebook_kernel",
+                "displayName": "Restart Deepnote Notebook",
                 "modelDescription": "Tool used to restart a Notebook kernel. Some packages require a restart of the kernel after being installed. Use this if after installing a package if you know the package requires a restart, or if still getting an error about a missing package after installing.",
-                "toolReferenceName": "restartNotebookKernel",
+                "toolReferenceName": "restartDeepnoteNotebookKernel",
                 "tags": [
                     "extension_installed_by_tool",
                     "jupyter",
diff --git a/package.nls.json b/package.nls.json
index a449eda77a..5817dea8b2 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -241,10 +241,10 @@
     "DataScience.installPythonTitle": "Install Python",
     "DataScience.installPythonExtensionViaKernelPickerTitle": "Install Python Extension",
     "DataScience.switchToRemoteKernelsTitle": "Connect to a Jupyter Server",
-    "deepnote.languageModelTools.configure_notebook.displayName": "Configure Jupyter Notebook",
-    "deepnote.languageModelTools.configure_notebook.userDescription": "Ensure Notebook is ready for use, such as running cells.",
-    "deepnote.languageModelTools.notebook_list_packages.userDescription": "Lists Python packages available in the selected Notebook Kernel.",
-    "deepnote.languageModelTools.notebook_install_packages.userDescription": "Installs Python packages in the selected Notebook Kernel.",
+    "deepnote.languageModelTools.configure_deepnote_notebook.displayName": "Configure Deepnote Notebook",
+    "deepnote.languageModelTools.configure_deepnote_notebook.userDescription": "Ensure Notebook is ready for use, such as running cells.",
+    "deepnote.languageModelTools.deepnote_notebook_list_packages.userDescription": "Lists Python packages available in the selected Notebook Kernel.",
+    "deepnote.languageModelTools.deepnote_notebook_install_packages.userDescription": "Installs Python packages in the selected Notebook Kernel.",
     "deepnote.notebook.displayName": "Deepnote Notebook",
     "deepnote.commands.refreshExplorer.title": "Refresh Explorer",
     "deepnote.commands.openNotebook.title": "Open Notebook",
diff --git a/src/commands.ts b/src/commands.ts
index 983371cd54..edc0b09e91 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -45,7 +45,7 @@ export interface ICommandNameArgumentTypeMapping {
     ['editor.action.rename']: [];
     ['deepnote.selectJupyterInterpreter']: [];
     ['dataScience.ClearUserProviderJupyterServerCache']: [];
-    ['jupyterViewVariables.focus']: [];
+    ['deepnoteViewVariables.focus']: [];
     ['deepnote.selectLocalJupyterServer']: [] | [undefined | string];
     ['workbench.action.openSettings']: ['deepnote.kernels.excludePythonEnvironments'];
     ['deepnote.getUsedAzMLServerHandles']: [];
diff --git a/src/interactive-window/commands/commandRegistry.ts b/src/interactive-window/commands/commandRegistry.ts
index cd418ce179..4b1b206c7d 100644
--- a/src/interactive-window/commands/commandRegistry.ts
+++ b/src/interactive-window/commands/commandRegistry.ts
@@ -533,7 +533,7 @@ export class CommandRegistry implements IDisposable, IExtensionSyncActivationSer
     private async openVariableView(): Promise<void> {
         // For all contributed views vscode creates a command with the format [view ID].focus to focus that view
         // It's the given way to focus a single view so using that here, note that it needs to match the view ID
-        return commands.executeCommand('jupyterViewVariables.focus');
+        return commands.executeCommand('deepnoteViewVariables.focus');
     }
 
     // Open the VS Code outline view
diff --git a/src/platform/webviews/types.ts b/src/platform/webviews/types.ts
index 5dde8bf53e..92027181e5 100644
--- a/src/platform/webviews/types.ts
+++ b/src/platform/webviews/types.ts
@@ -35,7 +35,7 @@ export type WebViewViewChangeEventArgs = { current: WebViewViewState; previous:
 
 // Wraps the VS Code WebviewViewProvider. VSC Prefix as we also have our own IWebviewViewProvider
 export interface IVSCWebviewViewProvider extends WebviewViewProvider {
-    readonly viewType: 'jupyterViewVariables';
+    readonly viewType: 'deepnoteViewVariables';
 }
 
 /**
diff --git a/src/standalone/chat/configureNotebook.node.ts b/src/standalone/chat/configureNotebook.node.ts
index c97a1eeee7..ea8fa36e54 100644
--- a/src/standalone/chat/configureNotebook.node.ts
+++ b/src/standalone/chat/configureNotebook.node.ts
@@ -29,7 +29,7 @@ import { BaseTool, IBaseToolParams, sendConfigureNotebookToolCallTelemetry } fro
 import { basename } from '../../platform/vscode-path/resources';
 
 export class ConfigureNotebookTool extends BaseTool<IBaseToolParams> {
-    public static toolName = 'configure_notebook';
+    public static toolName = 'configure_deepnote_notebook';
     constructor(
         private readonly controllerRegistration: IControllerRegistration,
         private readonly kernelDependencyService: IKernelDependencyService,
diff --git a/src/standalone/chat/installPackageTool.node.ts b/src/standalone/chat/installPackageTool.node.ts
index 0217dc775e..8c9550e458 100644
--- a/src/standalone/chat/installPackageTool.node.ts
+++ b/src/standalone/chat/installPackageTool.node.ts
@@ -16,7 +16,7 @@ import { BaseTool, IBaseToolParams } from './helper';
 import { WrappedError } from '../../platform/errors/types';
 
 export class InstallPackagesTool extends BaseTool<IInstallPackageParams> {
-    public static toolName = 'notebook_install_packages';
+    public static toolName = 'deepnote_notebook_install_packages';
     constructor(
         private readonly kernelProvider: IKernelProvider,
         private readonly controllerRegistration: IControllerRegistration,
diff --git a/src/standalone/chat/listPackageTool.node.ts b/src/standalone/chat/listPackageTool.node.ts
index 70d49c54f4..47edd03244 100644
--- a/src/standalone/chat/listPackageTool.node.ts
+++ b/src/standalone/chat/listPackageTool.node.ts
@@ -17,7 +17,7 @@ import { BaseTool, IBaseToolParams } from './helper';
 import { WrappedError } from '../../platform/errors/types';
 
 export class ListPackageTool extends BaseTool<IBaseToolParams> {
-    public static toolName = 'notebook_list_packages';
+    public static toolName = 'deepnote_notebook_list_packages';
     constructor(
         private readonly kernelProvider: IKernelProvider,
         private readonly controllerRegistration: IControllerRegistration
diff --git a/src/standalone/chat/restartKernelTool.node.ts b/src/standalone/chat/restartKernelTool.node.ts
index f56126709c..cd73d8fe14 100644
--- a/src/standalone/chat/restartKernelTool.node.ts
+++ b/src/standalone/chat/restartKernelTool.node.ts
@@ -15,7 +15,7 @@ interface RestartKernelToolParams extends IBaseToolParams {
 }
 
 export class RestartKernelTool extends BaseTool<RestartKernelToolParams> {
-    public static toolName = 'restart_notebook_kernel';
+    public static toolName = 'restart_deepnote_notebook_kernel';
 
     constructor(
         private readonly kernelProvider: IKernelProvider,
@@ -44,7 +44,7 @@ export class RestartKernelTool extends BaseTool<RestartKernelToolParams> {
         const kernel = this.kernelProvider.get(notebook);
         if (!controller || !kernel || !hasKernelStartedOrIsStarting(kernel)) {
             throw new WrappedError(
-                `No active kernel for notebook ${options.input.filePath}, the configure_notebook tool can be used to help the user select a kernel.`,
+                `No active kernel for notebook ${options.input.filePath}, the configure_deepnote_notebook tool can be used to help the user select a kernel.`,
                 undefined,
                 'noActiveKernel'
             );
diff --git a/src/webviews/extension-side/variablesView/variableViewProvider.ts b/src/webviews/extension-side/variablesView/variableViewProvider.ts
index a2f21bd547..3982642d65 100644
--- a/src/webviews/extension-side/variablesView/variableViewProvider.ts
+++ b/src/webviews/extension-side/variablesView/variableViewProvider.ts
@@ -15,7 +15,7 @@ import { DataViewerDelegator } from '../dataviewer/dataViewerDelegator';
 // This class creates our UI for our variable view and links it to the vs code webview view
 @injectable()
 export class VariableViewProvider implements IVariableViewProvider {
-    public readonly viewType = 'jupyterViewVariables';
+    public readonly viewType = 'deepnoteViewVariables';
 
     // Either return the active variable view or wait until it's created and return it
     // @ts-ignore Property will be accessed in test code via casting to ITestVariableViewProviderInterface

From cefe13a8eb62be1d49521d6599a173e093da4137 Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 11:10:11 +0000
Subject: [PATCH 3/7] Fix translation ids

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index b91b3ab390..d8ee9637e4 100644
--- a/package.json
+++ b/package.json
@@ -2290,9 +2290,9 @@
         "languageModelTools": [
             {
                 "name": "configure_deepnote_notebook",
-                "displayName": "%deepnote.languageModelTools.configure_notebook.displayName%",
+                "displayName": "%deepnote.languageModelTools.configure_deepnote_notebook.displayName%",
                 "modelDescription": "Tool used to configure a Notebook. ALWAYS use this tool before running/executing any Notebook Cells for the first time or before listing/installing packages in Notebooks for the first time. I.e. there is no need to use this tool more than once for the same notebook.",
-                "userDescription": "%deepnote.languageModelTools.configure_notebook.userDescription%",
+                "userDescription": "%deepnote.languageModelTools.configure_deepnote_notebook.userDescription%",
                 "toolReferenceName": "configureNotebook",
                 "tags": [
                     "python environment",

From 2a591b17d53edd1f281fc56328374d87a31e8c66 Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 13:59:24 +0000
Subject: [PATCH 4/7] fix: Update configuration references from 'jupyter' to
 'deepnote'

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 package.json                                           |  4 ++--
 src/extension.node.ts                                  |  2 +-
 src/extension.web.ts                                   |  2 +-
 src/kernels/raw/finder/trustedKernelPaths.node.ts      |  2 +-
 src/kernels/raw/finder/trustedKernelPaths.unit.test.ts |  2 +-
 .../raw/finder/trustedKernrelPaths.unit.test.ts        |  2 +-
 src/kernels/raw/session/rawKernelConnection.node.ts    |  2 +-
 src/platform/common/configSettings.ts                  |  4 ++--
 src/platform/common/configuration/service.unit.test.ts |  2 +-
 src/platform/common/constants.ts                       |  2 +-
 src/platform/common/featureManager.ts                  |  4 ++--
 src/platform/interpreter/filter/filterService.ts       |  4 ++--
 src/platform/interpreter/filter/settingsMigration.ts   | 10 +++++-----
 src/platform/interpreter/reservedNamedProvider.node.ts |  8 ++++----
 .../reservedNamedProvider.node.unit.test.ts            |  4 ++--
 src/platform/logging/index.ts                          |  2 +-
 src/standalone/executionAnalysis/extension.ts          |  2 +-
 .../intellisense/kernelCompletionProvider.ts           |  4 ++--
 src/test/common.web.ts                                 |  2 +-
 .../interactiveWindow.vscode.common.test.ts            |  8 ++++----
 src/test/datascience/jupyter/connection.vscode.test.ts |  2 +-
 .../datascience/notebook/exportFull.vscode.test.ts     |  8 ++++----
 .../completionProvider.vscode.common.test.ts           |  2 +-
 .../widgets/standardWidgets.vscode.common.test.ts      |  2 +-
 .../widgets/thirdpartyWidgets.vscode.common.test.ts    |  2 +-
 src/test/web/clientApi.ts                              |  6 ++++--
 26 files changed, 48 insertions(+), 46 deletions(-)

diff --git a/package.json b/package.json
index d8ee9637e4..17e6cae7e6 100644
--- a/package.json
+++ b/package.json
@@ -1363,13 +1363,13 @@
                     "command": "deepnote.exportfileasnotebook",
                     "title": "%deepnote.command.deepnote.exportfileasnotebook.title%",
                     "category": "Jupyter",
-                    "when": "deepnote.ispythonorinteractiveeactive && !notebookEditorFocused && isWorkspaceTrusted"
+                    "when": "deepnote.ispythonorinteractiveactive && !notebookEditorFocused && isWorkspaceTrusted"
                 },
                 {
                     "command": "deepnote.restartkernel",
                     "title": "%deepnote.command.deepnote.restartkernel.title%",
                     "category": "Jupyter",
-                    "when": "(deepnote.ispythonorinteractiveeactive || deepnote.isnativeactive) && isWorkspaceTrusted"
+                    "when": "(deepnote.ispythonorinteractiveactive || deepnote.isnativeactive) && isWorkspaceTrusted"
                 },
                 {
                     "command": "deepnote.notebookeditor.removeallcells",
diff --git a/src/extension.node.ts b/src/extension.node.ts
index ef0eeb864e..6f6b29443f 100644
--- a/src/extension.node.ts
+++ b/src/extension.node.ts
@@ -219,7 +219,7 @@ async function activateLegacy(
     const isDevMode =
         !isTestExecution() &&
         (context.extensionMode === ExtensionMode.Development ||
-            workspace.getConfiguration('jupyter').get<boolean>('development', false));
+            workspace.getConfiguration('deepnote').get<boolean>('development', false));
     serviceManager.addSingletonInstance<boolean>(IsDevMode, isDevMode);
     if (isDevMode) {
         commands.executeCommand('setContext', 'deepnote.development', true).then(noop, noop);
diff --git a/src/extension.web.ts b/src/extension.web.ts
index e05a1575d7..7b632e7bf7 100644
--- a/src/extension.web.ts
+++ b/src/extension.web.ts
@@ -174,7 +174,7 @@ async function activateLegacy(
     // register "services"
     const isDevMode =
         context.extensionMode === ExtensionMode.Development ||
-        workspace.getConfiguration('jupyter').get<boolean>('development', false);
+        workspace.getConfiguration('deepnote').get<boolean>('development', false);
 
     serviceManager.addSingletonInstance<boolean>(IsDevMode, isDevMode);
     if (isDevMode) {
diff --git a/src/kernels/raw/finder/trustedKernelPaths.node.ts b/src/kernels/raw/finder/trustedKernelPaths.node.ts
index e28ae0f2c2..63b0b4531c 100644
--- a/src/kernels/raw/finder/trustedKernelPaths.node.ts
+++ b/src/kernels/raw/finder/trustedKernelPaths.node.ts
@@ -16,7 +16,7 @@ export class TrustedKernelPaths implements ITrustedKernelPaths {
         : undefined;
     constructor(@inject(IPlatformService) private readonly platform: IPlatformService) {}
     private get trustedKernelSpecs(): string[] {
-        return workspace.getConfiguration('jupyter', undefined).get<string[]>('kernels.trusted', []);
+        return workspace.getConfiguration('deepnote', undefined).get<string[]>('kernels.trusted', []);
     }
     public isTrusted(kernelPath: Uri): boolean {
         const trusted = this.isTrustedImpl(kernelPath);
diff --git a/src/kernels/raw/finder/trustedKernelPaths.unit.test.ts b/src/kernels/raw/finder/trustedKernelPaths.unit.test.ts
index 75d2715643..54ace45577 100644
--- a/src/kernels/raw/finder/trustedKernelPaths.unit.test.ts
+++ b/src/kernels/raw/finder/trustedKernelPaths.unit.test.ts
@@ -22,7 +22,7 @@ suite('Trusted Kernel paths', () => {
         function createTrustedPathService() {
             jupyterConfig = mock<WorkspaceConfiguration>();
             when(jupyterConfig.get('kernels.trusted', anything())).thenCall((_, defaultValue) => defaultValue);
-            when(mockedVSCodeNamespaces.workspace.getConfiguration('jupyter', anything())).thenReturn(
+            when(mockedVSCodeNamespaces.workspace.getConfiguration('deepnote', anything())).thenReturn(
                 instance(jupyterConfig)
             );
             platform = mock<IPlatformService>();
diff --git a/src/kernels/raw/finder/trustedKernrelPaths.unit.test.ts b/src/kernels/raw/finder/trustedKernrelPaths.unit.test.ts
index 7ace818512..e9db51ca40 100644
--- a/src/kernels/raw/finder/trustedKernrelPaths.unit.test.ts
+++ b/src/kernels/raw/finder/trustedKernrelPaths.unit.test.ts
@@ -21,7 +21,7 @@ suite('Trusted Kernel paths', () => {
         function createTrustedPathService() {
             jupyterConfig = mock<WorkspaceConfiguration>();
             when(jupyterConfig.get('kernels.trusted', anything())).thenCall((_, defaultValue) => defaultValue);
-            when(mockedVSCodeNamespaces.workspace.getConfiguration('jupyter', anything())).thenReturn(
+            when(mockedVSCodeNamespaces.workspace.getConfiguration('deepnote', anything())).thenReturn(
                 instance(jupyterConfig)
             );
             platform = mock<IPlatformService>();
diff --git a/src/kernels/raw/session/rawKernelConnection.node.ts b/src/kernels/raw/session/rawKernelConnection.node.ts
index 386523f763..a57da8ecf4 100644
--- a/src/kernels/raw/session/rawKernelConnection.node.ts
+++ b/src/kernels/raw/session/rawKernelConnection.node.ts
@@ -680,7 +680,7 @@ function newRawKernel(kernelProcess: IKernelProcess, clientId: string, username:
         username,
         model
     });
-    if (workspace.getConfiguration('jupyter').get('enablePythonKernelLogging', false)) {
+    if (workspace.getConfiguration('deepnote').get('enablePythonKernelLogging', false)) {
         realKernel.anyMessage.connect((_, msg) => {
             logger.trace(`[AnyMessage Event] [${msg.direction}] [${kernelProcess.pid}] ${JSON.stringify(msg.msg)}`);
         });
diff --git a/src/platform/common/configSettings.ts b/src/platform/common/configSettings.ts
index 15385ad175..425492bd21 100644
--- a/src/platform/common/configSettings.ts
+++ b/src/platform/common/configSettings.ts
@@ -222,7 +222,7 @@ export class JupyterSettings implements IWatchableJupyterSettings {
 
     private initialize(): void {
         const onDidChange = () => {
-            const currentConfig = workspace.getConfiguration('jupyter', this._workspaceRoot);
+            const currentConfig = workspace.getConfiguration('deepnote', this._workspaceRoot);
             const pythonConfig = workspace.getConfiguration('python', this._workspaceRoot);
             this.update(currentConfig, pythonConfig);
 
@@ -242,7 +242,7 @@ export class JupyterSettings implements IWatchableJupyterSettings {
             })
         );
 
-        const initialConfig = workspace.getConfiguration('jupyter', this._workspaceRoot);
+        const initialConfig = workspace.getConfiguration('deepnote', this._workspaceRoot);
         const pythonConfig = workspace.getConfiguration('python', this._workspaceRoot);
         if (initialConfig) {
             this.update(initialConfig, pythonConfig);
diff --git a/src/platform/common/configuration/service.unit.test.ts b/src/platform/common/configuration/service.unit.test.ts
index 784ded6581..7c040ce87a 100644
--- a/src/platform/common/configuration/service.unit.test.ts
+++ b/src/platform/common/configuration/service.unit.test.ts
@@ -23,7 +23,7 @@ suite('Configuration Service', () => {
 
     function setupConfigProvider(): WorkspaceConfiguration {
         const workspaceConfig = mock<WorkspaceConfiguration>();
-        when(mockedVSCodeNamespaces.workspace.getConfiguration('jupyter', uriEquals(resource))).thenReturn(
+        when(mockedVSCodeNamespaces.workspace.getConfiguration('deepnote', uriEquals(resource))).thenReturn(
             instance(workspaceConfig)
         );
         return workspaceConfig;
diff --git a/src/platform/common/constants.ts b/src/platform/common/constants.ts
index 12457f3757..e67f48f139 100644
--- a/src/platform/common/constants.ts
+++ b/src/platform/common/constants.ts
@@ -296,7 +296,7 @@ export namespace EditorContexts {
     export const IsNativeActive = 'deepnote.isnativeactive';
     export const IsInteractiveOrNativeActive = 'deepnote.isinteractiveornativeactive';
     export const IsPythonOrNativeActive = 'deepnote.ispythonornativeactive';
-    export const IsPythonOrInteractiveActive = 'deepnote.ispythonorinteractiveeactive';
+    export const IsPythonOrInteractiveActive = 'deepnote.ispythonorinteractiveactive';
     export const IsPythonOrInteractiveOrNativeActive = 'deepnote.ispythonorinteractiveornativeeactive';
     export const CanRestartNotebookKernel = 'deepnote.notebookeditor.canrestartNotebookkernel';
     export const CanInterruptNotebookKernel = 'deepnote.notebookeditor.canInterruptNotebookKernel';
diff --git a/src/platform/common/featureManager.ts b/src/platform/common/featureManager.ts
index a824a56da3..18de8c78a1 100644
--- a/src/platform/common/featureManager.ts
+++ b/src/platform/common/featureManager.ts
@@ -127,13 +127,13 @@ export class FeatureManager implements IFeaturesManager {
                     return;
                 }
                 notify = this.isDeprecatedSettingAndValueUsed(
-                    workspace.getConfiguration('jupyter', workspaceFolder.uri),
+                    workspace.getConfiguration('deepnote', workspaceFolder.uri),
                     deprecatedInfo.setting!
                 );
             });
         } else {
             notify = this.isDeprecatedSettingAndValueUsed(
-                workspace.getConfiguration('jupyter'),
+                workspace.getConfiguration('deepnote'),
                 deprecatedInfo.setting!
             );
         }
diff --git a/src/platform/interpreter/filter/filterService.ts b/src/platform/interpreter/filter/filterService.ts
index 901d180e8c..a15f500d77 100644
--- a/src/platform/interpreter/filter/filterService.ts
+++ b/src/platform/interpreter/filter/filterService.ts
@@ -55,14 +55,14 @@ export class PythonEnvironmentFilter implements IDisposable {
         // As there's no way to provide controllers per folder.
         if (!workspace.workspaceFolders || workspace.workspaceFolders.length === 0) {
             return workspace
-                .getConfiguration('jupyter', undefined)
+                .getConfiguration('deepnote', undefined)
                 .get<string[]>('kernels.excludePythonEnvironments', []);
         }
         const filters: string[] = [];
         workspace.workspaceFolders.forEach((item) => {
             filters.push(
                 ...workspace
-                    .getConfiguration('jupyter', item.uri)
+                    .getConfiguration('deepnote', item.uri)
                     .get<string[]>('kernels.excludePythonEnvironments', [])
             );
         });
diff --git a/src/platform/interpreter/filter/settingsMigration.ts b/src/platform/interpreter/filter/settingsMigration.ts
index 1d1fd7b411..8045d82bec 100644
--- a/src/platform/interpreter/filter/settingsMigration.ts
+++ b/src/platform/interpreter/filter/settingsMigration.ts
@@ -16,28 +16,28 @@ export class PythonEnvFilterSettingMigration implements IExtensionSyncActivation
         // As there's no way to provide controllers per folder.
         const workspaceFolders = Array.isArray(workspace.workspaceFolders) ? workspace.workspaceFolders : [];
         await this.migrateWorkspaceFilters(
-            workspace.getConfiguration('jupyter', undefined),
+            workspace.getConfiguration('deepnote', undefined),
             ConfigurationTarget.Global
         );
         if (workspaceFolders.length === 0) {
             await this.migrateWorkspaceFilters(
-                workspace.getConfiguration('jupyter', undefined),
+                workspace.getConfiguration('deepnote', undefined),
                 ConfigurationTarget.Global
             );
         } else if (workspaceFolders.length === 1) {
             await this.migrateWorkspaceFilters(
-                workspace.getConfiguration('jupyter', workspaceFolders[0].uri),
+                workspace.getConfiguration('deepnote', workspaceFolders[0].uri),
                 ConfigurationTarget.WorkspaceFolder
             );
         } else {
             await this.migrateWorkspaceFilters(
-                workspace.getConfiguration('jupyter', undefined),
+                workspace.getConfiguration('deepnote', undefined),
                 ConfigurationTarget.Workspace
             );
             await Promise.all(
                 workspaceFolders.map((workspaceFolder) =>
                     this.migrateWorkspaceFilters(
-                        workspace.getConfiguration('jupyter', workspaceFolder.uri),
+                        workspace.getConfiguration('deepnote', workspaceFolder.uri),
                         ConfigurationTarget.WorkspaceFolder
                     )
                 )
diff --git a/src/platform/interpreter/reservedNamedProvider.node.ts b/src/platform/interpreter/reservedNamedProvider.node.ts
index 0d41cd1b75..68a2440cbe 100644
--- a/src/platform/interpreter/reservedNamedProvider.node.ts
+++ b/src/platform/interpreter/reservedNamedProvider.node.ts
@@ -12,7 +12,7 @@ import minimatch from 'minimatch';
 import { IFileSystemNode } from '../common/platform/types.node';
 import * as path from '../../platform/vscode-path/resources';
 
-const PYTHON_PACKAGES_MEMENTO_KEY = 'jupyter.pythonPackages';
+const PYTHON_PACKAGES_MEMENTO_KEY = 'deepnote.pythonPackages';
 export const ignoreListSettingName = 'diagnostics.reservedPythonNames.exclude';
 /**
  * Determines if a file or directory in the workspace is overriding a reserved python name.
@@ -35,7 +35,7 @@ export class ReservedNamedProvider implements IReservedPythonNamedProvider {
         );
         workspace.onDidChangeConfiguration(
             (e) => {
-                if (e.affectsConfiguration(`jupyter.${ignoreListSettingName}`)) {
+                if (e.affectsConfiguration(`deepnote.${ignoreListSettingName}`)) {
                     this.initializeIgnoreList();
                 }
             },
@@ -104,7 +104,7 @@ export class ReservedNamedProvider implements IReservedPythonNamedProvider {
     }
     public async addToIgnoreList(uri: Uri) {
         await this.pendingUpdate;
-        const jupyterConfig = workspace.getConfiguration('jupyter');
+        const jupyterConfig = workspace.getConfiguration('deepnote');
         const filePath = this.platform.isWindows ? uri.fsPath.toLowerCase() : uri.fsPath;
         this.initializeIgnoreList();
         const originalSizeOfList = this.ignoredFiles.size;
@@ -118,7 +118,7 @@ export class ReservedNamedProvider implements IReservedPythonNamedProvider {
         return this.pendingUpdate;
     }
     private initializeIgnoreList() {
-        const jupyterConfig = workspace.getConfiguration('jupyter');
+        const jupyterConfig = workspace.getConfiguration('deepnote');
         let listInSettings = jupyterConfig.get(ignoreListSettingName, []) as string[];
         // Ignore file case on windows, hence lower case the files.
         if (this.platform.isWindows) {
diff --git a/src/platform/interpreter/reservedNamedProvider.node.unit.test.ts b/src/platform/interpreter/reservedNamedProvider.node.unit.test.ts
index 132d9ec157..091e61ed29 100644
--- a/src/platform/interpreter/reservedNamedProvider.node.unit.test.ts
+++ b/src/platform/interpreter/reservedNamedProvider.node.unit.test.ts
@@ -36,7 +36,7 @@ suite('Reserved Names Provider', () => {
         fs = mock<IFileSystemNode>();
         workspaceConfig = mock<WorkspaceConfiguration>();
         when(memento.update(anything(), anything())).thenResolve();
-        when(mockedVSCodeNamespaces.workspace.getConfiguration('jupyter')).thenReturn(instance(workspaceConfig));
+        when(mockedVSCodeNamespaces.workspace.getConfiguration('deepnote')).thenReturn(instance(workspaceConfig));
         when(workspaceConfig.get(ignoreListSettingName, anything())).thenReturn(defaultIgnoreList);
         when(memento.get(anything(), anything())).thenCall((_, defaultValue) => defaultValue as any);
         settingsChanged = new EventEmitter<ConfigurationChangeEvent>();
@@ -197,7 +197,7 @@ suite('Reserved Names Provider', () => {
         // Now, lets change the setting to un-ignore the above file.
         ignoreListInSettings = [...defaultIgnoreList];
         settingsChanged.fire({
-            affectsConfiguration: (section) => section === `jupyter.${ignoreListSettingName}`
+            affectsConfiguration: (section) => section === `deepnote.${ignoreListSettingName}`
         });
 
         uris = await reservedNamedProvider.getUriOverridingReservedPythonNames(cwd);
diff --git a/src/platform/logging/index.ts b/src/platform/logging/index.ts
index af56db850e..7253106e3b 100644
--- a/src/platform/logging/index.ts
+++ b/src/platform/logging/index.ts
@@ -88,7 +88,7 @@ type LoggingLevelSettingType = keyof typeof LogLevel | Lowercase<keyof typeof Lo
 function getLoggingLevelFromConfig() {
     try {
         const { level } = workspace
-            .getConfiguration('jupyter')
+            .getConfiguration('deepnote')
             .get<{ level: LoggingLevelSettingType }>('logging', { level: 'Info' });
         switch (level) {
             case 'debug':
diff --git a/src/standalone/executionAnalysis/extension.ts b/src/standalone/executionAnalysis/extension.ts
index 4c8880db93..06ebca8934 100644
--- a/src/standalone/executionAnalysis/extension.ts
+++ b/src/standalone/executionAnalysis/extension.ts
@@ -7,7 +7,7 @@ import { findNotebookAndCell, noop } from './common';
 import { ExecutionFixCodeActionsProvider, SymbolsTracker } from './symbols';
 
 export async function activate(context: vscode.ExtensionContext): Promise<void> {
-    const optInto = vscode.workspace.getConfiguration('jupyter').get<boolean>('executionAnalysis.enabled');
+    const optInto = vscode.workspace.getConfiguration('deepnote').get<boolean>('executionAnalysis.enabled');
     if (!optInto) {
         return;
     }
diff --git a/src/standalone/intellisense/kernelCompletionProvider.ts b/src/standalone/intellisense/kernelCompletionProvider.ts
index 507a04e93b..25f136259f 100644
--- a/src/standalone/intellisense/kernelCompletionProvider.ts
+++ b/src/standalone/intellisense/kernelCompletionProvider.ts
@@ -559,12 +559,12 @@ function getKernelLanguage(kernel: IKernel) {
 }
 
 function isKernelCompletionEnabled(resource: Resource) {
-    return workspace.getConfiguration('jupyter', resource).get<boolean>('enableKernelCompletions', false);
+    return workspace.getConfiguration('deepnote', resource).get<boolean>('enableKernelCompletions', false);
 }
 
 function getCompletionTriggerCharacter(kernel: IKernel) {
     const triggerCharacters = workspace
-        .getConfiguration('jupyter', kernel.notebook.uri)
+        .getConfiguration('deepnote', kernel.notebook.uri)
         .get<Record<string, string[]>>('completionTriggerCharacters');
 
     // Check if object, as this used to be a different setting a few years ago (when it was specific to Python).
diff --git a/src/test/common.web.ts b/src/test/common.web.ts
index d065e17589..69b89cc809 100644
--- a/src/test/common.web.ts
+++ b/src/test/common.web.ts
@@ -61,7 +61,7 @@ export function initializeCommonWebApi() {
             password?: string;
         }): Promise<{ url: string } & IDisposable> {
             // DEBUG_JUPYTER_SERVER_URI is not a valid setting, but updated when we launch the tests via vscode debugger.
-            const url = workspace.getConfiguration('jupyter').get('DEBUG_JUPYTER_SERVER_URI', JUPYTER_SERVER_URI);
+            const url = workspace.getConfiguration('deepnote').get('DEBUG_JUPYTER_SERVER_URI', JUPYTER_SERVER_URI);
             console.log(`ServerURI for remote test: ${url}`);
             // Server URI should have been embedded in the constants file
             const uri = Uri.parse(url);
diff --git a/src/test/datascience/interactiveWindow.vscode.common.test.ts b/src/test/datascience/interactiveWindow.vscode.common.test.ts
index 98f3074193..ee1f1fd91d 100644
--- a/src/test/datascience/interactiveWindow.vscode.common.test.ts
+++ b/src/test/datascience/interactiveWindow.vscode.common.test.ts
@@ -78,7 +78,7 @@ suite(`Interactive window execution @iw`, async function () {
         }
         await closeNotebooksAndCleanUpAfterTests(disposables);
         // restore the default value
-        const settings = vscode.workspace.getConfiguration('jupyter', null);
+        const settings = vscode.workspace.getConfiguration('deepnote', null);
         await settings.update('interactiveWindow.creationMode', 'multiple');
         logger.info(`Ended Test (completed) ${this.currentTest?.title}`);
     });
@@ -219,7 +219,7 @@ suite(`Interactive window execution @iw`, async function () {
     });
 
     test('Multiple interactive windows', async () => {
-        const settings = vscode.workspace.getConfiguration('jupyter', null);
+        const settings = vscode.workspace.getConfiguration('deepnote', null);
         await settings.update('interactiveWindow.creationMode', 'multiple');
         const window1 = await interactiveWindowProvider.getOrCreate(undefined);
         const window2 = await interactiveWindowProvider.getOrCreate(undefined);
@@ -397,7 +397,7 @@ ${actualCode}
         await waitForTextOutput(secondCell!, '1');
     });
     test('Error stack traces have correct line hrefs with mix of cell sources', async function () {
-        const settings = vscode.workspace.getConfiguration('jupyter', null);
+        const settings = vscode.workspace.getConfiguration('deepnote', null);
         await settings.update('interactiveWindow.creationMode', 'single');
 
         const interactiveWindow = await createStandaloneInteractiveWindow(interactiveWindowProvider);
@@ -576,7 +576,7 @@ ${actualCode}
 
         let runFilePromise = vscode.commands.executeCommand(Commands.RunAllCells);
 
-        const settings = vscode.workspace.getConfiguration('jupyter', null);
+        const settings = vscode.workspace.getConfiguration('deepnote', null);
         const mode = (await settings.get('interactiveWindow.creationMode')) as InteractiveWindowMode;
         const interactiveWindow = interactiveWindowProvider.getExisting(tempFile.file, mode) as InteractiveWindow;
         await runInteractiveWindowInput('x = 5', interactiveWindow, 5);
diff --git a/src/test/datascience/jupyter/connection.vscode.test.ts b/src/test/datascience/jupyter/connection.vscode.test.ts
index 6c83f721a3..4e24279ab0 100644
--- a/src/test/datascience/jupyter/connection.vscode.test.ts
+++ b/src/test/datascience/jupyter/connection.vscode.test.ts
@@ -228,7 +228,7 @@ suite('Connect to Remote Jupyter Servers @mandatory', function () {
         userUri: string;
         failWithInvalidPassword?: boolean;
     }) {
-        const config = workspace.getConfiguration('jupyter');
+        const config = workspace.getConfiguration('deepnote');
         const displayName = 'Test Remove Server Name';
         void env.clipboard.writeText(userUri);
         sinon.stub(UserJupyterServerUriInput.prototype, 'getUrlFromUser').resolves({
diff --git a/src/test/datascience/notebook/exportFull.vscode.test.ts b/src/test/datascience/notebook/exportFull.vscode.test.ts
index 379e211502..7a4aad08ab 100644
--- a/src/test/datascience/notebook/exportFull.vscode.test.ts
+++ b/src/test/datascience/notebook/exportFull.vscode.test.ts
@@ -109,7 +109,7 @@ suite('Export @export', function () {
             await captureScreenShot(this);
         }
         // Revert back our settings just in case
-        const settings = workspace.getConfiguration('jupyter', null);
+        const settings = workspace.getConfiguration('deepnote', null);
         await settings.update('pythonExportMethod', 'direct', ConfigurationTarget.Global);
 
         await closeNotebooksAndCleanUpAfterTests(disposables);
@@ -160,7 +160,7 @@ suite('Export @export', function () {
             }
         });
 
-        const settings = workspace.getConfiguration('jupyter', null);
+        const settings = workspace.getConfiguration('deepnote', null);
         await settings.update('pythonExportMethod', 'commentMagics', ConfigurationTarget.Global);
 
         // Execute our export command
@@ -193,7 +193,7 @@ suite('Export @export', function () {
             }
         });
 
-        const settings = workspace.getConfiguration('jupyter', null);
+        const settings = workspace.getConfiguration('deepnote', null);
         await settings.update('pythonExportMethod', 'nbconvert', ConfigurationTarget.Global);
 
         // Execute our export command
@@ -274,7 +274,7 @@ suite('Export @export', function () {
         });
 
         // Set to nbconvert
-        const settings = workspace.getConfiguration('jupyter', null);
+        const settings = workspace.getConfiguration('deepnote', null);
         await settings.update('pythonExportMethod', 'nbconvert', ConfigurationTarget.Global);
 
         // Execute our export command
diff --git a/src/test/datascience/notebook/intellisense/completionProvider.vscode.common.test.ts b/src/test/datascience/notebook/intellisense/completionProvider.vscode.common.test.ts
index fc79bf92a7..cc889a3e19 100644
--- a/src/test/datascience/notebook/intellisense/completionProvider.vscode.common.test.ts
+++ b/src/test/datascience/notebook/intellisense/completionProvider.vscode.common.test.ts
@@ -43,7 +43,7 @@ import { IKernelProvider } from '../../../../kernels/types';
                 }
                 logger.info(`Start Suite Code Completion via Jupyter`);
                 this.timeout(120_000);
-                jupyterConfig = workspace.getConfiguration('jupyter', undefined);
+                jupyterConfig = workspace.getConfiguration('deepnote', undefined);
                 previousJediSetting = jupyterConfig.get<boolean>('enableExtendedPythonKernelCompletions');
                 await jupyterConfig.update(
                     'enableExtendedPythonKernelCompletions',
diff --git a/src/test/datascience/widgets/standardWidgets.vscode.common.test.ts b/src/test/datascience/widgets/standardWidgets.vscode.common.test.ts
index 6ce283168b..d6e81975e9 100644
--- a/src/test/datascience/widgets/standardWidgets.vscode.common.test.ts
+++ b/src/test/datascience/widgets/standardWidgets.vscode.common.test.ts
@@ -116,7 +116,7 @@ suite('Standard IPyWidget Tests @widgets', function () {
         this.timeout(120_000);
         await initialize();
         logger.info('Suite Setup Standard IPyWidget Tests, Step 2');
-        const config = workspace.getConfiguration('jupyter', undefined);
+        const config = workspace.getConfiguration('deepnote', undefined);
         await config.update('widgetScriptSources', widgetScriptSourcesValue, ConfigurationTarget.Global);
         logger.info('Suite Setup Standard IPyWidget Tests, Step 3');
         await startJupyterServer();
diff --git a/src/test/datascience/widgets/thirdpartyWidgets.vscode.common.test.ts b/src/test/datascience/widgets/thirdpartyWidgets.vscode.common.test.ts
index 567cdf7937..2ef19fc214 100644
--- a/src/test/datascience/widgets/thirdpartyWidgets.vscode.common.test.ts
+++ b/src/test/datascience/widgets/thirdpartyWidgets.vscode.common.test.ts
@@ -55,7 +55,7 @@ import { IS_REMOTE_NATIVE_TEST } from '../../constants';
             logger.info('Suite Setup VS Code Notebook - Execution');
             this.timeout(120_000);
             api = await initialize();
-            const config = workspace.getConfiguration('jupyter', undefined);
+            const config = workspace.getConfiguration('deepnote', undefined);
             await config.update('widgetScriptSources', widgetScriptSourcesValue, ConfigurationTarget.Global);
             const configService = api.serviceContainer.get<IConfigurationService>(IConfigurationService);
             const settings = configService.getSettings(undefined) as ReadWrite<IJupyterSettings>;
diff --git a/src/test/web/clientApi.ts b/src/test/web/clientApi.ts
index a4e7894632..9cbfd6ac22 100644
--- a/src/test/web/clientApi.ts
+++ b/src/test/web/clientApi.ts
@@ -7,8 +7,10 @@ export class ClientAPI {
     static screenShotCount = new Map<string, number>();
     static url: string;
     public static initialize() {
-        console.log(`DEBUG_JUPYTER_SERVER_URI={workspace.getConfiguration('jupyter').get('DEBUG_JUPYTER_SERVER_URI')}`);
-        const reportServerPor = workspace.getConfiguration('jupyter').get('REPORT_SERVER_PORT') as number;
+        console.log(
+            `DEBUG_JUPYTER_SERVER_URI={workspace.getConfiguration('deepnote').get('DEBUG_JUPYTER_SERVER_URI')}`
+        );
+        const reportServerPor = workspace.getConfiguration('deepnote').get('REPORT_SERVER_PORT') as number;
 
         const url = `http://127.0.0.1:${reportServerPor}`;
         ClientAPI.url = url;

From a5a5aa0c0d40c44862c2325aa4e467193d16e8f2 Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 14:05:14 +0000
Subject: [PATCH 5/7] fix: Add forgotten file

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 src/platform/common/configuration/service.base.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/platform/common/configuration/service.base.ts b/src/platform/common/configuration/service.base.ts
index 9b17a6ea55..79f150ab53 100644
--- a/src/platform/common/configuration/service.base.ts
+++ b/src/platform/common/configuration/service.base.ts
@@ -24,7 +24,7 @@ export abstract class BaseConfigurationService implements IConfigurationService
             target: configTarget || ConfigurationTarget.WorkspaceFolder
         };
         let settingsInfo = defaultSetting;
-        if (section === 'jupyter' && configTarget !== ConfigurationTarget.Global) {
+        if (section === 'deepnote' && configTarget !== ConfigurationTarget.Global) {
             settingsInfo = JupyterSettings.getSettingsUriAndTarget(resource);
         }
         const configSection = workspace.getConfiguration(section, settingsInfo.uri);
@@ -50,7 +50,7 @@ export abstract class BaseConfigurationService implements IConfigurationService
         resource?: Uri,
         configTarget?: ConfigurationTarget
     ): Promise<void> {
-        return this.updateSectionSetting('jupyter', setting, value, resource, configTarget);
+        return this.updateSectionSetting('deepnote', setting, value, resource, configTarget);
     }
 
     private async verifySetting(

From 271d83b576286f5b4e6cfe527c5f91f588f0897c Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 14:16:29 +0000
Subject: [PATCH 6/7] Resolve nitpicks

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 src/platform/logging/index.ts | 2 +-
 src/test/web/clientApi.ts     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/platform/logging/index.ts b/src/platform/logging/index.ts
index 7253106e3b..0d703f607e 100644
--- a/src/platform/logging/index.ts
+++ b/src/platform/logging/index.ts
@@ -69,7 +69,7 @@ export function initializeLoggers(options: {
 
     if (options.addConsoleLogger) {
         // In CI there's no need for the label.
-        registerLogger(new ConsoleLogger(isCI ? undefined : 'Jupyter Extension:'));
+        registerLogger(new ConsoleLogger(isCI ? undefined : 'Deepnote Extension:'));
     }
 
     return standardOutputChannel;
diff --git a/src/test/web/clientApi.ts b/src/test/web/clientApi.ts
index 9cbfd6ac22..71120c223f 100644
--- a/src/test/web/clientApi.ts
+++ b/src/test/web/clientApi.ts
@@ -8,7 +8,7 @@ export class ClientAPI {
     static url: string;
     public static initialize() {
         console.log(
-            `DEBUG_JUPYTER_SERVER_URI={workspace.getConfiguration('deepnote').get('DEBUG_JUPYTER_SERVER_URI')}`
+            `DEBUG_JUPYTER_SERVER_URI=${workspace.getConfiguration('deepnote').get('DEBUG_JUPYTER_SERVER_URI')}`
         );
         const reportServerPor = workspace.getConfiguration('deepnote').get('REPORT_SERVER_PORT') as number;
 

From 1a1f1c2cc69755112c80c2f22d241db2cd41b099 Mon Sep 17 00:00:00 2001
From: Tomas Kislan <tomas@kislan.sk>
Date: Tue, 4 Nov 2025 14:36:43 +0000
Subject: [PATCH 7/7] Fix typo

Signed-off-by: Tomas Kislan <tomas@kislan.sk>
---
 src/test/web/clientApi.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/web/clientApi.ts b/src/test/web/clientApi.ts
index 71120c223f..b7abb44303 100644
--- a/src/test/web/clientApi.ts
+++ b/src/test/web/clientApi.ts
@@ -10,9 +10,9 @@ export class ClientAPI {
         console.log(
             `DEBUG_JUPYTER_SERVER_URI=${workspace.getConfiguration('deepnote').get('DEBUG_JUPYTER_SERVER_URI')}`
         );
-        const reportServerPor = workspace.getConfiguration('deepnote').get('REPORT_SERVER_PORT') as number;
+        const reportServerPort = workspace.getConfiguration('deepnote').get('REPORT_SERVER_PORT') as number;
 
-        const url = `http://127.0.0.1:${reportServerPor}`;
+        const url = `http://127.0.0.1:${reportServerPort}`;
         ClientAPI.url = url;
     }
     public static async sendRawMessage<T>(message: T): Promise<void> {