nebula-notebook 0.1.1 → 0.2.1

package/node-server/dist/kernel/kernelspec.d.ts

@@ -10,6 +10,16 @@ export type { KernelSpec } from './types';
  * Standard kernelspec search paths
  */
 export declare function getKernelSearchPaths(): string[];
+/**
+ * Read kernelspecs from a list of `…/kernels` directories. `seen` dedupes by
+ * kernel name across calls (first path wins — Jupyter precedence order).
+ */
+export declare function readKernelSpecsFromPaths(searchPaths: string[], options?: {
+    skipDefaultPythonSpecs?: boolean;
+    seen?: Set<string>;
+}): KernelSpec[];
+/** The `share/jupyter/kernels` dir belonging to each interpreter's prefix. */
+export declare function envKernelspecDirs(envPythonPaths: string[]): string[];
 /**
  * Discover all available kernelspecs on the system
  * Uses 60-second in-memory cache to avoid repeated disk I/O
@@ -23,6 +33,23 @@ export declare function invalidateKernelspecCache(): void;
  * Get a specific kernelspec by name
  */
 export declare function getKernelSpec(name: string): KernelSpec | null;
+/**
+ * Env kernels (VSCode-style raw launch): any Python environment can be used
+ * as a kernel WITHOUT registering a kernelspec on disk. The kernel name
+ * `env:<pythonPath>` resolves to a synthetic in-memory spec that launches
+ * `<python> -m ipykernel_launcher` directly — only ipykernel needs to be
+ * importable in the environment; jupyter itself is never required.
+ */
+export declare const ENV_KERNEL_PREFIX = "env:";
+export declare function isEnvKernelName(name: string): boolean;
+/** The interpreter path encoded in an env: kernel name, or null. */
+export declare function envKernelPythonPath(name: string): string | null;
+export declare function makeEnvKernelSpec(pythonPath: string, displayName?: string): KernelSpec;
+/**
+ * Resolve a kernel name to a spec: env: names produce a synthetic raw-launch
+ * spec, anything else falls back to registered kernelspecs on disk.
+ */
+export declare function resolveKernelSpec(name: string, displayName?: string): KernelSpec | null;
 /**
  * Check if a kernelspec exists
  */

package/node-server/dist/kernel/kernelspec.js

@@ -39,14 +39,23 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_KERNEL_PREFIX = void 0;
 exports.getKernelSearchPaths = getKernelSearchPaths;
+exports.readKernelSpecsFromPaths = readKernelSpecsFromPaths;
+exports.envKernelspecDirs = envKernelspecDirs;
 exports.discoverKernelSpecs = discoverKernelSpecs;
 exports.invalidateKernelspecCache = invalidateKernelspecCache;
 exports.getKernelSpec = getKernelSpec;
+exports.isEnvKernelName = isEnvKernelName;
+exports.envKernelPythonPath = envKernelPythonPath;
+exports.makeEnvKernelSpec = makeEnvKernelSpec;
+exports.resolveKernelSpec = resolveKernelSpec;
 exports.hasKernelSpec = hasKernelSpec;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const discovery_service_1 = require("../discovery/discovery-service");
+const conda_locations_1 = require("../discovery/conda-locations");
 // In-memory cache for kernelspecs (avoids repeated disk I/O)
 let kernelspecCache = null;
 let kernelspecCacheTime = 0;
@@ -139,12 +148,19 @@ function readKernelSpec(kernelDir) {
     }
 }
 /**
- * Perform actual kernelspec discovery (disk I/O)
+ * Auto-registered default python specs (`python3`, `python3.11`, …) inside an
+ * environment duplicate what the env row in the picker already offers ("run
+ * Python here") — showing N identical "Python 3 (ipykernel)" entries would
+ * drown the real kernels. VSCode hides these the same way.
  */
