Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/kernels/deepnote/deepnoteServerStarter.node.ts`:
- Around line 405-414: Extract the duplicated disposal logic into a single
helper method named disposeOutputListeners(fileKey): it should look up
this.disposablesByFile.get(fileKey), iterate disposables, call dispose() inside
a try/catch, and log warnings on exceptions (same behavior as current block).
Replace the duplicated blocks in monitorServerOutput, stopServerForEnvironment,
and dispose() to call this.disposeOutputListeners(fileKey) and ensure the helper
handles the case of no entry and leaves map state consistent. Keep the helper as
a private method on the same class and reuse it everywhere the original disposal
loop appears.

In `@src/kernels/deepnote/deepnoteTestHelpers.node.ts`:
- Around line 15-66: Replace the hand-rolled mock object with one that extends
Node's EventEmitter and uses real emitter methods
(emit/on/once/removeListener/listeners/etc.) and mutable internal state exposed
via getters for properties like killed and connected; specifically update the
mock that currently defines killed, connected, signalCode, spawnargs, spawnfile
and methods kill, send, disconnect, unref, ref and all the listener stubs so the
mock class (or factory) wraps EventEmitter, maintains internal booleans (e.g.,
_killed, _connected) that are updated by kill/disconnect/ref/unref and exposed
as getters killed and connected, forward listener methods to the EventEmitter
instance (or inherit them) and remove the hardcoded stub implementations and the
Symbol.dispose no-op in favor of proper EventEmitter behavior.

In `@src/notebooks/deepnote/deepnoteActivationService.ts`:
- Around line 59-63: The current registration of
workspace.onDidOpenNotebookDocument only handles future opens and misses
notebooks already open at activation; after you push the
onDidOpenNotebookDocument listener (or inside activate where
extensionContext.subscriptions is set up), iterate over
workspace.notebookDocuments and call the existing checkAndSplitIfNeeded(doc) for
each open notebook to ensure restored/.deepnote notebooks are processed—use the
same method name checkAndSplitIfNeeded and keep adding the subscriptions onto
extensionContext.subscriptions as appropriate.

In `@src/notebooks/deepnote/deepnoteAutoSplitter.ts`:
- Around line 133-160: snapshotGlob currently matches both legacy and new
snapshot filename forms but extractVariantFromSnapshotFilename only understands
the legacy shape, causing filenames like
{slug}_{projectId}_{notebookId}_{variant}.snapshot.deepnote to be mis-parsed and
re-suffixed; before calling splitSingleSnapshot for each snapshotUri in
allSnapshotFiles, detect and skip files that already match the new format (or
extend extractVariantFromSnapshotFilename to parse the new pattern) by checking
the filename parts for the extra notebookId segment (use snapshotUri.fsPath or
basename), and only call splitSingleSnapshot when the file is in the legacy
shape; update the loop around splitSingleSnapshot (and the identical block at
the other occurrence) to perform this guard so valid new-format snapshots are
left untouched.
- Around line 46-49: The filename generation for extraNotebooks (inside the loop
using slugifyNotebookName, originalStem, and Uri.joinPath) can collide when
notebookSlug is identical; update the logic to produce collision-proof names by
including a unique identifier (e.g., notebook.id or an incrementing index/UUID)
or by checking for existing target paths and appending a disambiguator until the
path is unique before writing; apply the same fix to the similar block
referenced around lines 283-289 so newFileName/ newFileUri never overwrite
earlier notebooks.
- Around line 120-290: The private methods in this class are out of order;
reorder them to follow the repo TS file-order rule (grouped by accessibility
then alphabetically). Move the private methods so they appear in alphabetical
order: computeSnapshotHash, extractVariantFromSnapshotFilename, getFileStem,
slugifyNotebookName, splitSingleSnapshot, splitSnapshots (use these exact
function names to locate each method) and leave their implementations unchanged.

In `@src/notebooks/deepnote/deepnoteExplorerView.ts`:
- Around line 523-525: The tree item always opens the default notebook because
context.notebookId is ignored; fix the open logic in deepnoteExplorerView by
including context.notebookId when resolving the notebook (instead of just
Uri.file(context.filePath)). Pass the notebook identifier through to
workspace.openNotebookDocument (or construct a notebook URI using the
fragment/query) or call deserializeNotebook with the notebookId so the correct
notebook instance is opened; update the code paths around fileUri,
workspace.openNotebookDocument and deserializeNotebook to use
context.notebookId.
- Around line 79-80: The issue is that after creating or duplicating a notebook
the code appends the new notebook but reopens only the fileUri (e.g. via
saveProjectAndOpenNotebook(fileUri,...)), which lets
DeepnoteNotebookSerializer.findDefaultNotebook() pick the wrong notebook; modify
the create/duplicate flows to capture the new notebook's identifier (e.g. the
created/duplicated notebook object or its id/path) and pass that specific
notebook target into the reopen call (either by extending
saveProjectAndOpenNotebook to accept a notebookId/notebookUri parameter or by
calling whatever openNotebook/openEditor function exists with the precise
notebook target) so the editor opens the newly created/duplicated notebook
rather than the file's default. Ensure you update all affected call sites (the
create flow, duplicate flow and the other spots noted) to forward the new
notebook identifier.

In `@src/notebooks/deepnote/deepnoteExplorerView.unit.test.ts`:
- Around line 189-190: The test creates two DeepnoteExplorerView instances
(view1 and view2) which each construct a DeepnoteTreeDataProvider that registers
file watchers; to avoid leaking watchers, dispose of these views at the end of
the test (or add an afterEach/tearDown) by calling their dispose method (or
otherwise invoking the DeepnoteExplorerView cleanup) so both view1 and view2 are
properly torn down; locate usages of DeepnoteExplorerView in the test and ensure
view1.dispose() and view2.dispose() (or centralized cleanup) are invoked.

In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.unit.test.ts`:
- Around line 757-759: The test "should update outputs when snapshot file
changes" (and/or add a new unit test in deepnoteFileChangeWatcher.unit.test.ts)
currently only uses the legacy snapshot filename pattern produced by testFileUri
and createMockNotebook; update that test or add one to also exercise the new
per-notebook snapshot filename pattern produced by snapshotService (the
..._{projectId}_{notebookId}_{variant}.snapshot.deepnote shape) by calling
testFileUri with the new filename (including notebookId) and asserting the same
"happy-path/self-write" behavior so the watcher reacts as expected; reference
the existing test name and helpers (testFileUri, createMockNotebook) to locate
where to add the additional case.

