notebook-intelligence 5.0.1__tar.gz → 5.1.0__tar.gz

notebook_intelligence-5.1.0/.editorconfig

@@ -0,0 +1,22 @@
+# EditorConfig (https://editorconfig.org) keeps basic whitespace consistent
+# across editors. It complements Prettier rather than replacing it: Prettier
+# still owns the canonical formatting enforced by `jlpm lint:check`.
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+# Trailing whitespace is significant in Markdown (two spaces = a hard line
+# break), so do not strip it there.
+[*.md]
+trim_trailing_whitespace = false
+
+# package.json is formatted with a 4-space tab width (see the prettier
+# override in package.json), so match that here.
+[package.json]
+indent_size = 4

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/.gitignore

@@ -90,7 +90,11 @@ ENV/
 .venv/
 .env/
 venv*/
-.vscode/
+.vscode/*
+# Share Prettier-on-save settings and extension recommendations; keep all
+# other (per-user) VS Code files ignored.
+!.vscode/settings.json
+!.vscode/extensions.json
 # celery beat schedule file
 celerybeat-schedule
 
@@ -142,3 +146,8 @@ ui-tests/.tsbuild/
 _site/
 Gemfile.lock
 
+
+# Benchmark results (may contain cost data and environment details)
+benchmarks/claude_perf/results.json
+benchmarks/claude_perf/__pycache__/
+benchmarks/claude_perf/screenshots/

notebook_intelligence-5.1.0/.husky/_/.gitignore

@@ -0,0 +1 @@
+*

notebook_intelligence-5.1.0/.husky/_/applypatch-msg

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/commit-msg

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/h

@@ -0,0 +1,22 @@
+#!/usr/bin/env sh
+[ "$HUSKY" = "2" ] && set -x
+n=$(basename "$0")
+s=$(dirname "$(dirname "$0")")/$n
+
+[ ! -f "$s" ] && exit 0
+
+if [ -f "$HOME/.huskyrc" ]; then
+	echo "husky - '~/.huskyrc' is DEPRECATED, please move your code to ~/.config/husky/init.sh"
+fi
+i="${XDG_CONFIG_HOME:-$HOME/.config}/husky/init.sh"
+[ -f "$i" ] && . "$i"
+
+[ "${HUSKY-}" = "0" ] && exit 0
+
+export PATH="node_modules/.bin:$PATH"
+sh -e "$s" "$@"
+c=$?
+
+[ $c != 0 ] && echo "husky - $n script failed (code $c)"
+[ $c = 127 ] && echo "husky - command not found in PATH=$PATH"
+exit $c

notebook_intelligence-5.1.0/.husky/_/husky.sh

@@ -0,0 +1,9 @@
+echo "husky - DEPRECATED
+
+Please remove the following two lines from $0:
+
+#!/usr/bin/env sh
+. \"\$(dirname -- \"\$0\")/_/husky.sh\"
+
+They WILL FAIL in v10.0.0
+"

notebook_intelligence-5.1.0/.husky/_/post-applypatch

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/post-checkout

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/post-commit

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/post-merge

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/post-rewrite

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-applypatch

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-auto-gc

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-commit

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-merge-commit

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-push

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/pre-rebase

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/_/prepare-commit-msg

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+. "$(dirname "$0")/h"

notebook_intelligence-5.1.0/.husky/pre-commit

@@ -0,0 +1 @@
+lint-staged

notebook_intelligence-5.1.0/.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint",
+    "stylelint.vscode-stylelint",
+    "EditorConfig.EditorConfig"
+  ]
+}

notebook_intelligence-5.1.0/.vscode/settings.json

@@ -0,0 +1,34 @@
+{
+  "[markdown]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[jsonc]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[css]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/CHANGELOG.md

@@ -10,6 +10,50 @@ For each release we list user-facing changes grouped as **Added**, **Changed**,
 
 ## [Unreleased]
 
+## [5.1.0] - UNRELEASED
+
+5.1.0 builds on 5.0.x with a focus on Claude-mode agent visibility. Tool calls the agent runs now render as persistent status cards with inline diffs and collapsible grouping, the generating indicator can cycle custom verbs, and cancelling a turn tears down the whole process tree the agent spawned instead of leaking it. It also adds two opt-in security guardrails (an MCP stdio-command allowlist and a default-token-password check on shared filesystems) and an always-visible mode for chat feedback. No traitlet, env-var, REST route, or on-disk-format renames or removals; every new admin surface is opt-in and listed below.
+
+### Upgrade note
+
+If you installed NBI before the 5.0 npm-scope rename (from `@notebook-intelligence/notebook-intelligence` to `@plmbr/notebook-intelligence`) and now see **two Notebook Intelligence icons** in the sidebar, an old labextension is lingering alongside the new one and JupyterLab is loading both. Run `jupyter labextension list`; if both scopes show as enabled, remove the stale `@notebook-intelligence` labextension directory. See [Two Notebook Intelligence icons in the sidebar](docs/troubleshooting.md#two-notebook-intelligence-icons-in-the-sidebar) (#367).
+
+### Added
+
+- **Claude agent tool calls render as persistent status cards** (#358). Each tool the agent runs in Claude mode appears as its own card showing a kind icon (read / edit / execute / other), a humanized label, and a live status (in progress, completed, failed, cancelled) that stays on screen after the turn ends instead of scrolling away as transient progress text. Built-in and `mcp__<server>__<tool>` names map to friendly labels, with a sentence-case fallback for unknown tools.
+- **Inline diffs, collapsible grouping, and unified tool maps for tool-call cards** (#360). Edit-style tools (`Edit`, `MultiEdit`, `Write`, and their MCP-wrapped variants) show an inline add/remove diff on the card, capped and truncation-marked for large changes. A run of consecutive tool calls collapses into a single expandable group so a tool-heavy turn reads as one unit rather than a wall of rows; large settled groups start collapsed, live ones stay expanded. The kind/label lookups are unified into one map shared by the humanizer and the categorizer.
+- **Custom Claude spinner verbs** (#356). When Claude mode is active, NBI reads `spinnerVerbs.verbs` from `~/.claude/settings.json` and cycles them in the generating label (Fisher-Yates shuffle, 4-7s per verb, no immediate repeats) instead of a static "Generating". The current verb is mirrored into a hidden `aria-live` region so screen readers announce verb changes without re-reading every elapsed-seconds tick.
+- **Always-visible chat feedback** (#354). New `enable_chat_feedback_always_visible` traitlet (default `False`, requires `enable_chat_feedback = True`) renders the thumbs up/down buttons at full opacity on every assistant reply instead of revealing them on hover, and drops the post-`StreamEnd` gate so they appear with the reply. The thumbs tooltips are reworded to "Good response" / "Bad response" (screen readers announce "Rate response as good" / "Rate response as bad").
+- **Admin allowlist for stdio MCP server commands** (#298). New `mcp_stdio_command_allowlist` traitlet and `NBI_MCP_STDIO_COMMAND_ALLOWLIST` env var (CSV, appended to the traitlet at startup). When non-empty, every stdio MCP server (added via Claude `mcp add` or loaded from `mcp.json`) must match at least one `re.search` regex or the admin gate rejects it; the empty default means no enforcement, so per-user deployments are unchanged. See [Restricting MCP stdio commands](docs/admin-guide.md#restricting-mcp-stdio-commands).
+- **Default-token-password guardrails on shared filesystems** (#302). The GitHub Copilot token storage path now logs a per-process warning the first time it reads or writes the stored token while the public default `NBI_GH_ACCESS_TOKEN_PASSWORD` is in use, escalated when `~/.jupyter/nbi/` is group- or other-accessible. Setting `NBI_REFUSE_DEFAULT_TOKEN_PASSWORD_ON_SHARED_FS=1` upgrades that to a hard refusal of the write when both conditions hold; `NBI_ALLOW_DEFAULT_TOKEN_PASSWORD=1` opts back out per pod. The shared-directory check is POSIX-only and the refusal is opt-in, so single-user deployments are unaffected.
+- **Claude Code vs NBI chat performance benchmark suite** (#350). A standalone suite under `benchmarks/claude_perf/` compares response times between the `claude -p` terminal CLI and NBI's chat WebSocket path (time to first token, wall time, tokens, cost), with a runner that interleaves the two paths and separates cold from warm runs. Developer tooling; not shipped in the extension.
+- **Opt-in Prettier pre-commit hook and editor format-on-save** (#355). A husky + lint-staged hook formats staged files on commit, alongside EditorConfig and VS Code format-on-save settings. Developer tooling.
+
+### Changed
+
+- **Notebook-agent prompts and tool responses** (#351). Notebook editing/execution prompts now encourage incremental analysis and intermediate validation rather than generating a whole notebook in one pass; `add-code-cell` and `add-markdown-cell` return the inserted `cellIndex` for traceability; and `read_file` caps its output with UTF-8-safe truncation so large reads stay within a budget.
+- **Expandable parameter/detail boxes use a flat fill** instead of the inner-glow effect (#361), for a cleaner read in both light and dark themes.
+
+### Fixed
+
+- **Cancelling a Claude turn tears down the whole process tree** the agent spawned (#357). A cancel previously killed only the direct `claude` CLI child, leaking reparented shells, MCP servers, and dev servers that accumulated across cancels and restarts; NBI now reaps the agent's descendants, gracefully then forcefully, without signalling the Jupyter server's own process group.
+- **Claude session-resume commands are shell-quoted** (#349). Resume launches route through the shared command builder and quote the transcript-derived session id, so malicious session metadata cannot break out of `claude --resume` into shell execution.
+- **Forged upload-context paths are rejected** (#348). WebSocket upload attachments must resolve under the server upload root before an image read or Claude file mention uses the supplied path, closing the forged `isUpload` path that could point chat context at arbitrary server-readable files outside the workspace.
+- **Tool-call diffs are readable in dark theme and the tool-call group no longer flickers** (#360, #364). Diff add/remove lines use semi-transparent tints over the card so the theme's own text color stays legible in both themes (the `--jp-*-color3` fills were light pastels in both); and the streaming response keeps a stable message identity, so the tool-call group no longer expands and collapses on its own as calls arrive.
+
+## [5.0.1] - 2026-05-24
+
+A patch release: one provider-compatibility fix, one chat-rendering fix, and the npm package-scope rename. No traitlet, env-var, REST route, or on-disk-format changes; no migration steps beyond the 5.0.0 note.
+
+### Changed
+
+- **GitHub Copilot Codex chat models route through the `/responses` endpoint** (#341). Codex-family models (e.g. `gpt-5.3-codex`) are served only by Copilot's OpenAI Responses API mirror and return HTTP 400 on the standard `/chat/completions` path, so selecting one in the chat-model dropdown previously failed. NBI now picks the endpoint per model from the `/models` catalog's `supported_endpoints` field (with a `codex` substring fallback for offline sessions), translates the request and streaming events to the Responses shape, and surfaces `response.failed` / `response.error` / `response.incomplete` / `error` events instead of an empty turn. No new settings; the dispatch is internal to the GitHub Copilot provider.
+- **npm package scope renamed to `@plmbr/notebook-intelligence`** (#342), following the GitHub org rename from `notebook-intelligence` to `plmbr`. The labextension is now listed as `@plmbr/notebook-intelligence` in `jupyter labextension list`; the pip package name (`notebook-intelligence`) is unchanged, so `pip install notebook-intelligence` still works.
+
+### Fixed
+
+- **AI-generated links in the chat sidebar open in a new tab instead of replacing the JupyterLab UI** (#347). Markdown links emitted by the model previously navigated the top-level document and unloaded the whole Lab session on click. External links (`http` / `https` / `mailto`) now open with `target="_blank" rel="noopener noreferrer"`; workspace-relative paths open the referenced file through JupyterLab's document manager; fragment-only links render as inert text; and disallowed schemes (`javascript:`, traversal-escaping paths, dangerous codepoints) are blocked.
+
 ## [5.0.0] - 2026-05-22
 
 5.0.0 is a major release built on top of 4.8.0, gathering a large surface of new admin policies, accessibility work across the chat sidebar / popovers / settings tabs, several security hardening passes, and three new agent-aware UI surfaces. Most existing configuration continues to work; the version bump reflects the breadth of new admin-policy / env-var surface that operators should review, plus the dependency swap from `fastmcp` to the official `mcp` SDK.
@@ -330,7 +374,8 @@ A multi-PR accessibility pass landed across most NBI surfaces. Together these ma
 - Settings UI restructured around Claude vs default mode.
 - WebSocket connection reliability improvements.
 
-[unreleased]: https://github.com/plmbr/notebook-intelligence/compare/v5.0.0...HEAD
+[unreleased]: https://github.com/plmbr/notebook-intelligence/compare/v5.0.1...HEAD
+[5.0.1]: https://github.com/plmbr/notebook-intelligence/compare/v5.0.0...v5.0.1
 [5.0.0]: https://github.com/plmbr/notebook-intelligence/compare/v4.8.0...v5.0.0
 [4.8.0]: https://github.com/plmbr/notebook-intelligence/compare/v4.7.0...v4.8.0
 [4.7.0]: https://github.com/plmbr/notebook-intelligence/compare/v4.6.0...v4.7.0

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/CONTRIBUTING.md

@@ -32,7 +32,7 @@ NBI has two halves:
   - `notebook_intelligence/ai_service_manager.py` — composes LLM providers, MCP, skills, and rules into the request pipeline.
   - `notebook_intelligence/llm_providers/` — provider adapters (GitHub Copilot, OpenAI-compatible, LiteLLM-compatible, Ollama).
   - `notebook_intelligence/claude.py` + `notebook_intelligence/claude_sessions.py` — Claude Code integration via [`claude-agent-sdk`](https://pypi.org/project/claude-agent-sdk/).
-  - `notebook_intelligence/mcp_manager.py` — MCP server management via [`fastmcp`](https://pypi.org/project/fastmcp/).
+  - `notebook_intelligence/mcp_manager.py`: MCP server management via the official [`mcp`](https://pypi.org/project/mcp/) SDK (replaced `fastmcp` in 5.0.0).
   - `notebook_intelligence/skill_manager.py`, `skill_github_import.py`, `skill_manifest.py`, `skill_reconciler.py`, `skillset.py` — Claude Skills storage, GitHub import, and managed-manifest reconciliation.
   - `notebook_intelligence/rule_manager.py`, `rule_injector.py`, `ruleset.py` — ruleset discovery and prompt injection.
   - `notebook_intelligence/built_in_toolsets.py` — built-in tool implementations (`nbi-notebook-edit`, `nbi-command-execute`, etc.).
@@ -176,6 +176,15 @@ jlpm lint         # check and auto-fix prettier, eslint, and stylelint
 
 CI runs `lint:check`. Identifiers prefixed with `_` are treated as intentionally unused and excluded from the unused-vars rule.
 
+### Automatic formatting
+
+Two optional layers catch formatting drift before it reaches CI, so a common lint failure (an unformatted `.md`, `.ts`, or `.css` file) never makes it into a commit:
+
+- **Pre-commit hook.** `jlpm install` registers a [Husky](https://typicode.github.io/husky/) hook (via a `postinstall` script) that runs `prettier --write` on staged files through [lint-staged](https://github.com/lint-staged/lint-staged). Staged files are formatted and re-staged automatically before the commit completes. Husky no-ops when there is no Git checkout (for example during `pip install` builds from an sdist) and when `HUSKY=0` is set, so it never affects packaging. To skip it for a single commit, use `git commit --no-verify`; to opt out entirely, run `HUSKY=0 jlpm install`.
+- **Editor format-on-save.** `.editorconfig` and `.vscode/` settings format files with Prettier on save. Install the recommended VS Code extensions (you will be prompted, or see `.vscode/extensions.json`) to enable it.
+
+Both layers only run Prettier, which is safe to apply automatically; ESLint and Stylelint rule violations are still left for you and CI to surface. Neither layer changes what CI enforces; both just move the formatting fix earlier. `jlpm lint` remains the manual catch-all.
+
 If `jlpm install` produces unexpected lockfile changes, your local Yarn version probably differs from the one bundled with JupyterLab. `jlpm` ships with JupyterLab — use it directly instead of a system-wide `yarn`.
 
 ## Packaging

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notebook_intelligence
-Version: 5.0.1
+Version: 5.1.0
 Summary: AI coding assistant for JupyterLab
 Project-URL: Homepage, https://github.com/plmbr/notebook-intelligence
 Project-URL: Bug Tracker, https://github.com/plmbr/notebook-intelligence/issues
@@ -704,6 +704,7 @@ Requires-Dist: mcp>=1.27.0
 Requires-Dist: mistune>=3.2.1
 Requires-Dist: ollama
 Requires-Dist: openai
+Requires-Dist: psutil>=5.7
 Requires-Dist: python-multipart>=0.0.27
 Requires-Dist: sseclient-py
 Requires-Dist: tiktoken
@@ -811,7 +812,7 @@ If the Claude Code CLI is on `PATH`, NBI launches it automatically. To override
 
 When Claude mode is on, the chat sidebar shows a history icon next to the gear. Click it to list the Claude Code sessions recorded for the current working directory (the same transcripts the Claude Code CLI stores under `~/.claude/projects/`). Selecting a session reconnects via `resume`, so the next message you send continues that transcript with full prior context. A **New chat session** button next to the gear restarts the SDK client without typing `/clear`.
 
-Long Claude turns surface an elapsed-time counter, a heartbeat-driven pulse with a "may be slow" copy flip after 30 seconds, and inline tool-call narration so the sidebar reflects what the agent is doing rather than appearing stuck.
+Long Claude turns surface an elapsed-time counter and a heartbeat-driven pulse with a "may be slow" copy flip after 30 seconds. Each tool the agent runs shows up as a persistent status card with a kind icon and a live in-progress / done / failed state; edits carry an inline diff, and a run of consecutive calls collapses into one expandable group, so the sidebar reflects what the agent is doing rather than appearing stuck.
 
 In Claude mode, workspace files attached as chat context arrive as `@`-mention pointers rather than inlined file contents. Claude's Read tool fetches them on demand, which means images, large files, and notebooks (cell-aware) now work where the older content-injection path silently truncated or skipped them.
 
@@ -1100,6 +1101,12 @@ jupyter lab --NotebookIntelligence.enable_chat_feedback=true
 
 The feedback fires an in-process `telemetry` event. Nothing leaves the process by default — see the [admin guide](docs/admin-guide.md#chat-feedback-event-hook) for how to wire it into your observability stack.
 
+The thumbs buttons reveal on hover by default. To keep them always visible, enable:
+
+```python
+c.NotebookIntelligence.enable_chat_feedback_always_visible = True
+```
+
 <img src="media/chat-feedback.png" alt="Chat feedback" width=500 />
 
 ## Documentation

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/PRIVACY.md

@@ -58,7 +58,7 @@ For air-gapped or egress-restricted environments, see [`docs/admin-guide.md`](do
 
 > Treat `~/.jupyter/nbi/config.json` and `~/.jupyter/nbi/user-data.json` as secrets. They contain your API keys and (encrypted) GitHub token. Do not commit them to git, share them, or sync them across users. If a key leaks, rotate it at the provider immediately.
 
-The encrypted GitHub token uses a default password (`nbi-access-token-password`) unless you set `NBI_GH_ACCESS_TOKEN_PASSWORD`. The default is **shared across installs** and provides obfuscation, not real protection. Set a custom password before enabling "remember login" on any shared or multi-tenant system.
+The encrypted GitHub token uses a default password (`nbi-access-token-password`) unless you set `NBI_GH_ACCESS_TOKEN_PASSWORD`. The default is **shared across installs** and provides obfuscation, not real protection. Set a custom password before enabling "remember login" on any shared or multi-tenant system. NBI logs a per-process WARNING when the default is in use and escalates the message when `~/.jupyter/nbi/` is group/other-accessible. Operators on shared filesystems can set `NBI_REFUSE_DEFAULT_TOKEN_PASSWORD_ON_SHARED_FS=1` to refuse the write entirely until a per-user password is configured, with `NBI_ALLOW_DEFAULT_TOKEN_PASSWORD=1` available as an explicit per-pod opt-out during a rollout.
 
 ## Telemetry
 

{notebook_intelligence-5.0.1 → notebook_intelligence-5.1.0}/README.md

@@ -94,7 +94,7 @@ If the Claude Code CLI is on `PATH`, NBI launches it automatically. To override
 
 When Claude mode is on, the chat sidebar shows a history icon next to the gear. Click it to list the Claude Code sessions recorded for the current working directory (the same transcripts the Claude Code CLI stores under `~/.claude/projects/`). Selecting a session reconnects via `resume`, so the next message you send continues that transcript with full prior context. A **New chat session** button next to the gear restarts the SDK client without typing `/clear`.
 
-Long Claude turns surface an elapsed-time counter, a heartbeat-driven pulse with a "may be slow" copy flip after 30 seconds, and inline tool-call narration so the sidebar reflects what the agent is doing rather than appearing stuck.
+Long Claude turns surface an elapsed-time counter and a heartbeat-driven pulse with a "may be slow" copy flip after 30 seconds. Each tool the agent runs shows up as a persistent status card with a kind icon and a live in-progress / done / failed state; edits carry an inline diff, and a run of consecutive calls collapses into one expandable group, so the sidebar reflects what the agent is doing rather than appearing stuck.
 
 In Claude mode, workspace files attached as chat context arrive as `@`-mention pointers rather than inlined file contents. Claude's Read tool fetches them on demand, which means images, large files, and notebooks (cell-aware) now work where the older content-injection path silently truncated or skipped them.
 
@@ -383,6 +383,12 @@ jupyter lab --NotebookIntelligence.enable_chat_feedback=true
 
 The feedback fires an in-process `telemetry` event. Nothing leaves the process by default — see the [admin guide](docs/admin-guide.md#chat-feedback-event-hook) for how to wire it into your observability stack.
 
+The thumbs buttons reveal on hover by default. To keep them always visible, enable:
+
+```python
+c.NotebookIntelligence.enable_chat_feedback_always_visible = True
+```
+
 <img src="media/chat-feedback.png" alt="Chat feedback" width=500 />
 
 ## Documentation

notebook_intelligence-5.1.0/benchmarks/claude_perf/README.md

@@ -0,0 +1,64 @@
+# Claude Code Performance Benchmark
+
+Compare Claude Code response times between the terminal CLI and NBI's chat sidebar.
+
+## Quick start
+
+```bash
+cd benchmarks/claude_perf
+
+# Smoke test (terminal only, 2 iterations, one prompt)
+python bench_runner.py --iterations 2 --prompts short --terminal-only
+
+# Full terminal benchmark (25 iterations, all prompts)
+python bench_runner.py --iterations 25 --terminal-only
+
+# Full comparison (requires JupyterLab running on :8889 with Claude mode on)
+python bench_runner.py --iterations 25
+
+# Non-interleaved (all terminal first, then all NBI)
+python bench_runner.py --iterations 25 --no-interleave
+
+# View results
+python report.py
+```
+
+## What it measures
+
+| Metric            | Terminal                           | NBI Chat                                        |
+| ----------------- | ---------------------------------- | ----------------------------------------------- |
+| TTFT (ms)         | From Claude CLI's `result.ttft_ms` | From WebSocket send to first `nbiContent` chunk |
+| Wall time (ms)    | subprocess spawn to exit           | WebSocket send to `stream-end`                  |
+| CLI duration (ms) | `result.duration_ms`               | n/a                                             |
+| API duration (ms) | `result.duration_api_ms`           | n/a                                             |
+| Output tokens     | From `result.usage`                | n/a                                             |
+| Output chars      | From `result.result` text length   | From streamed markdown chunks                   |
+
+## Methodology notes
+
+This benchmark measures **end-to-end user-perceived latency** for each surface, not isolated NBI overhead. Several structural asymmetries should be kept in mind when interpreting results:
+
+**Different process models.** The terminal path spawns a fresh `claude -p` subprocess per run (pays Node.js startup, config loading, MCP server discovery each time). The NBI path hits an already-running JupyterLab server where the Agent SDK client is warm. This means the terminal "cold" cost is higher than NBI's, but for a different reason than NBI overhead.
+
+**Different system prompts.** The `claude -p` CLI loads `~/.claude/CLAUDE.md`, project CLAUDE.md, skills, and MCP tool schemas into its system prompt. NBI builds a shorter JupyterLab-specific prompt. Different input token counts affect TTFT via prompt-cache behavior: each path warms its own cache key, and the first run in each block pays `cache_creation_input_tokens` cost.
+
+**Prompt cache confound.** Run 0 ("cold") in each path is tagged separately and excluded from the comparison table's warm-only medians. The comparison table reflects steady-state performance after caches are populated.
+
+**API latency dominates.** Claude API TTFT commonly spans 800-3000ms depending on load and cache state. NBI's local overhead (WebSocket parsing, thread dispatch, Agent SDK query: ~200-500ms) is a fraction of one standard deviation of API latency. With 25 samples, detecting a real 300ms difference on top of 2-5s API calls requires looking at the interleaved paired medians, not individual run comparisons.
+
+**Interleaving.** By default, terminal and NBI runs are interleaved (terminal-NBI-terminal-NBI) to cancel out API load drift over the run. Use `--no-interleave` for block-sequential if needed.
+
+## Prerequisites
+
+- `claude` CLI on PATH (Claude Code 2.x)
+- For NBI benchmarks: JupyterLab running with NBI installed, Claude mode enabled, no auth token (or pass `--nbi-token`)
+- `pip install websockets` (for the WebSocket benchmark)
+
+## Files
+
+- `bench_terminal.py` - runs one prompt through `claude -p --output-format stream-json --verbose`
+- `bench_nbi_ws.py` - connects to NBI's WebSocket and sends one chat request
+- `bench_runner.py` - orchestrator (iterations, prompt bank, cold/warm, interleaving, summary table)
+- `report.py` - reads `results.json` and prints formatted comparison with histograms
+- `prompts.py` - the prompt bank (short / medium / code / long)
+- `stats.py` - shared `summarize()` helper

notebook_intelligence-5.1.0/benchmarks/claude_perf/bench_nbi_ws.py

@@ -0,0 +1,148 @@
+"""Benchmark Claude Code through NBI's WebSocket chat endpoint.
+
+Connects to `ws://host:port/notebook-intelligence/copilot`, sends a
+chat-request message, and measures timing from the outside:
+
+- `ttft_ms`:      time from message-send to first content chunk
+- `wall_ms`:      time from message-send to stream-end signal
+- `output_chars`: total characters in the streamed assistant reply
+
+JupyterLab must be running with NBI installed and Claude mode enabled.
+The server token (if any) must be empty or passed via `--token`.
+
+Protocol notes (from extension.py):
+- Streaming chunks arrive as JSON with `choices[0].delta.nbiContent`
+  where `nbiContent.type` is "markdown", "markdown_part", etc.
+- The finish signal is `{"type": "stream-end", ...}`.
+- Heartbeats arrive as `{"type": "claude-code-heartbeat", ...}`.
+"""
+
+import asyncio
+import json
+import time
+import uuid
+
+try:
+    import websockets
+except ImportError:
+    websockets = None
+
+
+async def run_once_async(
+    prompt: str,
+    *,
+    host: str = "localhost",
+    port: int = 8889,
+    token: str = "",
+) -> dict:
+    if websockets is None:
+        return {"error": "websockets package not installed (pip install websockets)"}
+
+    url = f"ws://{host}:{port}/notebook-intelligence/copilot"
+    if token:
+        url += f"?token={token}"
+
+    chat_id = str(uuid.uuid4())
+    message_id = str(uuid.uuid4())
+
+    request = json.dumps({
+        "id": message_id,
+        "type": "chat-request",
+        "data": {
+            "chatId": chat_id,
+            "prompt": prompt,
+            "language": "python",
+            "filename": "benchmark.py",
+            "chatMode": "ask",
+            "toolSelections": {},
+            "additionalContext": [],
+        },
+    })
+
+    first_content_time = None
+    total_chars = 0
+    finished = False
+    error_msg = None
+
+    wall_start = time.perf_counter()
+
+    try:
+        async with websockets.connect(url, close_timeout=5, max_size=10 * 1024 * 1024) as ws:
+            await ws.send(request)
+
+            while not finished:
+                try:
+                    raw = await asyncio.wait_for(ws.recv(), timeout=120)
+                except asyncio.TimeoutError:
+                    error_msg = "timed out waiting for response (120s)"
+                    break
+
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+
+                msg_type = msg.get("type")
+
+                # NBI stream-end signal
+                if msg_type == "stream-end":
+                    finished = True
+                    continue
+
+                # Heartbeat (ignore for timing, but proves the connection is alive)
+                if msg_type == "claude-code-heartbeat":
+                    continue
+
+                # Streaming content: wrapped as
+                # {"type": "stream-message", "data": {"choices": [...]}}
+                data = msg.get("data") or {}
+                choices = data.get("choices") if isinstance(data, dict) else None
+                if isinstance(choices, list) and choices:
+                    delta = choices[0].get("delta", {})
+                    nbi = delta.get("nbiContent", {})
+                    nbi_type = nbi.get("type")
+
+                    if nbi_type in ("markdown", "markdown-part"):
+                        content = nbi.get("content", "")
+                        if content and first_content_time is None:
+                            first_content_time = time.perf_counter()
+                        total_chars += len(content)
+
+    except Exception as e:
+        error_msg = str(e)
+
+    wall_end = time.perf_counter()
+    wall_ms = round((wall_end - wall_start) * 1000, 1)
+
+    if error_msg:
+        return {"error": error_msg, "wall_ms": wall_ms}
+
+    ttft_ms = (
+        round((first_content_time - wall_start) * 1000, 1)
+        if first_content_time
+        else None
+    )
+
+    return {
+        "ttft_ms": ttft_ms,
+        "wall_ms": wall_ms,
+        "output_chars": total_chars,
+    }
+
+
+def run_once(
+    prompt: str,
+    *,
+    host: str = "localhost",
+    port: int = 8889,
+    token: str = "",
+) -> dict:
+    return asyncio.run(
+        run_once_async(prompt, host=host, port=port, token=token)
+    )
+
+
+if __name__ == "__main__":
+    import pprint
+    result = run_once("What is 2+2?")
+    pprint.pprint(result)