-function performKernelspecDiscovery() {
+const DEFAULT_PYTHON_SPEC_RE = /^python\d*(\.\d+)*$/i;
+/**
+ * Read kernelspecs from a list of `…/kernels` directories. `seen` dedupes by
+ * kernel name across calls (first path wins — Jupyter precedence order).
+ */
+function readKernelSpecsFromPaths(searchPaths, options = {}) {
     const specs = [];
-    const seenNames = new Set();
-    const searchPaths = getKernelSearchPaths();
+    const seenNames = options.seen ?? new Set();
     for (const searchPath of searchPaths) {
         if (!fs.existsSync(searchPath)) {
             continue;
@@ -159,6 +175,9 @@ function performKernelspecDiscovery() {
                 if (seenNames.has(kernelName)) {
                     continue;
                 }
+                if (options.skipDefaultPythonSpecs && DEFAULT_PYTHON_SPEC_RE.test(kernelName)) {
+                    continue;
+                }
                 const kernelDir = path.join(searchPath, kernelName);
                 const spec = readKernelSpec(kernelDir);
                 if (spec) {
@@ -173,6 +192,24 @@ function performKernelspecDiscovery() {
     }
     return specs;
 }
+/** The `share/jupyter/kernels` dir belonging to each interpreter's prefix. */
+function envKernelspecDirs(envPythonPaths) {
+    const dirs = envPythonPaths.map(p => path.join((0, conda_locations_1.prefixForPythonExe)(p), 'share', 'jupyter', 'kernels'));
+    return [...new Set(dirs)];
+}
+/**
+ * Perform actual kernelspec discovery (disk I/O): the standard Jupyter search
+ * paths first, then every discovered Python environment's own
+ * share/jupyter/kernels (how conda-installed kernels like R/Julia surface) —
+ * with each env's redundant default python spec hidden.
+ */
+function performKernelspecDiscovery() {
+    const seen = new Set();
+    const specs = readKernelSpecsFromPaths(getKernelSearchPaths(), { seen });
+    const envPaths = Object.keys(discovery_service_1.pythonDiscovery.getFromCache() ?? {});
+    specs.push(...readKernelSpecsFromPaths(envKernelspecDirs(envPaths), { seen, skipDefaultPythonSpecs: true }));
+    return specs;
+}
 /**
  * Discover all available kernelspecs on the system
  * Uses 60-second in-memory cache to avoid repeated disk I/O
@@ -202,6 +239,40 @@ function getKernelSpec(name) {
     const specs = discoverKernelSpecs();
     return specs.find(s => s.name === name) || null;
 }
+/**
+ * Env kernels (VSCode-style raw launch): any Python environment can be used
+ * as a kernel WITHOUT registering a kernelspec on disk. The kernel name
+ * `env:<pythonPath>` resolves to a synthetic in-memory spec that launches
+ * `<python> -m ipykernel_launcher` directly — only ipykernel needs to be
+ * importable in the environment; jupyter itself is never required.
+ */
+exports.ENV_KERNEL_PREFIX = 'env:';
+function isEnvKernelName(name) {
+    return name.startsWith(exports.ENV_KERNEL_PREFIX);
+}
+/** The interpreter path encoded in an env: kernel name, or null. */
+function envKernelPythonPath(name) {
+    return isEnvKernelName(name) ? name.slice(exports.ENV_KERNEL_PREFIX.length) : null;
+}
+function makeEnvKernelSpec(pythonPath, displayName) {
+    return {
+        name: exports.ENV_KERNEL_PREFIX + pythonPath,
+        displayName: displayName || `Python (${pythonPath})`,
+        language: 'python',
+        path: '', // synthetic — no kernelspec directory on disk
+        argv: [pythonPath, '-m', 'ipykernel_launcher', '-f', '{connection_file}'],
+    };
+}
+/**
+ * Resolve a kernel name to a spec: env: names produce a synthetic raw-launch
+ * spec, anything else falls back to registered kernelspecs on disk.
+ */
+function resolveKernelSpec(name, displayName) {
+    const pythonPath = envKernelPythonPath(name);
+    if (pythonPath)
+        return makeEnvKernelSpec(pythonPath, displayName);
+    return getKernelSpec(name);
+}
 /**
  * Check if a kernelspec exists
  */

package/node-server/dist/notebook/headless-handler.d.ts

@@ -45,6 +45,16 @@ export declare class HeadlessOperationHandler {
      * Get notebook from cache, loading from disk if needed.
      */
     private getCachedNotebook;
+    /** In-flight cache warm-ups per notebook path (single-flight). */
+    private warming;
+    /**
+     * Warm the notebook + undo-history caches with non-blocking I/O. The sync
+     * fallback in getCachedNotebook blocks the event loop on a cache miss — on
+     * a network filesystem a large notebook + history read stalls every
+     * in-flight request (kernel completions included) for seconds. Entry points
+     * await this first so the sync accessors below are pure in-memory hits.
+     */
+    private ensureCached;
     private getCells;
     private getVisibleOutputs;
     private saveCells;
@@ -52,6 +62,8 @@ export declare class HeadlessOperationHandler {
      * Persist dirty notebooks to disk.
      */
     flush(notebookPath?: string): Promise<void>;
+    /** In-flight persist per notebook path (single-flight). */
+    private persisting;
     private asyncPersist;
     private schedulePersist;
     /**

package/node-server/dist/notebook/headless-handler.js

@@ -43,8 +43,9 @@ exports.HeadlessOperationHandler = void 0;
 const fs = __importStar(require("fs"));
 const cell_hash_1 = require("./cell-hash");
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const private_tmp_1 = require("../private-tmp");
 const uuid_1 = require("uuid");
+const registry_1 = require("../fs/notebook-formats/registry");
 const cell_metadata_1 = require("./cell-metadata");
 const undoRedoManager_1 = require("./undoRedoManager");
 const kernelspec_1 = require("../kernel/kernelspec");
@@ -80,7 +81,7 @@ class HeadlessOperationHandler {
      */
     getCachedNotebook(notebookPath) {
         if (!this.cache.has(notebookPath)) {
-            const result = this.fsService.getNotebookCells(notebookPath);
+            const result = this.fsService.getNotebookCellsSync(notebookPath);
             this.cache.set(notebookPath, {
                 cells: result.cells || [],
                 metadata: result.metadata || {},
@@ -89,6 +90,37 @@ class HeadlessOperationHandler {
         }
         return this.cache.get(notebookPath);
     }
+    /** In-flight cache warm-ups per notebook path (single-flight). */
+    warming = new Map();
+    /**
+     * Warm the notebook + undo-history caches with non-blocking I/O. The sync
+     * fallback in getCachedNotebook blocks the event loop on a cache miss — on
+     * a network filesystem a large notebook + history read stalls every
+     * in-flight request (kernel completions included) for seconds. Entry points
+     * await this first so the sync accessors below are pure in-memory hits.
+     */
+    ensureCached(notebookPath) {
+        if (!notebookPath || this.cache.has(notebookPath))
+            return Promise.resolve();
+        const inflight = this.warming.get(notebookPath);
+        if (inflight)
+            return inflight;
+        const run = (async () => {
+            const result = await this.fsService.getNotebookCells(notebookPath);
+            if (!this.cache.has(notebookPath)) {
+                this.cache.set(notebookPath, {
+                    cells: result.cells || [],
+                    metadata: result.metadata || {},
+                    dirty: false,
+                });
+            }
+            await this.undoRedoManager.warm(notebookPath, this.cache.get(notebookPath).cells);
+        })().finally(() => {
+            this.warming.delete(notebookPath);
+        });
+        this.warming.set(notebookPath, run);
+        return run;
+    }
     getCells(notebookPath) {
         return this.getCachedNotebook(notebookPath).cells;
     }
@@ -109,23 +141,41 @@ class HeadlessOperationHandler {
     async flush(notebookPath) {
         const paths = notebookPath ? [notebookPath] : Array.from(this.cache.keys());
         for (const p of paths) {
-            const notebook = this.cache.get(p);
-            if (notebook?.dirty) {
+            // A scheduled persist may have already cleared the dirty flag but not
+            // finished writing — flush must wait for it, or callers read a stale
+            // file. The persist loop keeps writing while dirty, so awaiting the
+            // in-flight run covers later mutations too.
+            const inFlight = this.persisting.get(p);
+            if (inFlight) {
+                await inFlight;
+            }
+            if (this.cache.get(p)?.dirty) {
                 await this.asyncPersist(p);
             }
         }
     }
-    async asyncPersist(notebookPath) {
-        const notebook = this.cache.get(notebookPath);
-        if (!notebook)
-            return;
-        // Keep writing while dirty
-        while (notebook.dirty) {
-            const cells = JSON.parse(JSON.stringify(notebook.cells));
-            notebook.dirty = false;
-            const history = this.undoRedoManager.getHistory(notebookPath, cells);
-            await this.fsService.saveNotebookBundle(notebookPath, cells, undefined, history);
-        }
+    /** In-flight persist per notebook path (single-flight). */
+    persisting = new Map();
+    asyncPersist(notebookPath) {
+        const existing = this.persisting.get(notebookPath);
+        if (existing)
+            return existing;
+        const run = (async () => {
+            const notebook = this.cache.get(notebookPath);
+            if (!notebook)
+                return;
+            // Keep writing while dirty
+            while (notebook.dirty) {
+                const cells = JSON.parse(JSON.stringify(notebook.cells));
+                notebook.dirty = false;
+                const history = this.undoRedoManager.getHistory(notebookPath, cells);
+                await this.fsService.saveNotebookBundle(notebookPath, cells, undefined, history);
+            }
+        })().finally(() => {
+            this.persisting.delete(notebookPath);
+        });
+        this.persisting.set(notebookPath, run);
+        return run;
     }
     schedulePersist(notebookPath) {
         // Schedule async persist
@@ -143,6 +193,10 @@ class HeadlessOperationHandler {
         else {
             this.cache.clear();
         }
+        // Undo/redo state is derived from the persisted history file; when the
+        // notebook may have changed underneath us (UI save, external edit
+        // reconciliation), rebuild it from disk on next access.
+        this.undoRedoManager.clearState(notebookPath);
     }
     /**
      * Check if notebook has unsaved changes.
@@ -153,23 +207,24 @@ class HeadlessOperationHandler {
     /**
      * Check if agent has permission to modify this notebook.
      */
-    checkAgentPermission(notebookPath, _operationType) {
-        const status = this.fsService.getAgentPermissionStatus(notebookPath);
-        if (status.agent_created) {
+    async checkAgentPermission(notebookPath, _operationType) {
+        const status = await this.fsService.getAgentPermissionStatusAsync(notebookPath);
+        // can_agent_modify already encodes the tri-state rule (agent-created notebooks
+        // are permitted unless explicitly revoked; user notebooks need permission +
+        // history), so an explicit user revoke wins even for agent-created notebooks.
+        if (status.can_agent_modify) {
             return null;
         }
-        if (status.agent_permitted) {
-            if (!status.has_history) {
-                return {
-                    success: false,
-                    error: `Agent cannot modify "${notebookPath}": notebook is user-permitted but history is not enabled. Open the notebook in the UI first to enable history tracking, or the agent can create a new notebook.`,
-                };
-            }
-            return null;
+        // User-permitted but history not yet enabled (soft, fixable) vs. not permitted.
+        if (status.agent_permitted && !status.has_history && !status.agent_created) {
+            return {
+                success: false,
+                error: `Agent cannot modify "${notebookPath}": notebook is user-permitted but history is not enabled. Open the notebook in the UI first to enable history tracking, or the agent can create a new notebook.`,
+            };
         }
         return {
             success: false,
-            error: `Agent cannot modify "${notebookPath}": notebook is not agent-permitted. Either open the notebook in Nebula UI and grant agent permission, or the agent can create a new notebook which will be automatically permitted.`,
+            error: `Agent cannot modify "${notebookPath}": notebook is not agent-permitted (agent access may have been revoked). Either open the notebook in Nebula UI and grant agent permission, or the agent can create a new notebook which will be automatically permitted.`,
         };
     }
     /**
@@ -228,9 +283,20 @@ class HeadlessOperationHandler {
         // Read-only operations
         const readOnlyOps = new Set(['readCell', 'readCellOutput', 'searchCells', 'getUpdatesSince', 'startAgentSession', 'endAgentSession']);
         const permissionExemptOps = new Set(['createNotebook', 'readCell', 'readCellOutput', 'searchCells', 'getUpdatesSince', 'startAgentSession', 'endAgentSession']);
+        // Warm the notebook/history caches without blocking the event loop before
+        // any sync accessor below runs. createNotebook targets a file that may
+        // not exist yet; a failed warm defers to the operation's own error.
+        if (notebookPath && opType !== 'createNotebook') {
+            try {
+                await this.ensureCached(notebookPath);
+            }
+            catch {
+                // Operation handlers report missing/corrupt notebooks themselves
+            }
+        }
         // Check permission for write operations
         if (!permissionExemptOps.has(opType) && notebookPath) {
-            const permissionError = this.checkAgentPermission(notebookPath, opType);
+            const permissionError = await this.checkAgentPermission(notebookPath, opType);
             if (permissionError) {
                 return permissionError;
             }
@@ -361,6 +427,14 @@ class HeadlessOperationHandler {
      */
     async readNotebook(notebookPath, includeOutputs = true, maxLines, maxChars, maxLinesError, maxCharsError) {
         try {
+            // Non-blocking cache warm-up; on failure the sync accessor below
+            // produces the proper error (e.g. notebook not found).
+            try {
+                await this.ensureCached(notebookPath);
+            }
+            catch {
+                // fall through to getCachedNotebook's own error handling
+            }
             const notebook = this.getCachedNotebook(notebookPath);
             let cells = notebook.cells;
             if (includeOutputs) {
@@ -781,6 +855,28 @@ class HeadlessOperationHandler {
                 error: `Notebook already exists: ${notebookPath}. Use overwrite=true to replace.`,
             };
         }
+        // Text notebook formats (.py percent / .qmd): create through the format
+        // adapter — agent flags live in the file's own metadata like .ipynb.
+        const formatAdapter = (0, registry_1.getFormatAdapter)(normalizedPath);
+        if (formatAdapter) {
+            const dir = path.dirname(normalizedPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const metadata = {
+                kernelspec: { name: kernelName, display_name: kernelDisplayName },
+                nebula: { agent_created: true, agent_permitted: true },
+            };
+            if (formatAdapter.name === 'qmd')
+                metadata.__qmd_language = 'python';
+            fs.writeFileSync(normalizedPath, formatAdapter.serialize([], metadata), 'utf-8');
+            this.invalidate(notebookPath);
+            return {
+                success: true,
+                path: notebookPath,
+                mtime: fs.statSync(normalizedPath).mtimeMs / 1000,
+            };
+        }
         const notebook = {
             nbformat: 4,
             nbformat_minor: 5,
@@ -988,7 +1084,7 @@ class HeadlessOperationHandler {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
     saveOutputToTempFile(content, cellId) {
-        const tempDir = path.join(os.tmpdir(), 'nebula', 'outputs');
+        const tempDir = (0, private_tmp_1.privateTmpDir)('outputs');
         if (!fs.existsSync(tempDir)) {
             fs.mkdirSync(tempDir, { recursive: true });
         }

package/node-server/dist/notebook/operation-router.js

@@ -48,6 +48,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const ws_1 = require("ws");
 const cell_hash_1 = require("./cell-hash");
+const registry_1 = require("../fs/notebook-formats/registry");
 const AGENT_LOCK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const UI_STALE_TIMEOUT_MS = 45 * 1000; // 45 seconds
 function normalizeNotebookPath(notebookPath) {
@@ -320,9 +321,13 @@ class OperationRouter {
         const opType = operation.type;
         const agentId = operation.agentId;
         // For createNotebook, route to ANY connected UI (not path-specific)
-        // This allows the UI to open the new notebook in a new tab
+        // This allows the UI to open the new notebook in a new tab.
+        // EXCEPT text notebook formats (.py/.qmd): the UI's create handler only
+        // builds Jupyter JSON, so those are always created headless through the
+        // format adapters.
         const isCreateNotebook = opType === 'createNotebook';
-        const anyUI = isCreateNotebook ? this.getAnyUIConnection() : null;
+        const isTextFormatCreate = isCreateNotebook && (0, registry_1.isTextNotebookPath)(operation.notebookPath || '');
+        const anyUI = isCreateNotebook && !isTextFormatCreate ? this.getAnyUIConnection() : null;
         const hasUI = isCreateNotebook ? (anyUI !== null) : (this.getResponsiveUIConnection(normalizedPath) !== null);
         const backend = hasUI ? 'ui' : 'headless';
         // Clean up expired locks

package/node-server/dist/notebook/undoRedoManager.d.ts

@@ -139,6 +139,14 @@ export declare class HeadlessUndoRedoManager {
      * Get or initialize undo state for a notebook.
      */
     getState(notebookPath: string, cells: NebulaCell[]): NotebookUndoState;
+    /**
+     * Preload a notebook's history without blocking the event loop. After this
+     * resolves, getState is a pure in-memory hit — its loadHistorySync fallback
+     * (a large journal read that stalls every in-flight request on a network
+     * filesystem) never fires. No-op if state already exists.
+     */
+    warm(notebookPath: string, cells: NebulaCell[]): Promise<void>;
+    private initState;
     /**
      * Rebuild undo stack from history.
      */
@@ -182,7 +190,10 @@ export declare class HeadlessUndoRedoManager {
     /**
      * Clear state for a notebook (e.g., when closing).
      */
-    clearState(notebookPath: string): void;
+    /** Drop in-memory state so the next access rebuilds from the persisted
+     *  history file (the file/history may have changed underneath us: UI save,
+     *  external-edit reconciliation). Omit the path to clear all. */
+    clearState(notebookPath?: string): void;
     /**
      * Get updates since a timestamp (for agent awareness).
      * Returns human-readable summaries of operations made between agent sessions.

package/node-server/dist/notebook/undoRedoManager.js

@@ -142,30 +142,53 @@ class HeadlessUndoRedoManager {
             // Try to load existing history
             let loadedHistory = [];
             try {
-                loadedHistory = this.fsService.loadHistory(notebookPath);
+                loadedHistory = this.fsService.loadHistorySync(notebookPath);
             }
             catch (err) {
                 console.warn(`[UndoRedoManager] Failed to load history for ${notebookPath}:`, err);
             }
-            // Initialize state
-            const state = {
-                undoStack: [],
-                redoStack: [],
-                fullHistory: loadedHistory.length > 0 ? loadedHistory : [{
-                        type: 'snapshot',
-                        cells: cells.map(stripCellOutputs),
-                        timestamp: Date.now()
-                    }],
-                lastContent: new Map(cells.map(c => [c.id, c.content]))
-            };
-            // Rebuild undo stack from history
-            if (loadedHistory.length > 0) {
-                state.undoStack = this.rebuildUndoStack(loadedHistory);
-            }
-            this.states.set(notebookPath, state);
+            this.initState(notebookPath, cells, loadedHistory);
         }
         return this.states.get(notebookPath);
     }
+    /**
+     * Preload a notebook's history without blocking the event loop. After this
+     * resolves, getState is a pure in-memory hit — its loadHistorySync fallback
+     * (a large journal read that stalls every in-flight request on a network
+     * filesystem) never fires. No-op if state already exists.
+     */
+    async warm(notebookPath, cells) {
+        if (this.states.has(notebookPath))
+            return;
+        let loadedHistory = [];
+        try {
+            loadedHistory = (await this.fsService.loadHistory(notebookPath));
+        }
+        catch (err) {
+            console.warn(`[UndoRedoManager] Failed to load history for ${notebookPath}:`, err);
+        }
+        // A concurrent sync getState may have initialized while we awaited
+        if (this.states.has(notebookPath))
+            return;
+        this.initState(notebookPath, cells, loadedHistory);
+    }
+    initState(notebookPath, cells, loadedHistory) {
+        const state = {
+            undoStack: [],
+            redoStack: [],
+            fullHistory: loadedHistory.length > 0 ? loadedHistory : [{
+                    type: 'snapshot',
+                    cells: cells.map(stripCellOutputs),
+                    timestamp: Date.now()
+                }],
+            lastContent: new Map(cells.map(c => [c.id, c.content]))
+        };
+        // Rebuild undo stack from history
+        if (loadedHistory.length > 0) {
+            state.undoStack = this.rebuildUndoStack(loadedHistory);
+        }
+        this.states.set(notebookPath, state);
+    }
     /**
      * Rebuild undo stack from history.
      */
@@ -357,8 +380,16 @@ class HeadlessUndoRedoManager {
     /**
      * Clear state for a notebook (e.g., when closing).
      */
+    /** Drop in-memory state so the next access rebuilds from the persisted
+     *  history file (the file/history may have changed underneath us: UI save,
+     *  external-edit reconciliation). Omit the path to clear all. */
     clearState(notebookPath) {
-        this.states.delete(notebookPath);
+        if (notebookPath) {
+            this.states.delete(notebookPath);
+        }
+        else {
+            this.states.clear();
+        }
     }
     /**
      * Get updates since a timestamp (for agent awareness).

package/node-server/dist/output/display-data.js

@@ -8,6 +8,8 @@ exports.buildDisplayOutput = buildDisplayOutput;
 exports.convertMimeBundleToJupyter = convertMimeBundleToJupyter;
 const PREFERRED_MIME_TYPES = [
     'application/vnd.nebula.web+json',
+    // Widget views must win over plotly/html when both are present
+    'application/vnd.jupyter.widget-view+json',
     'application/vnd.plotly.v1+json',
     'text/html',
     'image/png',

package/node-server/dist/private-tmp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-user private temp directories.
+ *
+ * Shared paths like /tmp/nebula-kernels break on multi-user machines twice
+ * over: the first user's mkdir (with a restrictive umask) locks everyone else
+ * out, and anything world-readable leaks — kernel connection files carry the
+ * HMAC key, which is remote code execution as the kernel's owner for anyone
+ * who can read it.
+ *
+ * Layout: <tmpdir>/nebula-<username>/<segments...>, mode 0700 throughout.
+ * /tmp is sticky, so another user CAN pre-create our directory name — we
+ * verify ownership after mkdir and refuse to use a directory we don't own.
+ */
+export declare function privateTmpDir(...segments: string[]): string;

package/node-server/dist/private-tmp.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Per-user private temp directories.
+ *
+ * Shared paths like /tmp/nebula-kernels break on multi-user machines twice
+ * over: the first user's mkdir (with a restrictive umask) locks everyone else
+ * out, and anything world-readable leaks — kernel connection files carry the
+ * HMAC key, which is remote code execution as the kernel's owner for anyone
+ * who can read it.
+ *
+ * Layout: <tmpdir>/nebula-<username>/<segments...>, mode 0700 throughout.
+ * /tmp is sticky, so another user CAN pre-create our directory name — we
+ * verify ownership after mkdir and refuse to use a directory we don't own.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateTmpDir = privateTmpDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function privateTmpDir(...segments) {
+    const user = (os.userInfo().username || String(process.getuid?.() ?? 'user'))
+        .replace(/[^a-zA-Z0-9._-]/g, '_');
+    const root = path.join(os.tmpdir(), `nebula-${user}`);
+    const dir = path.join(root, ...segments);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32' && typeof process.getuid === 'function') {
+        const st = fs.statSync(root);
+        if (st.uid !== process.getuid()) {
+            throw new Error(`${root} exists but is owned by uid ${st.uid}, not us (${process.getuid()}) — ` +
+                `refusing to write private files into another user's directory. Remove or rename it.`);
+        }
+        // mkdirSync's mode is filtered by umask and ignored for pre-existing dirs;
+        // assert the closed mode explicitly.
+        fs.chmodSync(root, 0o700);
+    }
+    return dir;
+}