In `@src/notebooks/deepnote/deepnoteNotebookManager.ts`:
- Around line 47-60: storeOriginalProject and updateOriginalProject both write
cloned DeepnoteProject objects into a single Map (originalProjects) keyed only
by projectId, causing different .deepnote files within the same project to
collide; change the cache to be per-file (either use a composite key like
`${projectId}:${fileId}` where fileId is the unique notebook/.deepnote filename
or switch originalProjects to a nested Map keyed first by projectId then by
fileId) and update both methods (storeOriginalProject, updateOriginalProject) to
use that per-file key, ensuring any other lookups that read originalProjects
also use the same composite or nested-key pattern so each notebook's cached
project is stored separately.

In `@src/notebooks/deepnote/deepnoteNotebookManager.unit.test.ts`:
- Around line 224-226: The inline comment above the test that says "Use
updateOriginalProject which doesn't set currentNotebookId" is stale; remove or
update that comment to reflect the new behavior being tested (e.g., that
updateOriginalProject is used and integrations should be updated and true
returned). Locate the comment near the test invoking
manager.updateOriginalProject('project-123', mockProject) and either delete the
sentence about currentNotebookId or replace it with a brief accurate description
of what the test now verifies.

In `@src/notebooks/deepnote/deepnoteTreeDataProvider.ts`:
- Around line 148-150: performInitialScan currently calls loadAllProjectFiles
and then the root render triggers getProjectGroups which repeats the same file
walk; to fix, capture the LoadedProjectFile[] result from loadAllProjectFiles in
performInitialScan (e.g. assign to a new class field like
this.loadedProjectFiles) and have getProjectGroups and any subsequent
group-building logic use that cached array instead of calling
loadAllProjectFiles again. Remove duplicate calls to loadAllProjectFiles found
around getProjectGroups, and add cache invalidation/update logic tied to file
system or workspace change handlers so the cached LoadedProjectFile[] stays in
sync.

