Create a new empty notebook at path (must not exist yet).

Index of the notebook: one line per cell (index, name, revision, staleness, one-line summary) plus dependency edges and lint findings. Start here when opening a notebook. Summaries marked with * are deterministic fallbacks, not LLM-generated.

Read cells with code and condensed outputs (charts attached as images). Select by names (list of cell names), indices (python slice string like '0:5'), or neither for the whole notebook. view: full | code | outputs.

Add a cell. name must be unique kebab-case. Placement: after (an existing cell name; '' prepends), index, or omit both to append. run="stale" immediately executes every stale cell (the add→run loop in one call) and returns the execution results.

Replace a cell's source and/or rename it. expected_rev must be the rev from your latest read of this cell (optimistic locking). Updating source clears the cell's outputs and marks it (and dependents) stale. run="stale" immediately executes every stale cell (the edit→run loop in one call) and returns the execution results.

Delete a cell (requires its current rev; undo with undo_last).

Move a cell: after an existing cell ('' moves to top) or to index.

Execute cells on the notebook's persistent kernel.

Default (no `cells`): every stale cell in document order — minimal
recompute after edits. With `cells`: exactly those cells, even if fresh
(API calls, randomness), preceded by their stale ancestors so inputs are
trustworthy (`fresh_deps=false` skips the ancestor pass). Outputs are
persisted and returned condensed; charts come back as images; `quiet`
collapses ok cells to status lines. If everything finishes within
`wait_seconds` you get full results; otherwise execution continues in the
background — watch it via notebook_overview / read_cells (live output),
stop it via interrupt.

Interrupt the currently running cell (KeyboardInterrupt in the kernel) and cancel queued cells. Kernel state (variables) survives; interrupted cells read as stale until a successful re-run.

Restart the notebook's kernel (all in-memory state is lost; every code cell becomes stale).

Inspect a live kernel variable without adding a cell: type, shape, schema/columns, length, plus its richest Jupyter repr — dataframes condense to a CSV table, figures come back as images, everything else falls back to a (pretty) repr.

Restore the notebook to its state before the most recent mutation.

Detailed summaries (LLM): per-cell description plus, optionally, a summary of each cell's current output. Cheaper than reading full cells when orienting in a large notebook.

Search cell sources, names, summaries, and condensed outputs. Returns matching cells with the matching lines.