In `@src/notebooks/deepnote/deepnoteTreeItem.ts`:
- Around line 78-79: The label construction uses
this.context.filePath.split('/') which fails on Windows; replace split('/')
usages with a platform-aware basename (e.g., import path from 'path' and call
path.basename(this.context.filePath)) when setting this.label and at the other
identical occurrence where filePath is parsed; ensure you fallback to
project.project.name || 'Untitled Project' exactly as before.

In `@src/test/mocks/vsc/extHostedTypes.ts`:
- Around line 2547-2554: The class TabInputNotebook declares two public readonly
properties out of alphabetical order; reorder the member declarations so public
readonly notebookType appears before public readonly uri to satisfy the repo
member-ordering rule, and keep the constructor (constructor(uri: vscUri.URI,
notebookType: string)) assignments consistent by assigning this.notebookType and
this.uri after reordering the property declarations.

---

Outside diff comments:
In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.ts`:
- Around line 270-286: enqueueSnapshotOutputUpdate currently filters by
notebookId but only stores projectId in the pending operation, causing
notebook-scoped snapshot lookups to be lost; update the pending operation stored
in pendingOperations (keyed by nbKey) to include notebookId (e.g., set { type:
'snapshot-output-update', projectId, notebookId }) and ensure any code that
reads this pending op (including drainQueue and the similar block referenced
around the second occurrence) uses the notebookId when performing snapshot
lookup/updates so notebook-scoped snapshot files update the correct editor.

In `@src/notebooks/deepnote/deepnoteTreeDataProvider.ts`:
- Around line 290-307: getNotebooksForProject currently returns all notebooks
including the project's init notebook (project.project.initNotebookId), which
causes the internal init notebook to appear as a normal child; modify
getNotebooksForProject to filter out any notebook whose id matches
project.project.initNotebookId before mapping to DeepnoteTreeItem (i.e., compute
notebooks.filter(n => n.id !== project.project.initNotebookId) and then map that
filtered list to new DeepnoteTreeItem instances using the existing context
construction and TreeItemCollapsibleState.None).

In `@src/notebooks/deepnote/deepnoteTreeDataProvider.unit.test.ts`:
- Around line 538-593: Rename the test case titles so they accurately describe
behavior being asserted: update the test with description "should sort notebooks
alphabetically by name within a project" (and the similar test around lines
595-650) to something like "should preserve original notebook order within a
project" or "should return notebooks in original order" so the test name matches
the assertions in DeepnoteTreeDataProvider unit tests that call
provider.getChildren and verify the original order of notebook items; update
only the test description strings for the test(...) calls (e.g., the one
constructing mockProjectWithNotebooks and mockProjectItem) to avoid misleading
readers.

In `@src/notebooks/deepnote/snapshots/snapshotService.ts`:
- Around line 401-445: readSnapshot currently loses backward compatibility when
notebookId is provided because latestGlob and timestampedGlob only match
filenames containing _{projectId}_{notebookId}_..., skipping legacy files named
*_{{projectId}}_...; update readSnapshot to try both notebook-scoped and legacy
patterns when notebookId is present by constructing an additional legacy glob
(e.g., `**/snapshots/*_${projectId}_...`) and searching with both patterns
inside the existing workspace.findFiles loop(s), falling back to the legacy
match if no notebook-scoped file is found; ensure the same dual-pattern logic is
applied for both the "latest" search (latestGlob) and the timestamped search
(timestampedGlob) before calling parseSnapshotFile so parseSnapshotFile,
RelativePattern, and workspace.findFiles are reused without changing their APIs.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.ts`:
- Around line 398-406: The save failure handling is inconsistent: when
workspace.save(notebook.uri) returns undefined the function returns, but when it
throws the catch only logs and execution continues to the success path; update
the catch for workspace.save(notebook.uri) to mirror the undefined case (i.e.,
after logging the saveError via logger.warn include an early return or rethrow)
so both failure modes prevent reaching the subsequent success log; locate this
in deepnoteFileChangeWatcher.ts around the workspace.save(...) call and the
surrounding try/catch that references notebook.uri and logger.warn.

In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.unit.test.ts`:
- Around line 131-143: The suite currently creates a temp dir with mkdtempSync
in suiteSetup and removes it in suiteTeardown, but if the test process crashes
the cleanup can be skipped; add a fail-safe removal by registering a process
exit handler that checks testFixturesDir and calls rmSync(testFixturesDir, {
recursive: true, force: true }) (and also handle SIGINT/SIGTERM) so the temp
folder is removed on abrupt termination; ensure testFixturesDir is assigned
before registering the handler and keep the existing suiteTeardown removal in
place, and reference the testFixturesDir variable and the
suiteSetup/suiteTeardown functions when making the change.

---

Outside diff comments:
In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.ts`:
- Around line 120-139: The onFileWritten handler populates snapshotSelfWriteUris
and snapshotSelfWriteTimers using uri.toString(), but consumeSelfWrite looks up
keys via normalizeFileUri(uri), causing mismatches when URIs have
queries/fragments; update the onFileWritten callback in
deepnoteFileChangeWatcher.ts to compute the key with normalizeFileUri(uri) (use
the same normalization for both the Set snapshotSelfWriteUris and the Map
snapshotSelfWriteTimers and for clearing timers) so stored keys match
consumeSelfWrite's lookup and timers are tracked/cleared consistently.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/kernels/deepnote/deepnoteServerStarter.node.ts`:
- Around line 446-462: The private method disposeOutputListeners is placed
immediately before the public dispose method, violating the rule to order class
members first by accessibility then alphabetically; move disposeOutputListeners
so that all public members (including dispose) appear before private members, or
otherwise reorder members so that public dispose() comes before private
disposeOutputListeners and ensure disposablesByFile usage remains correct;
update the class member sequence so accessibility groups (public then private)
and alphabetical ordering within each group are respected for dispose() and
disposeOutputListeners.

In `@src/notebooks/deepnote/deepnoteNotebookManager.ts`:
- Around line 35-43: The current logic in the notebook lookup returns the first
entry from notebookMap even when a caller requested a specific notebookId and it
wasn't found, which can return the wrong notebook; change the behavior in the
function handling notebook lookups (the block referencing notebookId and
notebookMap) so that when notebookId is provided and notebookMap.get(notebookId)
returns undefined you return undefined immediately, and only use the
notebookMap.values().next().value fallback when notebookId was not provided
(i.e., the caller intentionally omitted it).

In `@src/notebooks/deepnote/deepnoteNotebookManager.unit.test.ts`:
- Around line 35-40: The tests store using
manager.storeOriginalProject('project-123', 'notebook-1', mockProject') but read
back with manager.getOriginalProject('project-123'), which doesn't verify
notebook-aware behavior; update the assertions in the new cache-contract tests
so they call manager.getOriginalProject('project-123', 'notebook-1') to read
with the same notebookId (do the same for the second case at the other test
block), and keep one separate test that asserts the fallback behavior using
getOriginalProject('project-123') only once.

In `@src/notebooks/deepnote/deepnoteTreeItem.ts`:
- Around line 53-58: The ProjectGroup/ProjectFile visual-field formatting logic
is duplicated between the DeepnoteTreeItem constructor and updateVisualFields();
extract shared helpers (e.g., formatProjectGroupVisuals(projectGroupData) and
formatProjectFileVisuals(projectFileData)) that return label, tooltip,
description, and icon info, and call those helpers from both the constructor and
updateVisualFields(); update usages for DeepnoteTreeItemType.ProjectGroup and
DeepnoteTreeItemType.ProjectFile so the rendering rules live in one place and
both code paths consume the same helper functions.

In `@src/notebooks/deepnote/snapshots/snapshotService.ts`:
- Around line 773-779: The code currently calls findProjectUriFromId(projectId)
which can return a sibling file's URI; instead derive the snapshot location from
the current notebook's URI (the `notebook` variable) so snapshots are written
for the correct file. Replace the findProjectUriFromId(projectId) call with
logic that uses `notebook.uri` (or a helper like
findProjectUriFromUri(notebook.uri) if available) as the source of truth for
`projectUri`, keep the same early-return and logger.warn behavior but reference
the notebook URI in the warning.
- Around line 415-418: The notebook-scoped glob construction (latestGlob)
currently omits legacy project-scoped snapshots when notebookId is present;
change the logic in snapshotService.ts so that when notebookId is provided you
first build the notebook-scoped pattern
(`*_{projectId}_{notebookId}_latest.snapshot.deepnote`) and if that yields no
results fall back to the legacy project-scoped pattern
(`*_{projectId}_latest.snapshot.deepnote`); apply the same change to the other
similar block around the code referenced at 443-445 so both the "latest" and the
other snapshot-glob checks try the notebook-scoped pattern first and then
fallback to the legacy project-scoped pattern when no matches are found.

---

Duplicate comments:
In `@src/notebooks/deepnote/deepnoteExplorerView.ts`:
- Around line 77-85: The current flow appends newNotebook to
projectData.project.notebooks then calls saveProjectAndOpenNotebook(fileUri),
which reopens the .deepnote file and usually selects the default notebook
instead of the newly created one; fix by carrying the target notebook through
the reopen path: change saveProjectAndOpenNotebook to accept an
identifier/ordinal for the notebook (e.g., newNotebook.id or the newNotebook
object) and use that to select/open the specific notebook after deserialization,
then update this call site to pass newNotebook (or newNotebook.id) instead of
only fileUri; alternatively, if you prefer per-notebook files, create a new
.deepnote file for newNotebook instead of appending to
projectData.project.notebooks and open that new file—adjust
saveProjectAndOpenNotebook and its callers accordingly (symbols:
projectData.project.notebooks, newNotebook, saveProjectAndOpenNotebook,
fileUri).
- Around line 253-271: The code writes the updated file but reopens using
fileUri, which opens the default notebook instead of the duplicated one; update
the reopen step to open the specific notebook entry for newNotebook by
constructing a notebook-specific URI (e.g., derive a fragment/identifier from
newNotebook.id or its index in projectData.project.notebooks) and pass that URI
to workspace.openNotebookDocument and window.showNotebookDocument so the
duplicated notebook (newNotebook) is opened rather than the file's default
notebook.

In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.ts`:
- Around line 398-406: The catch for the workspace.save(notebook.uri) call
currently only logs the error (logger.warn) and then execution falls through to
the success log; update the catch to stop further processing by returning (or
otherwise exiting) after logging the saveError so the code does not incorrectly
log a successful save for notebook.uri.path. Ensure you modify the catch block
that wraps workspace.save(notebook.uri) (the logger.warn call that references
notebook.uri.path and saveError) to return immediately after logging.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.unit.test.ts`:
- Around line 295-296: Replace scattered per-test numeric timeouts (e.g., 8000,
10000, 12000, 15000, 20000) with named constants declared near the top of the
module and reuse them in each test's this.timeout(...) call; specifically add
constants like TEST_TIMEOUT_SHORT, TEST_TIMEOUT_MEDIUM, TEST_TIMEOUT_LONG (or
similar) and update the tests referenced by their unique names such as the
"saving a non-deepnote notebook should not suppress FS change events" test and
the other tests noted in the comment so that each this.timeout(...) uses the
appropriate named constant instead of a literal; keep constants alongside the
existing timing constants block for easy CI tuning.
- Around line 1618-1630: The test is falsely passing because a suite-level
one-arg stub for mockSnapshotService.readSnapshot still exists; call
reset(mockSnapshotService) (not resetCalls) before re-stubbing so previous stubs
are removed, then stub readSnapshot explicitly with two args via
when(mockSnapshotService.readSnapshot(anything(), anything())).thenCall(...) and
increment/read readSnapshotCallCount as done, and finally verify the exact call
happened with verify(mockSnapshotService.readSnapshot('project-1',
scopedNotebookId)).once(); apply the same reset+explicit two-arg stubbing and
exact-args verification for the other occurrence around the 1655–1660 region.

---

Outside diff comments:
In `@src/notebooks/deepnote/deepnoteFileChangeWatcher.unit.test.ts`:
- Around line 787-799: The test incorrectly reuses the existing snapshot event
stream so noSnapshotWatcher isn't isolated; create a separate mocked
FileSystemWatcher and event emitter for the new DeepnoteFileChangeWatcher
instance (noSnapshotWatcher) instead of reusing snapshotOnDidChange or
snapshotWatcher, wire that mock into noSnapshotWatcher during
construction/activation, fire the new watcher’s change event (the new event
emitter) and then await debounceWaitMs, and finally assert readSnapshotCallCount
and any applySnapshot counts remain unchanged to prove the new watcher ignored
snapshot events; ensure workspace.notebookDocuments is still mocked to [] when
firing the new event.