diff --git a/CHANGELOG.md b/CHANGELOG.md
index df952bb..238c9a6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **The Debug Console and Watch work at a `breakpoint()` or red dot.** Type Python into the Debug
+  Console and it runs in the frame selected in the Call Stack: its locals, closed-over names, its
+  module's globals (an imported module's own, not the notebook's) and the builtins, as the paused
+  line itself would see them. A result opens like a Variables row; `print()` shows in the console;
+  names you bind (`y = 5`, `import json`, a `def`) last until the run resumes. An error reads as a
+  Jupyter traceback, frame by frame with the line that raised marked. A line runs as long as it
+  takes, and after a few seconds a notification offers to stop it; a watch keeps a two-second limit.
+  Code the console calls runs straight past `breakpoint()` and red dots. Not yet: `cls` in a
+  classmethod's frame, and rebinding a local (`n = 99`) changes the console's copy, not the paused
+  function.
+- **Show in Debug Console and Evaluate with self… on a Variables row.** Right-click any row, however
+  deep in the tree, and **Show in Debug Console** opens the console with that object in it: an
+  object with its attributes listed beneath, each by name; a list, set or dict, or an object with
+  more than 20 attributes, as one row that opens like the Variables row. Its name is left at the
+  console's prompt, or `_` bound to it for a row whose name means nothing there, such as a list item. **Evaluate with self…** asks for an expression and shows what it gives
+  with `self` bound to the row's object, in the frame selected in Call Stack.
 - **Variables shows each value's type, and opens objects whole.** Every row starts with its type,
   and a container's with its size too, as PyCharm shows them: `{Point} Point(3, 4)`,
   `{list: 3} […]`, `{list: 150}` for one too big to show. **Copy Value** copies the value alone,
@@ -29,6 +45,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   continues with it. What Python refuses is refused with Python's reason, such as a property with
   no setter. A method's receiver (`self`, or whatever the def calls it), a tuple's items, group
   rows and a saved stack's values cannot be changed, and VS Code does not offer Set Value on them.
+- **GemDB commands in the Debug Console.** A line starting with `%` is a GemDB command rather than
+  Python: `%persist p` adds `p` to Persisted Objects (or `%persist expr as key`), shown there as
+  added until the notebook commits; `%commit` commits the notebook; `%names` lists the names you
+  have bound in the console at this pause; `%help` lists the commands. Typing `%` suggests them,
+  and `%persist ` suggests your console names. The first pause in a window says so, once. `gemdb`
+  is available in the console without an import, so a line copied from Persisted Objects
+  (`gemdb.root["orders"]`) works in any program, and each persisted entry is there by its key
+  (`orders`) at every pause, unless the paused code has a name of its own spelled so, and is
+  labelled `orders is gemdb.root["orders"]` when typed; `persisted.orders` reaches it whatever
+  `orders` means at the pause. Typing a name offers `persisted.orders` in autocomplete for each
+  persisted entry it starts, and `persisted.` offers the keys.
+- **The Debug Console on a saved stack.** A stack reopened with **Restore a Saved Stack…** now has a
+  Debug Console, in each frame, on the saved objects: evaluate, call methods, bind names, change
+  objects, `%names`, `%persist`, `%commit`, Show in Debug Console and Evaluate with self…. The stack
+  opens in a database session of its own, so a change waits there uncommitted, as a notebook's
+  does. When the stack opens, the console warns that `%commit` (or ✓ in Persisted Objects) would
+  write a change into the saved stack, which then no longer holds the values it was saved with. Closing the stack
+  with changes pending asks whether to commit them; otherwise they are discarded.
+
+### Fixed
+
+- **A classmethod's or staticmethod's frame is named by its class.** The Call Stack read
+  `Account class.open` for a paused `@classmethod` or `@staticmethod`; it now reads `Account.open`,
+  as CPython names it.
 
 ## [1.6.0] - 2026-10-07
 
@@ -198,7 +238,7 @@ The engine is unchanged at GemStone 4.0.0.a4, so a database created by GemDB
   Saved Stack…** (a button in Run and Debug, and in the GemDB panel) lists the saved stacks, or
   opens the only one, in Run and Debug again; Persisted Objects can open it from its row too — after
   a restart, and with the notebook or file gone. Each frame shows the copy of its source saved with
-  the stack, marked "(saved <time>)" in its tab and Call Stack row. It is a read-only snapshot: the run itself is not resumed.
+  the stack, marked "(saved <time>)" in its tab and Call Stack row. It is a snapshot: the run itself is not resumed.
 - **A Persisted Objects view** under GemDB, and in Run and Debug while a cell is paused, lists what
   `gemdb.root` has committed, with a check mark, and under each notebook the objects added from the
   debugger that it has not committed yet. Its title bar always has **Commit** and **Abort**, for the
diff --git a/README.md b/README.md
index 199beeb..a67287a 100644
--- a/README.md
+++ b/README.md
@@ -422,12 +422,33 @@ database, select that kernel from the kernel picker at the top right.
   a local, a global, an attribute, a list item or a dict entry. The value you type is a Python
   expression, and the run continues with it. It can use the notebook's globals, or a `.py` file's,
   on any row, and on a Locals row the frame's locals too. **Continue** resumes the cell where it paused; **Stop**
-  ends it, along with any cells queued after it. Stepping is not supported yet, and neither are red
+  ends it, along with any cells queued after it. The **Debug Console** and **Watch** work at the
+  pause: type Python and it runs in the frame selected in the Call Stack, with that frame's locals,
+  its module's globals and the builtins, and a result opens like a Variables row. Names you bind
+  there last until the run resumes; an error reads as a notebook traceback; a long-running line can
+  be stopped from the notification that appears. A change to an object made there is in the
+  notebook's transaction, as it would be from a cell. Right-click a Variables row for **Show in
+  Debug Console**, which puts that object in the console (an object with its attributes
+  listed, a list or dict as one row that opens) and leaves its name at the prompt, or `_` for a
+  nested row, ready for the next line, or **Evaluate with self…**,
+  which runs an expression with `self` bound to it (`len(self.history)`) and shows the answer
+  there. Lines starting with `%` are GemDB commands, not Python: `%persist p` adds `p` to
+  Persisted Objects (`%persist expr as key` for anything else), `%commit` commits the notebook,
+  `%names` lists what you have bound in the console, and `%help` lists them all. Type `%` and the
+  console suggests them. `gemdb` is always available in the console, so a line copied from Persisted
+  Objects, such as `gemdb.root["orders"]`, works even if the program never imported it. What Persisted Objects holds is available by its
+  key too (`o` for `gemdb.root["o"]`), unless the paused code has its own name `o`; `persisted.o` reaches it whatever `o` means, and a
+  bare persisted name is labelled with where it came from. While you type a name, autocomplete
+  offers `persisted.o` for each persisted entry it starts (press Tab to take a suggestion). Stepping is not supported yet, and neither are red
   dots in a cell (they work in `.py` files; see above). Right-click a Variables row and choose **Add to Persisted Objects…** to keep that object: it
   goes in `gemdb.root` under the key you give (one is suggested) and is written at the notebook's
   next commit. The **Persisted Objects** view, under GemDB and in Run and Debug, lists what `gemdb.root`
   holds; its title bar always has **Commit** and **Abort** for the notebook you are working in. **Add Stack to Persisted Objects…** on the Call Stack saves the whole paused stack the same
-  way; once committed, Persisted Objects reopens it in the debugger, even after a restart.
+  way; once committed, Persisted Objects reopens it in the debugger, even after a restart. Its
+  Debug Console works on the saved objects: call a method, bind a name, change an object,
+  `%persist` one. A change waits uncommitted; the console says when the stack opens that `%commit`
+  (or ✓) would write it into the saved stack, and closing the stack asks whether to commit or
+  discard what is pending.
   **Debug Python File in GemDB** does the same for a `.py` file (see above). In the GemDB Shell
   and in **Run Python File in GemDB**, `breakpoint()` prints where it was and the code carries on.
 - Each notebook has its own session and its own transaction, so a commit in one notebook never
diff --git a/package.json b/package.json
index 77dbfff..f050cc0 100644
--- a/package.json
+++ b/package.json
@@ -397,6 +397,16 @@
         "title": "Keep the Database Running After Logout",
         "category": "GemDB"
       },
+      {
+        "command": "gemdb.showInDebugConsole",
+        "title": "Show in Debug Console",
+        "category": "GemDB"
+      },
+      {
+        "command": "gemdb.evaluateWithSelf",
+        "title": "Evaluate with self…",
+        "category": "GemDB"
+      },
       {
         "command": "gemdb.saveVariable",
         "title": "Add to Persisted Objects…",
@@ -594,6 +604,14 @@
           "command": "gemdb.configureRemoveIpc",
           "when": "isLinux"
         },
+        {
+          "command": "gemdb.showInDebugConsole",
+          "when": "false"
+        },
+        {
+          "command": "gemdb.evaluateWithSelf",
+          "when": "false"
+        },
         {
           "command": "gemdb.saveVariable",
           "when": "false"
@@ -637,9 +655,19 @@
       ],
       "debug/variables/context": [
         {
-          "command": "gemdb.saveVariable",
+          "command": "gemdb.showInDebugConsole",
           "when": "debugType == gemdb",
           "group": "z_gemdb@1"
+        },
+        {
+          "command": "gemdb.evaluateWithSelf",
+          "when": "debugType == gemdb",
+          "group": "z_gemdb@2"
+        },
+        {
+          "command": "gemdb.saveVariable",
+          "when": "debugType == gemdb",
+          "group": "z_gemdb@3"
         }
       ],
       "view/item/context": [
diff --git a/src/__integration__/breakpoint.test.ts b/src/__integration__/breakpoint.test.ts
index 05005d3..1ff767e 100644
--- a/src/__integration__/breakpoint.test.ts
+++ b/src/__integration__/breakpoint.test.ts
@@ -1221,6 +1221,38 @@ describe.skipIf(!haveExtent || !canMakeFixture())('breakpoint()', () => {
     expect(result.value).toBe('7');
   });
 
+  it('names a classmethod’s and a staticmethod’s frame by their class, as CPython does', async () => {
+    const names: string[][] = [];
+    setHaltHandler(async (request) => {
+      names.push(
+        parsePythonStack(await request.query(pythonStackQuery(request.process))).map((f) => f.name),
+      );
+      return 'continue';
+    });
+
+    await runPython(
+      [
+        'class Account:',
+        '    @classmethod',
+        '    def open(cls):',
+        '        breakpoint()',
+        '        return cls()',
+        '    @staticmethod',
+        '    def check():',
+        '        breakpoint()',
+        '        return 1',
+        'Account.open()',
+        'Account.check()',
+      ].join('\n'),
+      NB,
+    );
+
+    expect(names).toEqual([
+      ['Account.open', '<module>'],
+      ['Account.check', '<module>'],
+    ]);
+  });
+
   it('turns an interrupt while paused into KeyboardInterrupt and tells the handler', async () => {
     let cancelled = false;
     setHaltHandler(
diff --git a/src/__integration__/debugConsole.test.ts b/src/__integration__/debugConsole.test.ts
new file mode 100644
index 0000000..d859909
--- /dev/null
+++ b/src/__integration__/debugConsole.test.ts
@@ -0,0 +1,1232 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import {
+  __debugFactories,
+  __debugStarts,
+  DebugAdapterInlineImplementation,
+  NotebookCellKind,
+  SourceBreakpoint,
+  debug,
+  workspace,
+} from '../__mocks__/vscode';
+import { PauseDebugAdapter, registerBreakpointDebugger } from '../debugger';
+import { fileOwner } from '../fileOwner';
+import { stageGrail } from '../grail';
+import {
+  abortQuery,
+  childrenQuery,
+  commitQuery,
+  needsCommitQuery,
+  parseChildren,
+  parsePausedStack,
+  pausedStackQuery,
+} from '../pauseVariables';
+import { isRunning, startNetldi, startStone, stopNetldi, stopStone } from '../processes';
+import { PyResult, runPython, runPythonFile } from '../pythonQueries';
+import {
+  SessionOwner,
+  closeSessionFor,
+  executeAsync,
+  logoutAll,
+  sessionForIfOpen,
+  setHaltHandler,
+} from '../session';
+import { savedStackConsole, stackOwner, stackQuery } from '../savedObjects';
+import {
+  SavedFrame,
+  openStackQuery,
+  parseOpenedStack,
+  restoredFrames,
+  saveStackQuery,
+} from '../savedStacks';
+import { createDatabaseWithPython, Fixture, haveTestExtent, makeFixture } from './fixture';
+
+/**
+ * The Debug Console and the Watch pane against a real database, through the
+ * adapter VS Code would talk to: a cell pauses at breakpoint(), the debugger
+ * opens on it as it does in the editor, and the test types into the console
+ * by sending `evaluate` requests.
+ *
+ * The bar is debugpy's console: whatever the paused line could have said, the
+ * console can say, against the same names, and it reads back the way Python
+ * would — an error as a Jupyter traceback.
+ */
+
+const ext = process.cwd();
+const haveExtent = haveTestExtent();
+
+/** A notebook of its own per test, so no test sees another's globals. */
+const notebook = (name: string): SessionOwner => ({
+  key: `file:///${name}.ipynb`,
+  kind: 'notebook',
+  label: `${name}.ipynb`,
+});
+
+/** A module the notebooks import, with names of its own and a line to put a red dot on. */
+const DCMOD = [
+  'MODULE_ONLY = "mod"',
+  'shared = "module"',
+  '',
+  'def in_module(arg):',
+  '    breakpoint()',
+  '    return arg',
+  '',
+  'def fail():',
+  '    return {}["missing"]',
+  '',
+  'def dotted():',
+  '    x = 41',
+  '    return x + 1',
+].join('\n');
+
+/** The line of `x = 41` in DCMOD, 1-based. */
+const DOTTED_LINE = 12;
+
+let fixture: Fixture | undefined;
+
+beforeAll(async () => {
+  if (!haveExtent) return;
+  fixture = makeFixture();
+  if (!fixture) return;
+  fs.writeFileSync(path.join(fixture.root, 'dcmod.py'), DCMOD);
+  createDatabaseWithPython(fixture);
+  stageGrail(ext);
+  await startStone();
+  await startNetldi();
+});
+
+afterAll(async () => {
+  if (!fixture) return;
+  logoutAll();
+  try {
+    await stopNetldi();
+  } finally {
+    if (isRunning()) await stopStone(true);
+    fixture.remove();
+  }
+});
+
+/** See database.test.ts — skipIf is evaluated during collection. */
+function canMakeFixture(): boolean {
+  const probe = makeFixture();
+  if (!probe) return false;
+  probe.remove();
+  return true;
+}
+
+/** The cell lines that make `dcmod` importable from the fixture's root. */
+const importDcmod = (): string =>
+  `import sys\nsys.path.insert(0, ${JSON.stringify(fixture!.root)})\nimport dcmod`;
+
+// ---------------------------------------------------------------------------
+// Talking to the adapter the way VS Code does.
+// ---------------------------------------------------------------------------
+
+type Message = Record<string, unknown> & {
+  type: string;
+  command?: string;
+  event?: string;
+  request_seq?: number;
+  success?: boolean;
+  message?: string;
+  body?: Record<string, unknown>;
+};
+
+/** What one console line or watch came back with. */
+interface Evaluated {
+  ok: boolean;
+  /** The value as shown; '' for None or a statement. */
+  result: string;
+  type?: string;
+  /** Opens the result like a Variables row; 0 for a leaf. */
+  ref: number;
+  indexed?: number;
+  /** The failure's text: a traceback, or why the line was stopped. */
+  message: string;
+  /** Lines of `message`. */
+  lines: string[];
+  /** What the line printed, from `output` events sent before the answer. */
+  printed: string;
+  categories: string[];
+  /** Whether the adapter told VS Code to read the variables again. */
+  invalidated: boolean;
+  millis: number;
+}
+
+class Dap {
+  readonly sent: Message[] = [];
+  private seq = 1;
+  private readonly waiting = new Map<number, (m: Message) => void>();
+
+  constructor(private readonly adapter: InstanceType<typeof PauseDebugAdapter>) {
+    adapter.onDidSendMessage((raw) => {
+      const m = raw as Message;
+      this.sent.push(m);
+      if (m.type === 'response' && m.request_seq !== undefined) {
+        this.waiting.get(m.request_seq)?.(m);
+        this.waiting.delete(m.request_seq);
+      }
+    });
+  }
+
+  /** Send a request; its seq at once, its response when it comes. */
+  start(
+    command: string,
+    args: Record<string, unknown> = {},
+  ): { seq: number; done: Promise<Message> } {
+    const seq = this.seq++;
+    const done = new Promise<Message>((resolve) => this.waiting.set(seq, resolve));
+    this.adapter.handleMessage({ seq, type: 'request', command, arguments: args });
+    return { seq, done };
+  }
+
+  request(command: string, args: Record<string, unknown> = {}): Promise<Message> {
+    return this.start(command, args).done;
+  }
+
+  /** Type `expression` into the console (or add it as a watch) and wait for the answer. */
+  async evaluate(
+    expression: string,
+    { frameId, context = 'repl' }: { frameId?: number; context?: string } = {},
+  ): Promise<Evaluated> {
+    const from = this.sent.length;
+    const began = Date.now();
+    const response = await this.request('evaluate', {
+      expression,
+      context,
+      ...(frameId === undefined ? {} : { frameId }),
+    });
+    return this.read(response, from, began);
+  }
+
+  /** Make an Evaluated of a response, from what was sent since `from`. */
+  read(response: Message, from: number, began: number): Evaluated {
+    const millis = Date.now() - began;
+    const upToAnswer = this.sent.slice(from, this.sent.indexOf(response));
+    const outputs = upToAnswer.filter((m) => m.event === 'output');
+    const body = response.body ?? {};
+    const message = response.success ? '' : String(response.message ?? '');
+    return {
+      ok: response.success === true,
+      result: String(body.result ?? ''),
+      ...(body.type === undefined ? {} : { type: String(body.type) }),
+      ref: Number(body.variablesReference ?? 0),
+      ...(body.indexedVariables === undefined ? {} : { indexed: Number(body.indexedVariables) }),
+      message,
+      lines: message.split('\n'),
+      printed: outputs.map((m) => String(m.body?.output ?? '')).join(''),
+      categories: outputs.map((m) => String(m.body?.category ?? '')),
+      // Sent with the answer or just after it; read once the answer is in.
+      invalidated: this.sent.slice(from).some((m) => m.event === 'invalidated'),
+      millis,
+    };
+  }
+
+  /** The value an expression gives in the console, failing the test if it raised. */
+  async value(expression: string, frameId?: number): Promise<string> {
+    const r = await this.evaluate(expression, { frameId });
+    if (!r.ok) throw new Error(`${expression} failed:\n${r.message}`);
+    return r.result;
+  }
+
+  /** The last line of the error an expression raises — `NameError: …` and the like. */
+  async raises(expression: string, frameId?: number): Promise<string> {
+    const r = await this.evaluate(expression, { frameId });
+    if (r.ok) throw new Error(`${expression} answered ${r.result} instead of raising`);
+    return r.lines.filter((l) => l.trim() !== '').pop() ?? '';
+  }
+
+  async frames(): Promise<Array<{ id: number; name: string }>> {
+    const r = await this.request('stackTrace', { threadId: 1 });
+    return (r.body?.stackFrames ?? []) as Array<{ id: number; name: string }>;
+  }
+
+  async children(
+    ref: number,
+  ): Promise<Array<{ name: string; value: string; variablesReference: number }>> {
+    const r = await this.request('variables', { variablesReference: ref });
+    return (r.body?.variables ?? []) as Array<{
+      name: string;
+      value: string;
+      variablesReference: number;
+    }>;
+  }
+
+  /** A frame's Locals rows. */
+  async locals(
+    frameId = 1,
+  ): Promise<Array<{ name: string; value: string; variablesReference: number }>> {
+    const r = await this.request('scopes', { frameId });
+    const scopes = (r.body?.scopes ?? []) as Array<{ name: string; variablesReference: number }>;
+    const locals = scopes.find((s) => s.name === 'Locals');
+    if (!locals) throw new Error(`frame ${frameId} has no Locals`);
+    return this.children(locals.variablesReference);
+  }
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** The adapter VS Code would get for debug session `index` of `__debugStarts`. */
+function adapterFor(index: number): InstanceType<typeof PauseDebugAdapter> {
+  const factory = __debugFactories.get('gemdb') as {
+    createDebugAdapterDescriptor: (s: unknown) => DebugAdapterInlineImplementation;
+  };
+  return factory.createDebugAdapterDescriptor({ configuration: __debugStarts[index] })
+    .implementation as InstanceType<typeof PauseDebugAdapter>;
+}
+
+/**
+ * Run `run` with the debugger registered, and at its Nth pause open the
+ * debugger, as VS Code does, and hand it to the Nth of `drivers`; then
+ * Continue. Answers the run's result and how many debug sessions it opened.
+ * A driver that fails still continues the run, so the run never strands.
+ */
+async function atPauses(
+  run: () => Promise<PyResult>,
+  ...drivers: Array<(dap: Dap) => Promise<void>>
+): Promise<{ result: PyResult; sessions: number }> {
+  const registration = registerBreakpointDebugger();
+  const first = __debugStarts.length;
+  let ended = false;
+  const running = run().finally(() => (ended = true));
+  let failure: unknown;
+  try {
+    for (let i = 0; i < drivers.length; i++) {
+      while (__debugStarts.length <= first + i) {
+        if (ended) throw new Error(`the run ended before pause ${i + 1}`);
+        await sleep(20);
+      }
+      const dap = new Dap(adapterFor(first + i));
+      await dap.request('initialize', { adapterID: 'gemdb', supportsInvalidatedEvent: true });
+      await dap.request('launch', {
+        gemdbPause: (__debugStarts[first + i] as { gemdbPause: string }).gemdbPause,
+      });
+      await dap.request('configurationDone');
+      try {
+        await drivers[i](dap);
+      } catch (e) {
+        failure ??= e;
+      } finally {
+        await dap.request('continue', { threadId: 1 });
+      }
+    }
+    const result = await running;
+    if (failure) throw failure;
+    return { result, sessions: __debugStarts.length - first };
+  } finally {
+    registration.dispose();
+  }
+}
+
+/** Run `source` in notebook `nb` with the debugger open at each pause. */
+const inCell = (
+  nb: SessionOwner,
+  source: string,
+  ...drivers: Array<(dap: Dap) => Promise<void>>
+): Promise<{ result: PyResult; sessions: number }> =>
+  atPauses(() => runPython(source, nb), ...drivers);
+
+/**
+ * Put notebook `nb` in the editor with these code cells, run in order (so the
+ * second reads `Cell [2]`), the way VS Code holds an open notebook. Answers
+ * how to close it.
+ */
+function showNotebook(nb: SessionOwner, cells: string[]): () => void {
+  const doc = {
+    uri: { toString: () => nb.key },
+    getCells: () =>
+      cells.map((text, index) => ({
+        index,
+        kind: NotebookCellKind.Code,
+        document: { uri: { toString: () => `${nb.key}#cell${index}` }, getText: () => text },
+        executionSummary: { executionOrder: index + 1 },
+      })),
+  };
+  workspace.notebookDocuments.push(doc);
+  return () => {
+    workspace.notebookDocuments.splice(workspace.notebookDocuments.indexOf(doc), 1);
+  };
+}
+
+/** A cell that pauses once, in a function with no locals. */
+const PAUSE_ONCE = 'def go():\n    breakpoint()\ngo()';
+
+/** Text in an error that only GemDB's own machinery could have put there. */
+const MACHINERY =
+  /ModuleAst|SymbolDictionary|___gemdb|evaluateSource|GsProcess|AbstractException|SessionTemps/;
+
+describe.skipIf(!haveExtent || !canMakeFixture())('the Debug Console at a pause', () => {
+  it('answers an expression with its repr and type, and a result that opens like a Variables row', async () => {
+    const nb = notebook('dc-values');
+    const seen: Record<string, Evaluated> = {};
+    let kids: string[] = [];
+    let localRow = '';
+    let pageOfBig: string[] = [];
+
+    await inCell(
+      nb,
+      [
+        'class P:',
+        '    def __init__(self, name):',
+        '        self.name = name',
+        '        self.tags = {"a", "b"}',
+        '    def __repr__(self):',
+        '        return f"P({self.name!r})"',
+        'def go(p):',
+        '    breakpoint()',
+        '    return p.name',
+        'go(P("ann"))',
+      ].join('\n'),
+      async (dap) => {
+        seen.p = await dap.evaluate('p');
+        kids = (await dap.children(seen.p.ref)).map((v) => v.name).sort();
+        seen.watch = await dap.evaluate('p', { context: 'watch' });
+        localRow = (await dap.locals()).find((v) => v.name === 'p')!.value;
+        seen.none = await dap.evaluate('None');
+        seen.big = await dap.evaluate('list(range(1000))');
+        pageOfBig = (
+          (
+            await dap.request('variables', {
+              variablesReference: seen.big.ref,
+              start: 998,
+              count: 2,
+            })
+          ).body?.variables as Array<{ value: string }>
+        ).map((v) => v.value);
+      },
+    );
+    closeSessionFor(nb.key);
+
+    // The console prints the repr, as debugpy and PyCharm do: no type badge.
+    expect(seen.p).toMatchObject({ ok: true, result: "P('ann')", type: 'P' });
+    expect(seen.p.ref).toBeGreaterThan(0);
+    // Opened as a Variables row is: its data, with its dunders folded into a group.
+    expect(kids).toEqual(['name', 'special variables', 'tags']);
+    // A watch is a row, so it reads as the Variables row for the same object does.
+    expect(seen.watch).toMatchObject({ ok: true, result: localRow });
+    expect(seen.none).toMatchObject({ ok: true, result: '', ref: 0 });
+    expect(seen.big.indexed).toBe(1000);
+    expect(pageOfBig).toEqual(['{int} 998', '{int} 999']);
+  });
+
+  it('keeps names typed in the console for the rest of the pause, and only that long', async () => {
+    const nb = notebook('dc-names');
+    const first: Record<string, string> = {};
+    let afterResume = '';
+
+    await inCell(
+      nb,
+      [
+        'def go():',
+        '    n = 1',
+        '    breakpoint()',
+        '    breakpoint()',
+        '    return n',
+        'go()',
+      ].join('\n'),
+      async (dap) => {
+        first.assign = await dap.value('y = 5');
+        first.y = await dap.value('y + 1');
+        first.import = await dap.value('import json');
+        first.json = await dap.value('json.dumps([n, y])');
+        first.def = await dap.value('def twice(v):\n    return v * 2');
+        first.call = await dap.value('twice(y)');
+        first.block = await dap.value('total = 0\nfor i in range(4):\n    total += i\ntotal');
+        first.rebind = await dap.value('n = 99');
+        first.n = await dap.value('n');
+      },
+      async (dap) => {
+        afterResume = await dap.raises('y');
+      },
+    );
+    closeSessionFor(nb.key);
+
+    expect(first).toEqual({
+      assign: '',
+      y: '6',
+      import: '',
+      json: "'[1, 5]'",
+      def: '',
+      call: '10',
+      block: '6',
+      rebind: '',
+      n: '99',
+    });
+    expect(afterResume).toBe("NameError: name 'y' is not defined");
+  });
+
+  it.todo(
+    'writes a local rebound in the console (n = 99) back into the paused frame, as debugpy does — not decided yet',
+  );
+
+  it('sends what a line prints to the console as stdout, not to the cell, even when the line then fails', async () => {
+    const nb = notebook('dc-print');
+    const cellPrinted: string[] = [];
+    const seen: Record<string, Evaluated> = {};
+
+    await atPauses(
+      () =>
+        runPython('def go(p):\n    breakpoint()\ngo("x")', nb, (chunk) => cellPrinted.push(chunk)),
+      async (dap) => {
+        seen.print = await dap.evaluate('print("hello", p)');
+        seen.thenFail = await dap.evaluate('print("first")\n1/0');
+      },
+    );
+    closeSessionFor(nb.key);
+
+    expect(seen.print).toMatchObject({ ok: true, result: '', printed: 'hello x\n' });
+    expect(seen.print.categories).toEqual(['stdout']);
+    expect(seen.thenFail).toMatchObject({ ok: false, printed: 'first\n' });
+    expect(cellPrinted.join('')).toBe('');
+  });
+
+  it('finds names as the paused line would: locals, closed-over names, the notebook, its imports, builtins', async () => {
+    const nb = notebook('dc-scope');
+    await runPython('import math', nb);
+    const inner: Record<string, string> = {};
+    const outer: Record<string, string> = {};
+    let top = '';
+    let frameNames: string[] = [];
+
+    await inCell(
+      nb,
+      [
+        'nb_global = 10',
+        'def outer():',
+        '    captured = "c"',
+        '    def inner(k):',
+        '        seen = captured',
+        '        breakpoint()',
+        '        return seen',
+        '    return inner(3)',
+        'outer()',
+      ].join('\n'),
+      async (dap) => {
+        frameNames = (await dap.frames()).map((f) => f.name);
+        inner.local = await dap.value('k');
+        inner.closedOver = await dap.value('captured');
+        inner.global = await dap.value('nb_global');
+        inner.earlierImport = await dap.value('math.pi');
+        inner.builtin = await dap.value('len([k, k])');
+        inner.isinstance = await dap.value('isinstance(k, int)');
+        inner.comprehension = await dap.value('[k for _ in range(2)]');
+        inner.lambda = await dap.value('(lambda: k + 1)()');
+        inner.generator = await dap.value('sum(k for _ in range(2))');
+        outer.local = await dap.value('captured', 2);
+        outer.notHere = await dap.raises('k', 2);
+        top = await dap.value('nb_global', 3);
+      },
+    );
+    closeSessionFor(nb.key);
+
+    expect(frameNames[0]).toMatch(/inner$/);
+    expect(frameNames.slice(1, 3)).toEqual(['outer', '<module>']);
+    expect(inner).toEqual({
+      local: '3',
+      closedOver: "'c'",
+      global: '10',
+      earlierImport: '3.141592653589793',
+      builtin: '2',
+      isinstance: 'True',
+      // One scope, not locals over globals as two dicts: debugpy's comprehension trap.
+      comprehension: '[3, 3]',
+      lambda: '4',
+      generator: '6',
+    });
+    // Each frame its own: the selected frame decides.
+    expect(outer).toEqual({ local: "'c'", notHere: "NameError: name 'k' is not defined" });
+    expect(top).toBe('10');
+  });
+
+  const ACCOUNT = [
+    'class Account:',
+    '    rate = 2',
+    '    def __init__(self):',
+    '        self.balance = 7',
+    '    def show(self):',
+    '        breakpoint()',
+    '    @classmethod',
+    '    def make(cls):',
+    '        breakpoint()',
+    '        return cls()',
+  ].join('\n');
+
+  it('binds self in a method', async () => {
+    const nb = notebook('dc-self');
+    const seen: Record<string, string> = {};
+
+    await inCell(nb, `${ACCOUNT}\nAccount().show()`, async (dap) => {
+      seen.balance = await dap.value('self.balance');
+      seen.both = await dap.value('self.rate * self.balance');
+    });
+    closeSessionFor(nb.key);
+
+    expect(seen).toEqual({ balance: '7', both: '14' });
+  });
+
+  // Fails today, in Grail rather than here: a classmethod's frame carries no
+  // `cls` in its locals (Grail's PyFrame ___receiverNameForMethod___ answers
+  // nil for it), so the Locals pane shows none and the console has none to
+  // copy. When this starts passing, drop `.fails`.
+  it.fails('binds cls in a classmethod', async () => {
+    const nb = notebook('dc-cls');
+    const seen: Record<string, string> = {};
+
+    await inCell(nb, `${ACCOUNT}\nAccount.make()`, async (dap) => {
+      seen.rate = await dap.value('cls.rate');
+      seen.name = await dap.value('cls.__name__');
+    });
+    closeSessionFor(nb.key);
+
+    expect(seen).toEqual({ rate: '2', name: "'Account'" });
+  });
+
+  it('gives a frame in an imported module that module’s globals, not the notebook’s', async () => {
+    const nb = notebook('dc-module');
+    await runPython(importDcmod(), nb);
+    const inModule: Record<string, string> = {};
+    const inCellFrame: Record<string, string> = {};
+
+    await inCell(nb, 'shared = "notebook"\nnb_only = 1\ndcmod.in_module(5)', async (dap) => {
+      inModule.own = await dap.value('MODULE_ONLY');
+      inModule.shared = await dap.value('shared');
+      inModule.arg = await dap.value('arg');
+      inModule.notebookOnly = await dap.raises('nb_only');
+      inCellFrame.shared = await dap.value('shared', 2);
+      inCellFrame.notebookOnly = await dap.value('nb_only', 2);
+    });
+    closeSessionFor(nb.key);
+
+    expect(inModule).toEqual({
+      own: "'mod'",
+      shared: "'module'",
+      arg: '5',
+      notebookOnly: "NameError: name 'nb_only' is not defined",
+    });
+    expect(inCellFrame).toEqual({ shared: "'notebook'", notebookOnly: '1' });
+  });
+
+  it('gives a .py run’s frames that run’s __main__ globals', async () => {
+    const file = path.join(fixture!.root, 'dcjob.py');
+    fs.writeFileSync(
+      file,
+      ['total = 10', 'def step(n):', '    breakpoint()', '    return n', 'step(3)'].join('\n'),
+    );
+    const owner = fileOwner(file);
+    const seen: Record<string, string> = {};
+
+    await atPauses(
+      () => runPythonFile(file, owner, () => {}),
+      async (dap) => {
+        seen.sum = await dap.value('total + n');
+        seen.name = await dap.value('__name__');
+      },
+    );
+    closeSessionFor(owner.key);
+
+    expect(seen).toEqual({ sum: '13', name: "'__main__'" });
+  });
+
+  it('shows an error as a Jupyter traceback: the console’s lines, then each frame it went through', async () => {
+    const nb = notebook('dc-errors');
+    const cells = [importDcmod(), 'def boom(d):\n    return 10 / d', PAUSE_ONCE];
+    // Open, as it is in the editor: a cell's frame shows that cell's lines.
+    const close = showNotebook(nb, cells);
+    await runPython(cells[0], nb);
+    await runPython(cells[1], nb);
+    const seen: Record<string, Evaluated> = {};
+    const last: Record<string, string> = {};
+    let after = '';
+
+    await inCell(nb, cells[2], async (dap) => {
+      seen.here = await dap.evaluate('x = 1\n1/0');
+      seen.called = await dap.evaluate('boom(0)');
+      seen.module = await dap.evaluate('dcmod.fail()');
+      last.name = await dap.raises('nope');
+      seen.syntax = await dap.evaluate('1 +');
+      after = await dap.value('6 * 7');
+    }).finally(close);
+    closeSessionFor(nb.key);
+
+    // As a notebook cell's error reads in Jupyter:
+    //   -----------------------------------------------------------------
+    //   ZeroDivisionError                 Traceback (most recent call last)
+    //   <where>, line 2
+    //         1 x = 1
+    //   ----> 2 1/0
+    //
+    //   ZeroDivisionError: division by zero
+    const here = seen.here.lines;
+    expect(seen.here.ok).toBe(false);
+    expect(here[0]).toMatch(/^-{40,}$/);
+    expect(here[1]).toMatch(/^ZeroDivisionError\s+Traceback \(most recent call last\)$/);
+    expect(here.some((l) => /line 2\b/.test(l))).toBe(true);
+    expect(here).toContainEqual(expect.stringMatching(/^\s+1 x = 1$/));
+    expect(here).toContainEqual(expect.stringMatching(/^----> 2 1\/0$/));
+    expect(here[here.length - 1]).toBe('ZeroDivisionError: division by zero');
+
+    // A function the console called: its own frame, after the console's, with its line marked.
+    const called = seen.called.lines;
+    const consoleFrame = called.findIndex((l) => /^----> 1 boom\(0\)$/.test(l));
+    const boomFrame = called.findIndex((l) => /^Cell \[2\], line 2, in boom$/.test(l));
+    expect(consoleFrame).toBeGreaterThan(0);
+    expect(boomFrame).toBeGreaterThan(consoleFrame);
+    expect(called).toContainEqual(expect.stringMatching(/^----> 2\s+return 10 \/ d$/));
+    expect(called[called.length - 1]).toBe('ZeroDivisionError: division by zero');
+
+    // A frame in a .py module is named by its file.
+    const mod = seen.module.lines;
+    expect(mod.some((l) => l.includes('dcmod.py') && /\bin fail\b/.test(l))).toBe(true);
+    expect(mod).toContainEqual(expect.stringMatching(/^----> 9\s+return \{\}\["missing"\]$/));
+    expect(mod[mod.length - 1]).toBe("KeyError: 'missing'");
+
+    expect(last.name).toBe("NameError: name 'nope' is not defined");
+    // A SyntaxError shows the line it could not read, as Jupyter does.
+    expect(seen.syntax.ok).toBe(false);
+    expect(seen.syntax.lines).toContainEqual(expect.stringMatching(/^\s*1 \+$/));
+    expect(seen.syntax.lines[seen.syntax.lines.length - 1]).toBe('SyntaxError: invalid syntax');
+
+    // Nothing of GemDB's own evaluation shows through.
+    for (const e of [seen.here, seen.called, seen.module, seen.syntax]) {
+      expect(e.message).not.toMatch(MACHINERY);
+    }
+    // And an error costs nothing: the pause goes on answering.
+    expect(after).toBe('42');
+  });
+
+  it('lets a console line run past the two seconds a Variables row gets, but not a watch', async () => {
+    const nb = notebook('dc-time');
+    const seen: Record<string, Evaluated> = {};
+
+    await inCell(nb, PAUSE_ONCE, async (dap) => {
+      seen.slow = await dap.evaluate('import time\ntime.sleep(3)\n"slept"');
+      seen.watch = await dap.evaluate('__import__("time").sleep(10) or "slept"', {
+        context: 'watch',
+      });
+      seen.after = await dap.evaluate('1 + 1');
+    });
+    closeSessionFor(nb.key);
+
+    expect(seen.slow).toMatchObject({ ok: true, result: "'slept'" });
+    expect(seen.slow.millis).toBeGreaterThanOrEqual(3_000);
+    expect(seen.watch.ok).toBe(false);
+    expect(seen.watch.message).toMatch(/too long/i);
+    expect(seen.watch.millis).toBeLessThan(8_000);
+    expect(seen.after).toMatchObject({ ok: true, result: '2' });
+  });
+
+  it('stops a runaway line on cancel, and the pause goes on answering', async () => {
+    const nb = notebook('dc-cancel');
+    let stopped: Evaluated | undefined;
+    let after = '';
+
+    const { result } = await inCell(nb, `${PAUSE_ONCE}\n"finished"`, async (dap) => {
+      const from = dap.sent.length;
+      const began = Date.now();
+      const spin = dap.start('evaluate', { expression: 'while True:\n    pass', context: 'repl' });
+      await sleep(500);
+      await dap.request('cancel', { requestId: spin.seq });
+      stopped = dap.read(await spin.done, from, began);
+      after = await dap.value('2 + 2');
+    });
+    closeSessionFor(nb.key);
+
+    expect(stopped).toMatchObject({ ok: false });
+    expect(stopped!.message).toMatch(/interrupted|cancelled/i);
+    expect(stopped!.message).not.toMatch(/Traceback/);
+    expect(stopped!.millis).toBeLessThan(10_000);
+    expect(after).toBe('4');
+    expect(result.value).toBe("'finished'");
+  });
+
+  it('runs straight past breakpoint() and red dots in code the console calls', async () => {
+    const nb = notebook('dc-dots');
+    await runPython(importDcmod(), nb);
+    const seen: Record<string, string> = {};
+    debug.breakpoints = [
+      new SourceBreakpoint({
+        uri: { scheme: 'file', fsPath: path.join(fixture!.root, 'dcmod.py') },
+        range: { start: { line: DOTTED_LINE - 1 } },
+      }),
+    ];
+
+    let sessions = 0;
+    try {
+      ({ sessions } = await inCell(
+        nb,
+        [
+          'def helper():',
+          '    breakpoint()',
+          '    return "h"',
+          'def go():',
+          '    breakpoint()',
+          'go()',
+        ].join('\n'),
+        async (dap) => {
+          seen.breakpoint = await dap.value('helper()');
+          seen.dot = await dap.value('dcmod.dotted()');
+        },
+      ));
+    } finally {
+      debug.breakpoints = [];
+    }
+    closeSessionFor(nb.key);
+
+    expect(seen).toEqual({ breakpoint: "'h'", dot: '42' });
+    // The one pause the cell made; none from the console's calls.
+    expect(sessions).toBe(1);
+  });
+
+  it('tells VS Code to read the variables again, so a change made in the console shows', async () => {
+    const nb = notebook('dc-invalidate');
+    let change: Evaluated | undefined;
+    let watched: Evaluated | undefined;
+    let x = '';
+
+    await inCell(
+      nb,
+      [
+        'class Box:',
+        '    def __init__(self):',
+        '        self.x = 1',
+        'def go(b):',
+        '    breakpoint()',
+        'go(Box())',
+      ].join('\n'),
+      async (dap) => {
+        change = await dap.evaluate('b.x = 10');
+        watched = await dap.evaluate('b.x', { context: 'watch' });
+        const box = (await dap.locals()).find((v) => v.name === 'b')!;
+        x = (await dap.children(box.variablesReference)).find((v) => v.name === 'x')!.value;
+      },
+    );
+    closeSessionFor(nb.key);
+
+    expect(change).toMatchObject({ ok: true, invalidated: true });
+    // A watch is a row, so it reads as one, type badge and all.
+    expect(watched).toMatchObject({ ok: true, result: '{int} 10', invalidated: false });
+    expect(x).toBe('{int} 10');
+  });
+
+  it('puts a change to a persistent object made in the console in the notebook’s transaction', async () => {
+    const nb = notebook('dc-transaction');
+
+    await inCell(nb, PAUSE_ONCE, async (dap) => {
+      await dap.value('import gemdb\ngemdb.root["dc_console"] = 1');
+    });
+    const session = sessionForIfOpen(nb.key)!;
+    const dirty = await session.executeAsync(needsCommitQuery());
+    await session.executeAsync(abortQuery());
+    closeSessionFor(nb.key);
+
+    // As the same line in a cell would: the notebook's next commit writes it.
+    expect(dirty).toBe('true');
+  });
+  it('puts a Variables row in the Debug Console, and evaluates with self bound to it', async () => {
+    const nb = notebook('dc-row');
+    const seen: Record<string, unknown> = {};
+
+    await inCell(
+      nb,
+      [
+        'class Box:',
+        '    def __init__(self, n):',
+        '        self.x = n',
+        '        self.items = [n, n]',
+        '    def look(self, other, big):',
+        '        breakpoint()',
+        'Box(1).look(Box(5), list(range(1000)))',
+      ].join('\n'),
+      async (dap) => {
+        const outputs = async (args: Record<string, unknown>) => {
+          const from = dap.sent.length;
+          const reply = await dap.request('gemdbShowRow', args);
+          return {
+            ok: reply.success,
+            out: dap.sent
+              .slice(from)
+              .filter((m) => m.event === 'output')
+              .map(
+                (m) => m.body as { category: string; output: string; variablesReference?: number },
+              ),
+          };
+        };
+        const other = (await dap.locals()).find((v) => v.name === 'other')!;
+        const shown = await outputs({ handle: other.variablesReference, name: 'other' });
+        seen.shown = shown;
+        // Everything shown is listed from one reference, so it all reads alike.
+        const listed = async (shownRows: { out: Array<{ variablesReference?: number }> }) =>
+          dap.children(shownRows.out.find((o) => o.variablesReference)?.variablesReference ?? 0);
+        // An object: a line naming it, then its attributes, each with its name.
+        const rows = await listed(shown);
+        seen.rows = rows.map((v) => v.value);
+        const items = rows.find((v) => v.value.startsWith('items'))!;
+        seen.items = (await dap.children(items.variablesReference)).map((v) => v.value);
+        // A list: one closed row, which opens like the Variables row.
+        const big = await listed(
+          await outputs({
+            handle: (await dap.locals()).find((v) => v.name === 'big')!.variablesReference,
+            name: 'big',
+          }),
+        );
+        seen.big = big.map((v) => v.value);
+        seen.bigOpened = (
+          await dap.request('variables', {
+            variablesReference: big[0].variablesReference,
+            start: 998,
+            count: 2,
+          })
+        ).body?.variables;
+        const withSelf = await outputs({
+          handle: other.variablesReference,
+          name: 'other',
+          expression: 'self.x * 10',
+          frameId: 1,
+        });
+        seen.echo = withSelf.out[0];
+        seen.withSelf = (await listed(withSelf)).map((v) => v.value);
+        // What Show leaves at the prompt: a Locals row's own name, which means
+        // it there; for a nested row, `_`, bound to it.
+        seen.typedLocal = (
+          await dap.request('gemdbShowRow', {
+            handle: other.variablesReference,
+            name: 'other',
+            frameId: 1,
+          })
+        ).body?.typed;
+        seen.typedNested = (
+          await dap.request('gemdbShowRow', {
+            handle: items.variablesReference,
+            name: 'items',
+            frameId: 1,
+          })
+        ).body?.typed;
+        seen.underscore = await dap.value('_', 1);
+        // The frame's own self is still the Box it was: the binding was for that line alone.
+        seen.frameSelf = await dap.value('self.x');
+        const scopes = (await dap.request('scopes', { frameId: 2 })).body?.scopes as Array<{
+          name: string;
+          variablesReference: number;
+        }>;
+        const groups = await dap.children(
+          scopes.find((sc) => sc.name === 'Globals')!.variablesReference,
+        );
+        const group = groups.find((v) => v.name === 'class variables')!;
+        seen.group = await outputs({ handle: group.variablesReference, name: 'class variables' });
+      },
+    );
+    closeSessionFor(nb.key);
+
+    expect(seen.shown).toMatchObject({ ok: true, out: [{ category: 'console', output: '' }] });
+    // Its data in name order, as Variables lists it, without the folded groups.
+    expect(seen.rows).toEqual([expect.stringMatching(/^other: .*Box/), 'items: [5, 5]', 'x: 5']);
+    expect(seen.items).toEqual(['{int} 5', '{int} 5']);
+    expect(seen.big).toEqual(['big: list with 1000 items']);
+    expect(seen.bigOpened).toEqual([
+      expect.objectContaining({ name: '[998]', value: '{int} 998' }),
+      expect.objectContaining({ name: '[999]', value: '{int} 999' }),
+    ]);
+    expect(seen.echo).toEqual({
+      category: 'console',
+      output: '>>> self.x * 10  # self is other\n',
+    });
+    expect(seen.withSelf).toEqual(['50']);
+    expect(seen.frameSelf).toBe('1');
+    expect(seen.typedLocal).toBe('other');
+    expect(seen.typedNested).toBe('_');
+    expect(seen.underscore).toBe('[5, 5]');
+    expect(seen.group).toMatchObject({
+      ok: true,
+      out: [{ category: 'stderr', output: expect.stringMatching(/not an object of its own/) }],
+    });
+  });
+  it('runs GemDB’s % commands: %persist, %names, %commit, and completes them', async () => {
+    const nb = notebook('dc-commands');
+    const seen: Record<string, unknown> = {};
+
+    await inCell(
+      nb,
+      [
+        'class Item:',
+        '    def __init__(self, sku, qty):',
+        '        self.sku, self.qty = sku, qty',
+        'def go(items):',
+        '    breakpoint()',
+        'go([Item("B400", "2"), Item("A200", 1)])',
+      ].join('\n'),
+      async (dap) => {
+        await dap.value('p = [(i.sku, i.qty, type(i.qty).__name__) for i in items]');
+        const said = async (line: string) => {
+          const from = dap.sent.length;
+          const r = await dap.evaluate(line);
+          return {
+            ok: r.ok,
+            message: r.message,
+            text: dap.sent
+              .slice(from)
+              .filter((m) => m.event === 'output')
+              .map((m) => String(m.body?.output ?? ''))
+              .join(''),
+          };
+        };
+        seen.persist = await said('%persist p');
+        seen.persistAs = await said('%persist items[0] as first_item');
+        seen.noKey = await said('%persist items[0]');
+        seen.names = await said('%names');
+        // As Persisted Objects copies it: the program never imported gemdb, and it still works.
+        seen.inRoot = await dap.value('gemdb.root["p"]');
+        const complete = async (text: string) =>
+          (
+            (await dap.request('completions', { text, column: text.length + 1, frameId: 1 })).body
+              ?.targets as Array<{ label: string }>
+          ).map((t) => t.label);
+        seen.completeCommands = await complete('%');
+        seen.completeNames = await complete('%persist ');
+        seen.commit = await said('%commit');
+      },
+    );
+    // Committed: another session sees it.
+    seen.elsewhere = await executeAsync(
+      `System abortTransaction. ((System myUserProfile symbolList objectNamed: #'ModuleAst') evaluateSource: 'import gemdb\n(gemdb.root["p"], gemdb.root["first_item"].sku)' usingModuleScope: SymbolDictionary new) printString encodeAsUTF8`,
+    );
+    closeSessionFor(nb.key);
+
+    expect(seen.persist).toMatchObject({
+      ok: true,
+      text: expect.stringMatching(
+        /^Added p to Persisted Objects as gemdb.root\["p"\]\. It is saved when dc-commands\.ipynb commits/,
+      ),
+    });
+    expect(seen.persistAs).toMatchObject({
+      ok: true,
+      text: expect.stringContaining('gemdb.root["first_item"]'),
+    });
+    expect(seen.noKey).toMatchObject({
+      ok: false,
+      message: 'Give it a key: %persist items[0] as some_key',
+    });
+    expect(seen.names).toMatchObject({
+      ok: true,
+      text: "p: list = [('B400', '2', 'str'), ('A200', 1, 'int')]\n",
+    });
+    expect(seen.inRoot).toBe("[('B400', '2', 'str'), ('A200', 1, 'int')]");
+    expect(seen.completeCommands).toEqual(['%persist', '%commit', '%names', '%help']);
+    expect(seen.completeNames).toEqual(['p']);
+    expect(seen.commit).toMatchObject({
+      ok: true,
+      text: expect.stringMatching(/^Committed dc-commands\.ipynb/),
+    });
+    expect(seen.elsewhere).toContain("'B400'");
+  });
+  it('makes what Persisted Objects holds available by its key at a later pause', async () => {
+    const nb = notebook('dc-persisted-names');
+    // Persisted earlier, as %persist would leave it after %commit.
+    await runPython(
+      'import gemdb\ngemdb.root["kept"] = [1, 2]\ngemdb.root["n"] = "persisted n"\ngemdb.root["list"] = "not the builtin"\ngemdb.root["two words"] = 2\ngemdb.commit()',
+      nb,
+    );
+    const seen: Record<string, unknown> = {};
+
+    await inCell(nb, 'def go(n):\n    breakpoint()\ngo("the local n")', async (dap) => {
+      seen.kept = await dap.value('kept');
+      // Said above a persisted value; nothing said for the paused code's own name.
+      seen.keptSaid = (await dap.evaluate('kept')).printed;
+      seen.nSaid = (await dap.evaluate('n')).printed;
+      await dap.value('kept2 = kept');
+      seen.rebound = (await dap.evaluate('kept2')).printed;
+      // Rebind kept in the console: persisted.kept still reaches the persisted one.
+      await dap.value('kept = "mine now"');
+      seen.keptMine = await dap.value('kept');
+      seen.persistedKept = await dap.value('persisted.kept');
+      seen.persistedN = await dap.value('persisted.n');
+      seen.persistedList = await dap.value('persisted');
+      seen.persistedNope = await dap.raises('persisted.nope');
+      const complete = async (text: string) =>
+        (
+          (await dap.request('completions', { text, column: text.length + 1, frameId: 1 })).body
+            ?.targets as Array<{ label: string }>
+        ).map((t) => t.label);
+      seen.typingKe = await complete('ke');
+      seen.afterDot = await complete('persisted.k');
+      // The frame's own name wins over a persisted one of the same name.
+      seen.n = await dap.value('n');
+      // A builtin is never hidden.
+      seen.list = await dap.value('list((1, 2))');
+      seen.names = (await dap.evaluate('%names')).printed;
+    });
+    closeSessionFor(nb.key);
+
+    expect(seen).toEqual({
+      kept: '[1, 2]',
+      keptSaid: 'kept is gemdb.root["kept"], from Persisted Objects (also persisted.kept)\n',
+      keptMine: "'mine now'",
+      persistedKept: '[1, 2]',
+      persistedN: "'persisted n'",
+      // Earlier tests in this file commit their own entries too.
+      persistedList: expect.stringMatching(
+        /^Persisted Objects: (.*, )?kept, list, n, (.*, )?two words$/,
+      ),
+      persistedNope: "AttributeError: Persisted Objects has no 'nope'",
+      // Found by typing: the persisted entry offered while its name is typed, and after persisted.
+      typingKe: ['persisted.kept'],
+      afterDot: ['kept'],
+      nSaid: '',
+      // A name the user bound is theirs: nothing said.
+      rebound: '',
+      n: "'the local n'",
+      list: '[1, 2]',
+      // Persisted names are there to use, not names the user bound here: only kept2 is.
+      names: 'kept2: list = [1, 2]\n',
+    });
+  });
+});
+
+describe.skipIf(!haveExtent || !canMakeFixture())('the Debug Console on a saved stack', () => {
+  it('evaluates, binds names and changes a stack opened again, and commits only on %commit', async () => {
+    const nb = notebook('dc-saved-stack');
+    const other = notebook('dc-saved-stack-other');
+    const cell = [
+      'class Employee:',
+      '    def __init__(self, name, reports=()):',
+      '        self.name = name',
+      '        self.reports = list(reports)',
+      '    def find(self, name, depth=0):',
+      '        if self.name == name:',
+      '            breakpoint()',
+      '            return self',
+      '        for r in self.reports:',
+      '            found = r.find(name, depth + 1)',
+      '            if found:',
+      '                return found',
+      '        return None',
+      'ceo = Employee("Ada", [Employee("Grace", [Employee("Barbara")])])',
+      'ceo.find("Barbara")',
+    ].join('\n');
+    // Saved at the pause as Add Stack does, then committed by the notebook.
+    setHaltHandler(async (request) => {
+      const { frames } = parsePausedStack(
+        await request.query(pausedStackQuery(request.process, nb.key)),
+      );
+      const savedFrames: SavedFrame[] = frames.map((f) => ({
+        name: f.name,
+        line: f.line,
+        column: f.column + 1,
+        end_column: null,
+        source_name: 'Cell [1]',
+        path: 'vscode-notebook-cell:/gone/dc-saved-stack.ipynb#W0',
+        text: cell,
+      }));
+      await request.query(
+        saveStackQuery(
+          'stack_dc',
+          { label: 'dc-saved-stack.ipynb', notebook: nb.key, saved_at: 'today', description: null },
+          savedFrames,
+          frames.map((f) => f.locals ?? 0),
+          nb.key,
+        ),
+      );
+      return 'continue';
+    });
+    try {
+      await runPython(cell, nb);
+    } finally {
+      setHaltHandler(undefined);
+    }
+    await sessionForIfOpen(nb.key)!.executeAsync(commitQuery());
+    closeSessionFor(nb.key);
+
+    // Opened again, as Restore a Saved Stack does: in a session of its own.
+    const open = async () => {
+      const owner = stackOwner('stack_dc');
+      const query = stackQuery(owner);
+      const opened = parseOpenedStack(await query(openStackQuery('stack_dc'), { budget: false }));
+      const { consoles } = restoredFrames(opened.meta, opened.locals, opened.globals, {
+        fileExists: () => false,
+        openCellLines: () => undefined,
+      });
+      const con = await savedStackConsole(query, owner.key, consoles);
+      const line = async (source: string) => {
+        const answer = await con.evaluate!(source, 1, 'repl', new AbortController().signal);
+        return answer.kind === 'value'
+          ? { value: answer.value, printed: answer.output }
+          : {
+              value: answer.kind === 'error' ? answer.traceback : 'interrupted',
+              printed: answer.output,
+            };
+      };
+      return { owner, query, opened, con, line };
+    };
+    const elsewhere = async () =>
+      (
+        await runPython(
+          'import gemdb\ngemdb.abort()\ngemdb.root["stack_dc"]["frames"][0]["locals"]["self"].name',
+          other,
+        )
+      ).value;
+    const { owner, query, opened, con, line } = await open();
+    const seen: Record<string, unknown> = {};
+    // Plain reads, the first line of each frame among them: nothing to commit, nothing said.
+    seen.name = await line('self.name');
+    seen.local = await line('depth + 1');
+    seen.global = await line('ceo.name');
+    seen.method = await line('self.find("Barbara") is self');
+    seen.bind = await line('typed_here = 5');
+    seen.useBound = await line('typed_here + 1');
+    seen.names = (await con.consoleNames!(1)).map((v) => v.name);
+    seen.error = (await line('nope')).value;
+    // A change to a saved object: kept, and not committed.
+    seen.write = await line('self.name = "Changed"');
+    seen.afterWrite = await line('self.name');
+    seen.writeAgain = await line('self.name = "Changed again"');
+    seen.beforeCommit = await elsewhere();
+    // A Variables row, as Show in Debug Console and Evaluate with self… reach it.
+    const rows = parseChildren(await query(childrenQuery(opened.locals[0], 0, 500)));
+    const row = (name: string) => rows.find((r) => r.name === name)!;
+    const shown = await con.showRow!(row('name').handle, 'name');
+    seen.shown = shown.kind === 'value' ? shown.value : shown.kind;
+    const withSelf = await con.evaluate!(
+      'len(self.reports)',
+      1,
+      'repl',
+      new AbortController().signal,
+      row('self').handle,
+    );
+    seen.withSelf = withSelf.kind === 'value' ? withSelf.value : withSelf.kind;
+    seen.keys = (await con.persistedKeys!()).includes('stack_dc');
+    // %commit, as the adapter sends it: the saved stack now holds the change.
+    seen.committed = await query(commitQuery(), { budget: false });
+    seen.afterCommit = await elsewhere();
+    closeSessionFor(owner.key);
+    // Opened again and changed, then closed without a commit: the change is gone.
+    const again = await open();
+    seen.reopened = await again.line('self.name');
+    await again.line('self.name = "Never committed"');
+    closeSessionFor(again.owner.key);
+    seen.afterDiscard = await elsewhere();
+    closeSessionFor(other.key);
+
+    expect(seen).toEqual({
+      name: { value: "'Barbara'", printed: '' },
+      local: { value: '3', printed: '' },
+      global: { value: "'Ada'", printed: '' },
+      method: { value: 'True', printed: '' },
+      bind: { value: '', printed: '' },
+      useBound: { value: '6', printed: '' },
+      names: ['typed_here'],
+      error: expect.stringMatching(/NameError: name 'nope' is not defined/),
+      write: { value: '', printed: '' },
+      afterWrite: { value: "'Changed'", printed: '' },
+      writeAgain: { value: '', printed: '' },
+      beforeCommit: "'Barbara'",
+      // The frame's own argument `name`, which the change to self.name leaves alone.
+      shown: "'Barbara'",
+      withSelf: '0',
+      keys: true,
+      committed: "'committed'",
+      afterCommit: "'Changed again'",
+      reopened: { value: "'Changed again'", printed: '' },
+      afterDiscard: "'Changed again'",
+    });
+  });
+});
diff --git a/src/__mocks__/vscode.ts b/src/__mocks__/vscode.ts
index d88502f..c77bd82 100644
--- a/src/__mocks__/vscode.ts
+++ b/src/__mocks__/vscode.ts
@@ -255,18 +255,23 @@ export const window = {
   },
   /**
    * Progress is a pass-through here: run the callback and return its result.
-   * Nothing asserts on the notification itself — that is the editor's job,
-   * not ours — and the token never reports cancelled, since nothing here can
-   * drive one.
+   * The token never reports cancelled; a test that needs to cancel spies on
+   * this and hands over a token it can drive.
    */
   withProgress<T>(
     _options: unknown,
     task: (
       progress: { report: (value: { message?: string }) => void },
-      token: { isCancellationRequested: boolean },
+      token: {
+        isCancellationRequested: boolean;
+        onCancellationRequested: (listener: () => void) => { dispose(): void };
+      },
     ) => Thenable<T>,
   ): Thenable<T> {
-    return task({ report: () => {} }, { isCancellationRequested: false });
+    return task(
+      { report: () => {} },
+      { isCancellationRequested: false, onCancellationRequested: () => ({ dispose: () => {} }) },
+    );
   },
 };
 
@@ -416,11 +421,22 @@ export const debug = {
   },
   stopDebugging: (): Promise<void> => Promise.resolve(),
   activeDebugSession: undefined as { id: string; type: string } | undefined,
+  /** The frame selected in Call Stack; a test sets it to a `DebugStackFrame`. */
+  activeStackItem: undefined as unknown,
   /** The gutter's breakpoints; a test fills it with `SourceBreakpoint`s. */
   breakpoints: [] as unknown[],
 };
 
 /** A gutter breakpoint, with just the location shape red dots read. */
+/** A frame selected in Call Stack. */
+export class DebugStackFrame {
+  constructor(
+    readonly session: { id: string; type: string; name?: string; customRequest: unknown },
+    readonly threadId: number,
+    readonly frameId: number,
+  ) {}
+}
+
 export class SourceBreakpoint {
   constructor(
     readonly location: {
diff --git a/src/__tests__/consoleCommands.test.ts b/src/__tests__/consoleCommands.test.ts
new file mode 100644
index 0000000..d74bcf9
--- /dev/null
+++ b/src/__tests__/consoleCommands.test.ts
@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import {
+  CONSOLE_COMMANDS,
+  commandCompletions,
+  helpText,
+  isConsoleCommand,
+  parseConsoleCommand,
+  persistedCompletions,
+} from '../consoleCommands';
+
+/** GemDB's `%` commands in the Debug Console: reading a line, and what is suggested while typing one. */
+
+describe('reading a % line', () => {
+  it('takes only a line that starts with %, so Python is never mistaken for a command', () => {
+    expect(isConsoleCommand('%persist p')).toBe(true);
+    expect(isConsoleCommand('  %help')).toBe(true);
+    expect(isConsoleCommand('x % 3')).toBe(false);
+    expect(isConsoleCommand('help')).toBe(false);
+    expect(parseConsoleCommand('p = 1')).toBeUndefined();
+  });
+
+  it('persists a name under its own name, or under the key given after as', () => {
+    expect(parseConsoleCommand('%persist p')).toEqual({
+      kind: 'persist',
+      expression: 'p',
+      key: 'p',
+    });
+    expect(parseConsoleCommand('%persist p as qty_check')).toEqual({
+      kind: 'persist',
+      expression: 'p',
+      key: 'qty_check',
+    });
+    expect(parseConsoleCommand('%persist o.items[0] as "first item"')).toEqual({
+      kind: 'persist',
+      expression: 'o.items[0]',
+      key: 'first item',
+    });
+  });
+
+  it('asks for a key when what is persisted is not a plain name', () => {
+    expect(parseConsoleCommand('%persist o.items[0]')).toEqual({
+      kind: 'invalid',
+      message: 'Give it a key: %persist o.items[0] as some_key',
+    });
+    expect(parseConsoleCommand('%persist')).toMatchObject({ kind: 'invalid' });
+  });
+
+  it('reads the commands that take nothing, and refuses extra words after them', () => {
+    expect(parseConsoleCommand('%commit')).toEqual({ kind: 'commit' });
+    expect(parseConsoleCommand('%names')).toEqual({ kind: 'names' });
+    expect(parseConsoleCommand('%help')).toEqual({ kind: 'help' });
+    expect(parseConsoleCommand('%commit now')).toMatchObject({ kind: 'invalid' });
+  });
+
+  it('names the commands when it does not know the one typed', () => {
+    const unknown = parseConsoleCommand('%abort');
+    expect(unknown).toMatchObject({ kind: 'invalid' });
+    expect((unknown as { message: string }).message).toMatch(
+      /%abort is not a GemDB command\. Commands: %persist, %commit, %names, %help\./,
+    );
+  });
+});
+
+describe('%help', () => {
+  it('lists every command with how to type it and what it does', () => {
+    const text = helpText();
+    for (const c of CONSOLE_COMMANDS) {
+      expect(text).toContain(c.usage);
+      expect(text).toContain(c.summary);
+    }
+  });
+});
+
+describe('autocomplete', () => {
+  it('lists the commands when % is typed, each with what it does, replacing the % onwards', () => {
+    expect(commandCompletions('%', [])).toEqual(
+      CONSOLE_COMMANDS.map((c) => ({
+        label: c.name,
+        detail: c.summary,
+        type: 'keyword',
+        start: 1,
+        length: 1,
+      })),
+    );
+  });
+
+  it('narrows to the commands that match what is typed', () => {
+    expect(commandCompletions('%pe', []).map((c) => c.label)).toEqual(['%persist']);
+    expect(commandCompletions('  %c', [])).toEqual([
+      expect.objectContaining({ label: '%commit', start: 3, length: 2 }),
+    ]);
+  });
+
+  it('offers the console’s names after %persist', () => {
+    expect(commandCompletions('%persist ', ['bad', 'p'])).toEqual([
+      { label: 'bad', type: 'variable', start: 10, length: 0 },
+      { label: 'p', type: 'variable', start: 10, length: 0 },
+    ]);
+    expect(commandCompletions('%persist b', ['bad', 'p']).map((c) => c.label)).toEqual(['bad']);
+  });
+
+  it('suggests nothing for Python', () => {
+    expect(commandCompletions('len(', ['p'])).toEqual([]);
+    expect(commandCompletions('x % ', ['p'])).toEqual([]);
+  });
+});
+
+describe('autocomplete for Persisted Objects while Python is typed', () => {
+  const keys = ['entry', 'o', 'orders', 'two words'];
+
+  it('offers persisted.key for each persisted key the typed name starts, as the gemdb.root entry it is', () => {
+    expect(persistedCompletions('o', keys)).toEqual([
+      {
+        label: 'persisted.o',
+        detail: 'gemdb.root["o"] in Persisted Objects',
+        type: 'variable',
+        start: 1,
+        length: 1,
+      },
+      {
+        label: 'persisted.orders',
+        detail: 'gemdb.root["orders"] in Persisted Objects',
+        type: 'variable',
+        start: 1,
+        length: 1,
+      },
+    ]);
+  });
+
+  it('replaces only the name being typed, inside a longer line', () => {
+    expect(persistedCompletions('len(ent', keys)).toEqual([
+      expect.objectContaining({ label: 'persisted.entry', start: 5, length: 3 }),
+    ]);
+  });
+
+  it('offers the keys after persisted.', () => {
+    expect(persistedCompletions('persisted.', keys).map((c) => c.label)).toEqual([
+      'entry',
+      'o',
+      'orders',
+    ]);
+    expect(persistedCompletions('x = persisted.or', keys)).toEqual([
+      expect.objectContaining({ label: 'orders', start: 15, length: 2 }),
+    ]);
+  });
+
+  it('offers nothing after another dot, or for a key that is not a Python name', () => {
+    expect(persistedCompletions('order.o', keys)).toEqual([]);
+    expect(persistedCompletions('two', keys)).toEqual([]);
+    expect(persistedCompletions('len(', keys)).toEqual([]);
+  });
+});
diff --git a/src/__tests__/consoleReplies.test.ts b/src/__tests__/consoleReplies.test.ts
new file mode 100644
index 0000000..aeb668d
--- /dev/null
+++ b/src/__tests__/consoleReplies.test.ts
@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { parseConsoleNames, parseConsoleReply, parsePersistedKeys } from '../pauseVariables';
+
+/**
+ * The console queries' answers, read. The queries themselves run against a
+ * real database in `__integration__/debugConsole.test.ts`; this pins down the
+ * reading of each shape they answer in.
+ */
+
+const F = '\u001f';
+const R = '\u001e';
+const rec = (...fields: Array<string | number>): string => fields.join(F) + R;
+
+describe('reading a console line’s answer', () => {
+  it('reads a value: the row, what was printed, the console’s position, and a persisted name’s origin', () => {
+    const raw =
+      rec('value', 12, 'hi\r\n', 'persisted') +
+      rec('o', "Order(1013, 'katherine', 3/14)", 'Order', 40, 0, 3, 41, -1, 0, 'obj');
+
+    expect(parseConsoleReply(raw)).toEqual({
+      consoleRef: 12,
+      output: 'hi\n',
+      kind: 'value',
+      origin: 'persisted',
+      row: expect.objectContaining({
+        name: 'o',
+        value: "Order(1013, 'katherine', 3/14)",
+        type: 'Order',
+        ref: 40,
+        named: 3,
+        kind: 'obj',
+      }),
+    });
+  });
+
+  it('reads a value with no origin when the name is not a persisted one', () => {
+    const reply = parseConsoleReply(rec('value', 3, '', '') + rec('n', '1', 'int', 0, 0, 0, 9));
+
+    expect(reply).not.toHaveProperty('origin');
+  });
+
+  it('reads None or a statement, and an interrupted line', () => {
+    expect(parseConsoleReply(rec('none', 3, 'printed\n', ''))).toEqual({
+      consoleRef: 3,
+      output: 'printed\n',
+      kind: 'none',
+    });
+    expect(parseConsoleReply(rec('interrupted', 3, '', ''))).toMatchObject({ kind: 'interrupted' });
+  });
+
+  it('reads an error: its type and message, then each frame outermost first', () => {
+    const raw =
+      rec('error', 3, '', '') +
+      rec('ZeroDivisionError', 'division by zero') +
+      rec('<grail>', 1, '<module>', 'boom(0') +
+      rec('/w/mod.py', 2, 'boom', '    return 10 / ');
+
+    expect(parseConsoleReply(raw)).toEqual({
+      consoleRef: 3,
+      output: '',
+      kind: 'error',
+      error: {
+        type: 'ZeroDivisionError',
+        message: 'division by zero',
+        frames: [
+          { file: '<grail>', line: 1, name: '<module>', text: 'boom(0' },
+          { file: '/w/mod.py', line: 2, name: 'boom', text: '    return 10 / ' },
+        ],
+      },
+    });
+  });
+
+  it('reads a SyntaxError’s file, line, column and text', () => {
+    const raw =
+      rec('error', 3, '', '') + rec('SyntaxError', 'invalid syntax', '<string>', 1, 4, '1 +');
+
+    expect(parseConsoleReply(raw)).toMatchObject({
+      kind: 'error',
+      error: { syntax: { file: '<string>', line: 1, offset: 4, text: '1 +' }, frames: [] },
+    });
+  });
+
+  it('reads a stack overflow as an error', () => {
+    const raw = rec('stack', 3, '', '') + rec('RecursionError', 'maximum recursion depth exceeded');
+
+    expect(parseConsoleReply(raw)).toMatchObject({
+      kind: 'error',
+      error: { type: 'RecursionError' },
+    });
+  });
+
+  it('turns an Error: line from the query itself into a failure', () => {
+    expect(parseConsoleReply('Error: the pause is over')).toEqual({
+      consoleRef: 0,
+      output: '',
+      kind: 'failed',
+      message: 'the pause is over',
+    });
+  });
+});
+
+describe('reading the console’s names', () => {
+  it('reads its position and each name with its type and repr', () => {
+    const raw = `7${R}` + rec('p', 'list', '[1, 2]') + rec('_', 'int', '3');
+
+    expect(parseConsoleNames(raw)).toEqual({
+      consoleRef: 7,
+      names: [
+        { name: 'p', type: 'list', repr: '[1, 2]' },
+        { name: '_', type: 'int', repr: '3' },
+      ],
+    });
+  });
+
+  it('reads no names, and throws on an Error: line', () => {
+    expect(parseConsoleNames(`7${R}`)).toEqual({ consoleRef: 7, names: [] });
+    expect(() => parseConsoleNames('Error: the pause is over')).toThrow('the pause is over');
+  });
+});
+
+describe('reading Persisted Objects’ keys', () => {
+  it('splits the keys, and reads an empty answer as none', () => {
+    expect(parsePersistedKeys(`entry${F}o${F}two words`)).toEqual(['entry', 'o', 'two words']);
+    expect(parsePersistedKeys('')).toEqual([]);
+  });
+});
diff --git a/src/__tests__/consoleTraceback.test.ts b/src/__tests__/consoleTraceback.test.ts
new file mode 100644
index 0000000..7acb1b7
--- /dev/null
+++ b/src/__tests__/consoleTraceback.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest';
+import { PlacedFrame, jupyterTraceback } from '../consoleTraceback';
+import type { ConsoleError, TracebackFrame } from '../pauseVariables';
+
+/**
+ * A Debug Console error written as Jupyter writes one. Placing a frame — the
+ * console's input, a cell, a file — is the caller's (`debugger.ts`); here it
+ * is a stub, so the layout itself is what is tested.
+ */
+
+const CELL = ['def boom(d):', '    return 10 / d'];
+const FILE = Array.from({ length: 12 }, (_, i) => `line ${i + 1}`);
+
+/** The console's input is frame 0; a `<grail>` frame is the cell; anything else the file. */
+function placed(input: string[]) {
+  return (frame: TracebackFrame, index: number): PlacedFrame =>
+    index === 0
+      ? { label: 'Debug Console', isFile: false, lines: input }
+      : frame.file === '<grail>'
+        ? { label: 'Cell [2]', isFile: false, lines: CELL }
+        : { label: `File ${frame.file}`, isFile: true, lines: FILE };
+}
+
+const error = (frames: TracebackFrame[], more: Partial<ConsoleError> = {}): ConsoleError => ({
+  type: 'ZeroDivisionError',
+  message: 'division by zero',
+  frames,
+  ...more,
+});
+
+describe('a Jupyter-style traceback', () => {
+  it('heads it as Jupyter does, then each frame outermost first, then the error', () => {
+    const text = jupyterTraceback(
+      error([
+        { file: '<grail>', line: 1, name: '<module>', text: 'boom(0' },
+        { file: '<grail>', line: 2, name: 'boom', text: '    return 10 / ' },
+      ]),
+      placed(['boom(0)']),
+    );
+
+    expect(text.split('\n')).toEqual([
+      '-'.repeat(75),
+      'ZeroDivisionError                         Traceback (most recent call last)',
+      'Debug Console, line 1',
+      '----> 1 boom(0)',
+      '',
+      'Cell [2], line 2, in boom',
+      '      1 def boom(d):',
+      '----> 2     return 10 / d',
+      '',
+      'ZeroDivisionError: division by zero',
+    ]);
+  });
+
+  it('shows two lines either side of the one that raised, and keeps the gutter seven wide at two digits', () => {
+    const text = jupyterTraceback(
+      error([{ file: '/w/mod.py', line: 10, name: 'fail', text: '' }], {
+        type: 'KeyError',
+        message: "'missing'",
+      }),
+      (frame) => placed([])(frame, 1),
+    );
+
+    expect(text.split('\n').slice(2, 8)).toEqual([
+      'File /w/mod.py:10, in fail',
+      '      8 line 8',
+      '      9 line 9',
+      '---> 10 line 10',
+      '     11 line 11',
+      '     12 line 12',
+    ]);
+  });
+
+  it('falls back to the text Grail recorded when a frame’s source cannot be found', () => {
+    const text = jupyterTraceback(
+      error([{ file: '<grail>', line: 4, name: 'helper', text: '    return x / y\nmore' }]),
+      () => ({ label: 'Cell', isFile: false }),
+    );
+
+    expect(text.split('\n').slice(2, 4)).toEqual([
+      'Cell, line 4, in helper',
+      '----> 4     return x / y',
+    ]);
+  });
+
+  it('shows a SyntaxError’s line with a caret under where it could not read, and no frames', () => {
+    const text = jupyterTraceback(
+      error([], {
+        type: 'SyntaxError',
+        message: 'invalid syntax',
+        syntax: { file: '<string>', line: 1, offset: 4, text: '1 +' },
+      }),
+      placed(['1 +']),
+    );
+
+    expect(text.split('\n')).toEqual([
+      '  Debug Console, line 1',
+      '    1 +',
+      '       ^',
+      'SyntaxError: invalid syntax',
+    ]);
+  });
+
+  it('ends with the type alone when the error has no message', () => {
+    const text = jupyterTraceback(
+      error([{ file: '<grail>', line: 1, name: '<module>', text: 'raise E' }], {
+        type: 'E',
+        message: '',
+      }),
+      placed(['raise E']),
+    );
+
+    expect(text.split('\n').pop()).toBe('E');
+  });
+});
diff --git a/src/__tests__/debugConsole.test.ts b/src/__tests__/debugConsole.test.ts
new file mode 100644
index 0000000..fa2deb3
--- /dev/null
+++ b/src/__tests__/debugConsole.test.ts
@@ -0,0 +1,992 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { commands, window } from '../__mocks__/vscode';
+import type { ConsoleAnswer, ConsoleHost, Pause } from '../debugger';
+import type { HaltHandler, RedDotSource } from '../session';
+
+/**
+ * The Debug Console and the Watch pane, without a database: what the adapter
+ * does with an `evaluate` request — which frame it asks for, what it sends
+ * back and in what order, how it is stopped — given a pause whose `evaluate`
+ * is a stub. What the expression actually does in the gem is
+ * `debugConsole.test.ts` in `__integration__`.
+ */
+
+vi.mock('../session', () => ({
+  setHaltHandler: (_handler: HaltHandler | undefined) => {},
+  setRedDotSource: (_source: RedDotSource | undefined) => {},
+}));
+
+const { PauseDebugAdapter, consoleTip, debugConsole, originLine, rowHandles } =
+  await import('../debugger');
+const { commitQuery } = await import('../pauseVariables');
+
+/** Let the adapter's promises run. */
+const settle = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0));
+
+type Evaluate = NonNullable<Pause['evaluate']>;
+
+/** A value answer: `value` reads as typed, nothing printed, not expandable. */
+const value = (text: string, more: Partial<ConsoleAnswer> = {}): ConsoleAnswer =>
+  ({ kind: 'value', output: '', value: text, variablesReference: 0, ...more }) as ConsoleAnswer;
+
+/** An adapter on a paused two-frame stack whose `evaluate` is `evaluate`. */
+function consoleOn(evaluate: Evaluate | undefined, more: Partial<Pause> = {}) {
+  const sent: Array<Record<string, unknown>> = [];
+  const pause: Pause = {
+    label: 'a.ipynb',
+    frames: [
+      { id: 1, name: 'inner', line: 4, column: 1 },
+      { id: 2, name: 'outer', line: 9, column: 1 },
+    ],
+    scopes: () => [],
+    variables: () => Promise.resolve([]),
+    answer: () => {},
+    ...(evaluate ? { evaluate } : {}),
+    ...more,
+  };
+  const adapter = new PauseDebugAdapter(() => pause);
+  adapter.onDidSendMessage((m) => sent.push(m as Record<string, unknown>));
+  let seq = 1;
+  const request = (command: string, args?: Record<string, unknown>): number => {
+    const mine = seq++;
+    adapter.handleMessage({ seq: mine, type: 'request', command, arguments: args });
+    return mine;
+  };
+  const responseTo = (requestSeq: number) =>
+    sent.find((m) => m.type === 'response' && m.request_seq === requestSeq);
+  const events = (name: string) => sent.filter((m) => m.type === 'event' && m.event === name);
+  return { adapter, sent, request, responseTo, events };
+}
+
+/** Initialize (as VS Code does, claiming what it supports), launch and stop. */
+function started(
+  evaluate: Evaluate | undefined,
+  client: Record<string, unknown> = { supportsInvalidatedEvent: true },
+  more: Partial<Pause> = {},
+) {
+  const c = consoleOn(evaluate, more);
+  c.request('initialize', { adapterID: 'gemdb', ...client });
+  c.request('launch', { gemdbPause: '1' });
+  c.request('configurationDone');
+  return c;
+}
+
+// The one-line tip about the % commands is tested on its own below; elsewhere it is already shown.
+beforeEach(() => {
+  consoleTip.shown = true;
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+describe('what the adapter claims', () => {
+  it('claims cancelling, so a runaway console line can be stopped', () => {
+    const { request, responseTo } = consoleOn(undefined);
+    const seq = request('initialize', { adapterID: 'gemdb' });
+
+    expect(responseTo(seq)?.body).toMatchObject({ supportsCancelRequest: true });
+  });
+
+  it('does not claim hover evaluation: a hover must never change anything', () => {
+    const { request, responseTo } = consoleOn(undefined);
+    const seq = request('initialize', { adapterID: 'gemdb' });
+
+    const body = responseTo(seq)?.body as Record<string, unknown>;
+    expect(body.supportsEvaluateForHovers).toBeFalsy();
+  });
+
+  it('runs nothing for a context that is not the console or Watch, such as Copy Value’s old one', async () => {
+    const evaluate = vi.fn<Evaluate>();
+    const { request, responseTo } = started(evaluate);
+
+    const seq = request('evaluate', { expression: '{int} 3', frameId: 1, context: 'variables' });
+    await settle();
+
+    expect(responseTo(seq)?.success).toBe(false);
+    expect(evaluate).not.toHaveBeenCalled();
+  });
+
+  it('refuses a hover evaluate without running anything', async () => {
+    const evaluate = vi.fn<Evaluate>();
+    const { request, responseTo } = started(evaluate);
+
+    const seq = request('evaluate', { expression: 'p', frameId: 1, context: 'hover' });
+    await settle();
+
+    expect(responseTo(seq)?.success).toBe(false);
+    expect(evaluate).not.toHaveBeenCalled();
+  });
+});
+
+describe('the frame an expression runs in', () => {
+  it('runs in the frame VS Code names: the one selected in Call Stack', async () => {
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value('1'));
+    const { request } = started(evaluate);
+
+    request('evaluate', { expression: 'n', frameId: 2, context: 'repl' });
+    await settle();
+
+    expect(evaluate).toHaveBeenCalledWith('n', 2, 'repl', expect.anything());
+  });
+
+  it('runs in the top frame when VS Code names none', async () => {
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value('1'));
+    const { request } = started(evaluate);
+
+    request('evaluate', { expression: 'n', context: 'repl' });
+    await settle();
+
+    expect(evaluate).toHaveBeenCalledWith('n', 1, 'repl', expect.anything());
+  });
+
+  it('tells a watch from a console line, so a watch keeps the short time budget', async () => {
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value('1'));
+    const { request } = started(evaluate);
+
+    request('evaluate', { expression: 'n', frameId: 1, context: 'watch' });
+    await settle();
+
+    expect(evaluate).toHaveBeenCalledWith('n', 1, 'watch', expect.anything());
+  });
+
+  it('answers with a message, not a hang, where the pause offers no evaluation', async () => {
+    const { request, responseTo } = started(undefined);
+
+    const seq = request('evaluate', { expression: 'p', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({ success: false });
+    expect(responseTo(seq)?.message).toEqual(expect.any(String));
+  });
+});
+
+describe('what the console shows', () => {
+  it('answers the value as typed, with its type and a reference that opens it', async () => {
+    const { request, responseTo } = started(() =>
+      Promise.resolve(value("P('ann')", { type: 'P', variablesReference: 12, namedVariables: 2 })),
+    );
+
+    const seq = request('evaluate', { expression: 'p', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({
+      success: true,
+      body: { result: "P('ann')", type: 'P', variablesReference: 12, namedVariables: 2 },
+    });
+  });
+
+  it('pages a big result the way the Variables pane does', async () => {
+    const { request, responseTo } = started(() =>
+      Promise.resolve(
+        value('list with 1000 items', {
+          type: 'list',
+          variablesReference: 4,
+          indexedVariables: 1000,
+        }),
+      ),
+    );
+
+    const seq = request('evaluate', { expression: 'big', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(responseTo(seq)?.body).toMatchObject({ variablesReference: 4, indexedVariables: 1000 });
+  });
+
+  it('shows nothing for None or a statement', async () => {
+    const { request, responseTo } = started(() => Promise.resolve(value('')));
+
+    const seq = request('evaluate', { expression: 'y = 5', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({
+      success: true,
+      body: { result: '', variablesReference: 0 },
+    });
+  });
+
+  it('sends what the line printed as stdout output, before the answer', async () => {
+    const { request, sent, responseTo } = started(() =>
+      Promise.resolve(value('', { output: "P('ann')\n" })),
+    );
+
+    const seq = request('evaluate', { expression: 'print(p)', frameId: 1, context: 'repl' });
+    await settle();
+
+    const printed = sent.findIndex((m) => m.event === 'output');
+    const answered = sent.indexOf(responseTo(seq)!);
+    expect(sent[printed]?.body).toMatchObject({ category: 'stdout', output: "P('ann')\n" });
+    expect(printed).toBeGreaterThanOrEqual(0);
+    expect(printed).toBeLessThan(answered);
+  });
+
+  it('sends no output event when nothing was printed', async () => {
+    const { request, events } = started(() => Promise.resolve(value('1')));
+
+    request('evaluate', { expression: '1', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(events('output')).toEqual([]);
+  });
+});
+
+describe('errors', () => {
+  const TRACEBACK = [
+    '---------------------------------------------------------------------------',
+    'ZeroDivisionError                         Traceback (most recent call last)',
+    'Debug Console, line 2',
+    '      1 x = 1',
+    '----> 2 1/0',
+    '',
+    'ZeroDivisionError: division by zero',
+  ].join('\n');
+
+  it('fails the request with the traceback as its message, not put to the user as a dialog', async () => {
+    const { request, responseTo } = started(() =>
+      Promise.resolve({ kind: 'error', output: '', traceback: TRACEBACK } as ConsoleAnswer),
+    );
+
+    const seq = request('evaluate', { expression: 'x = 1\n1/0', frameId: 1, context: 'repl' });
+    await settle();
+
+    const reply = responseTo(seq) as {
+      success: boolean;
+      message: string;
+      body: { error: { format: string; showUser: boolean } };
+    };
+    expect(reply.success).toBe(false);
+    expect(reply.message).toBe(TRACEBACK);
+    expect(reply.body.error.showUser).toBe(false);
+  });
+
+  it('still sends what was printed before the error, ahead of it', async () => {
+    const { request, sent, responseTo } = started(() =>
+      Promise.resolve({ kind: 'error', output: 'first\n', traceback: TRACEBACK } as ConsoleAnswer),
+    );
+
+    const seq = request('evaluate', {
+      expression: 'print("first")\n1/0',
+      frameId: 1,
+      context: 'repl',
+    });
+    await settle();
+
+    const printed = sent.findIndex((m) => m.event === 'output');
+    expect(sent[printed]?.body).toMatchObject({ output: 'first\n' });
+    expect(printed).toBeLessThan(sent.indexOf(responseTo(seq)!));
+  });
+
+  it('shows a watch’s error in the watch, the same way', async () => {
+    const { request, responseTo } = started(() =>
+      Promise.resolve({ kind: 'error', output: '', traceback: TRACEBACK } as ConsoleAnswer),
+    );
+
+    const seq = request('evaluate', { expression: '1/0', frameId: 1, context: 'watch' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({ success: false, message: TRACEBACK });
+  });
+
+  it('reads an interrupted line as interrupted, not as an error in the user’s code', async () => {
+    const { request, responseTo } = started(() =>
+      Promise.resolve({ kind: 'interrupted', output: '' } as ConsoleAnswer),
+    );
+
+    const seq = request('evaluate', {
+      expression: 'while True: pass',
+      frameId: 1,
+      context: 'repl',
+    });
+    await settle();
+
+    const reply = responseTo(seq) as { success: boolean; message: string };
+    expect(reply.success).toBe(false);
+    expect(reply.message).toMatch(/interrupted/i);
+    expect(reply.message).not.toMatch(/^Error/);
+  });
+
+  it('answers a failure of the evaluation itself with a message, and keeps the pause', async () => {
+    const answer = vi.fn();
+    const { request, responseTo } = started(
+      () => Promise.reject(new Error('the session went away')),
+      undefined,
+      { answer },
+    );
+
+    const seq = request('evaluate', { expression: 'p', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({ success: false });
+    expect(answer).not.toHaveBeenCalled();
+  });
+});
+
+describe('the Variables pane after a console line', () => {
+  it('tells VS Code to read the variables again after a console line', async () => {
+    const { request, events } = started(() => Promise.resolve(value('')));
+
+    request('evaluate', { expression: 'p.x = 10', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(events('invalidated').map((e) => e.body)).toEqual([
+      expect.objectContaining({ areas: expect.arrayContaining(['variables']) }),
+    ]);
+  });
+
+  it('says so after a console line that failed too: it may have changed something first', async () => {
+    const { request, events } = started(() =>
+      Promise.resolve({ kind: 'error', output: '', traceback: 'x' } as ConsoleAnswer),
+    );
+
+    request('evaluate', { expression: 'p.x = 10\n1/0', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(events('invalidated')).toHaveLength(1);
+  });
+
+  it('never invalidates after a watch, which VS Code re-runs when the variables are read again', async () => {
+    const { request, events } = started(() => Promise.resolve(value('1')));
+
+    request('evaluate', { expression: 'p.x', frameId: 1, context: 'watch' });
+    await settle();
+
+    expect(events('invalidated')).toEqual([]);
+  });
+
+  it('sends no invalidated event to a client that did not claim it', async () => {
+    const { request, events } = started(() => Promise.resolve(value('')), {});
+
+    request('evaluate', { expression: 'p.x = 10', frameId: 1, context: 'repl' });
+    await settle();
+
+    expect(events('invalidated')).toEqual([]);
+  });
+});
+
+describe('stopping a runaway line', () => {
+  /** An evaluate that runs until its signal aborts, then answers interrupted. */
+  function runaway(): { evaluate: Evaluate; signals: AbortSignal[] } {
+    const signals: AbortSignal[] = [];
+    const evaluate: Evaluate = (_source, _frameId, _context, signal) => {
+      signals.push(signal);
+      return new Promise<ConsoleAnswer>((resolve) =>
+        signal.addEventListener('abort', () =>
+          resolve({ kind: 'interrupted', output: '' } as ConsoleAnswer),
+        ),
+      );
+    };
+    return { evaluate, signals };
+  }
+
+  it('stops the line on DAP cancel, and answers both requests', async () => {
+    const { evaluate, signals } = runaway();
+    const { request, responseTo } = started(evaluate);
+
+    const running = request('evaluate', {
+      expression: 'while True: pass',
+      frameId: 1,
+      context: 'repl',
+    });
+    await settle();
+    const cancel = request('cancel', { requestId: running });
+    await settle();
+
+    expect(signals[0].aborted).toBe(true);
+    expect(responseTo(cancel)?.success).toBe(true);
+    expect(responseTo(running)).toMatchObject({ success: false });
+    expect((responseTo(running) as { message: string }).message).toMatch(/interrupted|cancelled/i);
+  });
+
+  it('leaves alone a line that a cancel for some other request names', async () => {
+    const { evaluate, signals } = runaway();
+    const { request } = started(evaluate);
+
+    const running = request('evaluate', { expression: 'spin()', frameId: 1, context: 'repl' });
+    await settle();
+    request('cancel', { requestId: running + 100 });
+    await settle();
+
+    expect(signals[0].aborted).toBe(false);
+  });
+
+  it('offers a cancellable notification once a console line has run a few seconds', async () => {
+    vi.useFakeTimers();
+    const { evaluate, signals } = runaway();
+    let cancelRequested: (() => void) | undefined;
+    const shown: Array<{ cancellable?: boolean; title?: string }> = [];
+    vi.spyOn(window, 'withProgress').mockImplementation(((
+      options: { cancellable?: boolean; title?: string },
+      task: (
+        progress: unknown,
+        token: { isCancellationRequested: boolean; onCancellationRequested: unknown },
+      ) => Thenable<unknown>,
+    ) => {
+      shown.push(options);
+      return task(
+        { report: () => {} },
+        {
+          isCancellationRequested: false,
+          onCancellationRequested: (listener: () => void) => {
+            cancelRequested = listener;
+            return { dispose: () => {} };
+          },
+        },
+      );
+    }) as typeof window.withProgress);
+    const { request, responseTo } = started(evaluate);
+
+    const running = request('evaluate', {
+      expression: 'while True: pass',
+      frameId: 1,
+      context: 'repl',
+    });
+    await vi.advanceTimersByTimeAsync(500);
+    const earlyNotifications = shown.length;
+    await vi.advanceTimersByTimeAsync(5_000);
+    cancelRequested?.();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(earlyNotifications).toBe(0);
+    expect(shown).toEqual([expect.objectContaining({ cancellable: true })]);
+    expect(signals[0].aborted).toBe(true);
+    expect(responseTo(running)).toMatchObject({ success: false });
+  });
+
+  it('shows no notification for a line that finishes quickly', async () => {
+    vi.useFakeTimers();
+    const progress = vi.spyOn(window, 'withProgress');
+    const { request } = started(() => Promise.resolve(value('1')));
+
+    request('evaluate', { expression: '1', frameId: 1, context: 'repl' });
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    expect(progress).not.toHaveBeenCalled();
+  });
+
+  it('shows no notification for a watch, which has a budget of its own', async () => {
+    vi.useFakeTimers();
+    const progress = vi.spyOn(window, 'withProgress');
+    const { evaluate } = runaway();
+    const { request } = started(evaluate);
+
+    request('evaluate', { expression: 'spin()', frameId: 1, context: 'watch' });
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    expect(progress).not.toHaveBeenCalled();
+  });
+});
+
+describe('rows a pause lists itself (rowHandles)', () => {
+  const row = (name: string, handle: number) =>
+    ({ name, value: '1', type: 'int', handle }) as Parameters<
+      ReturnType<typeof rowHandles>['remember']
+    >[1][number];
+
+  it('finds a listed row’s handle by its container and name, and nothing for one never listed', () => {
+    const rows = rowHandles();
+
+    rows.remember(4, [row('n', 17), row('m', 18)]);
+    rows.remember(5, [row('n', 30)]);
+
+    expect(rows.handleFor(4, 'n')).toBe(17);
+    expect(rows.handleFor(5, 'n')).toBe(30);
+    expect(rows.handleFor(4, 'x')).toBeUndefined();
+  });
+
+  it('keeps no handle for a row that has none', () => {
+    const rows = rowHandles();
+
+    rows.remember(4, [row('n', 0)]);
+
+    expect(rows.handleFor(4, 'n')).toBeUndefined();
+  });
+});
+
+describe('a console run through a host (debugConsole)', () => {
+  const F = '\u001f';
+  const R = '\u001e';
+  const rec = (...fields: Array<string | number>): string => fields.join(F) + R;
+
+  it('runs a line through its host, in the frame’s console names, and reads the answer', async () => {
+    const query = vi.fn<ConsoleHost['query']>(() =>
+      Promise.resolve(rec('value', 3, 'hi\n', '') + rec('t', '10', 'int', 0, 0, 0, 9)),
+    );
+    const con = debugConsole({
+      query,
+      ownerKey: 'saved-stack:s',
+      consoles: new Map([[2, { locals: 7, globals: 8 }]]),
+    });
+
+    const answer = await con.evaluate!('t', 2, 'repl', new AbortController().signal);
+
+    expect(answer).toMatchObject({ kind: 'value', value: '10', output: 'hi\n' });
+    // The frame's locals and globals, by registry position, and no time budget for a console line.
+    expect(query.mock.calls[0][0]).toMatch(/\(7 between: 1 and: reg size\)/);
+    expect(query.mock.calls[0][1]).toMatchObject({ budget: false });
+  });
+
+  it('answers a failed watch with the one line that says what went wrong, not the traceback', async () => {
+    const failed =
+      rec('error', 3, '', '') +
+      rec('NameError', "name 'grand_total' is not defined", '', 1, 0, 'x');
+    const con = debugConsole({
+      query: () => Promise.resolve(failed),
+      ownerKey: 'nb',
+      consoles: new Map(),
+    });
+
+    const watched = await con.evaluate!('grand_total', 1, 'watch', new AbortController().signal);
+    const typed = await con.evaluate!('grand_total', 1, 'repl', new AbortController().signal);
+
+    expect(watched).toMatchObject({
+      kind: 'error',
+      traceback: "NameError: name 'grand_total' is not defined",
+    });
+    // The console keeps the whole traceback, ending in that line.
+    expect(typed.kind === 'error' && typed.traceback).toMatch(
+      /Debug Console, line 1[\s\S]*\nNameError: name 'grand_total' is not defined$/,
+    );
+  });
+});
+
+describe('putting a Variables row in the Debug Console', () => {
+  const showRow = (answer: ConsoleAnswer) => vi.fn(() => Promise.resolve(answer));
+
+  type Listed = { value: string; variablesReference: number; indexedVariables?: number };
+
+  /**
+   * Show a row (or evaluate with self, given `expression`) and answer what was
+   * sent: the output events, and the rows the console lists from the one
+   * that carries a reference.
+   */
+  async function shown(
+    answer: ConsoleAnswer,
+    { variables, expression }: { variables?: Pause['variables']; expression?: string } = {},
+  ) {
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(answer);
+    const c = started(evaluate, undefined, {
+      showRow: showRow(answer),
+      ...(variables ? { variables } : {}),
+    });
+    const seq = c.request('gemdbShowRow', {
+      handle: 7,
+      name: 'p',
+      ...(expression === undefined ? {} : { expression, frameId: 2 }),
+    });
+    await settle();
+    const outputs = c
+      .events('output')
+      .map((e) => e.body as { category: string; output: string; variablesReference?: number });
+    const listing = outputs.find((o) => o.variablesReference);
+    let rows: Listed[] = [];
+    if (listing) {
+      const listed = c.request('variables', { variablesReference: listing.variablesReference });
+      await settle();
+      rows = (c.responseTo(listed)?.body as { variables: Listed[] }).variables;
+    }
+    return {
+      ok: c.responseTo(seq)?.success,
+      outputs,
+      rows,
+      evaluate,
+      invalidated: c.events('invalidated').length,
+    };
+  }
+
+  it('shows a value as one line, name and value', async () => {
+    const result = await shown(value('10'));
+
+    expect(result.rows).toEqual([{ name: 'p: 10', value: 'p: 10', variablesReference: 0 }]);
+    // Every line goes out the same way, so it all reads alike in the console.
+    expect(result.outputs).toEqual([
+      { category: 'console', output: '', variablesReference: expect.any(Number) },
+    ]);
+    expect(result.ok).toBe(true);
+    // Showing changes nothing, so Variables is left alone.
+    expect(result.invalidated).toBe(0);
+  });
+
+  it('names an object, then lists its attributes beneath, each with its name', async () => {
+    const variables = vi.fn<Pause['variables']>().mockResolvedValue([
+      // A folded group heading, as an object's rows start: left out of the listing.
+      { name: 'special variables', value: '', variablesReference: 11, namedVariables: 9 },
+      { name: 'owner', value: "{str} 'ada'", type: 'str', variablesReference: 0 },
+      { name: 'history', value: '[10]', type: 'list', variablesReference: 9, indexedVariables: 1 },
+    ]);
+
+    const result = await shown(
+      value("Account('ada', 10)", { variablesReference: 7, namedVariables: 2, children: 'obj' }),
+      { variables },
+    );
+
+    // Room for the group headings that come first.
+    expect(variables).toHaveBeenCalledWith(7, 0, 6);
+    // VS Code shows these with their names hidden, so each name is in its text.
+    expect(result.rows).toEqual([
+      { name: "p: Account('ada', 10)", value: "p: Account('ada', 10)", variablesReference: 0 },
+      // The console prints plain reprs: the Variables row's type badge comes off.
+      { name: "owner: 'ada'", value: "owner: 'ada'", type: 'str', variablesReference: 0 },
+      {
+        name: 'history: [10]',
+        value: 'history: [10]',
+        type: 'list',
+        variablesReference: 9,
+        indexedVariables: 1,
+      },
+    ]);
+  });
+
+  it('shows a list as one closed row that opens like the Variables row', async () => {
+    const variables = vi.fn<Pause['variables']>();
+
+    const result = await shown(
+      value('list with 1000 items', {
+        type: 'list',
+        variablesReference: 4,
+        indexedVariables: 1000,
+        children: 'seq',
+      }),
+      { variables },
+    );
+
+    expect(variables).not.toHaveBeenCalled();
+    expect(result.rows).toEqual([
+      {
+        name: 'p: list with 1000 items',
+        value: 'p: list with 1000 items',
+        type: 'list',
+        variablesReference: 4,
+        indexedVariables: 1000,
+      },
+    ]);
+  });
+
+  it('shows a dict as one closed row too, however few its entries', async () => {
+    const variables = vi.fn<Pause['variables']>();
+
+    const result = await shown(
+      value("{'a': 1}", { variablesReference: 4, namedVariables: 1, children: 'dict' }),
+      { variables },
+    );
+
+    expect(variables).not.toHaveBeenCalled();
+    expect(result.rows).toEqual([
+      expect.objectContaining({ value: "p: {'a': 1}", variablesReference: 4, namedVariables: 1 }),
+    ]);
+  });
+
+  it('shows an object with more than twenty attributes as one closed row', async () => {
+    const variables = vi.fn<Pause['variables']>();
+
+    const result = await shown(
+      value('Wide()', { variablesReference: 4, namedVariables: 21, children: 'obj' }),
+      { variables },
+    );
+
+    expect(variables).not.toHaveBeenCalled();
+    expect(result.rows).toHaveLength(1);
+  });
+
+  it('runs an expression with self bound to the row, echoing it, and refreshes Variables', async () => {
+    const result = await shown(value('2', { output: 'hi\n' }), {
+      expression: 'len(self.history)',
+    });
+
+    expect(result.evaluate).toHaveBeenCalledWith(
+      'len(self.history)',
+      2,
+      'repl',
+      expect.anything(),
+      7,
+    );
+    expect(result.outputs.slice(0, 2)).toEqual([
+      { category: 'console', output: '>>> len(self.history)  # self is p\n' },
+      { category: 'stdout', output: 'hi\n' },
+    ]);
+    expect(result.rows.map((r) => r.value)).toEqual(['2']);
+    expect(result.invalidated).toBe(1);
+  });
+
+  it('shows an error’s traceback in the console', async () => {
+    const result = await shown({ kind: 'error', output: '', traceback: 'TB' } as ConsoleAnswer, {
+      expression: 'self.nope',
+    });
+
+    expect(result.outputs.pop()).toEqual({ category: 'stderr', output: 'TB\n' });
+    expect(result.ok).toBe(true);
+  });
+
+  it('answers what to type at the prompt for the object it showed', async () => {
+    const consoleName = vi.fn<NonNullable<Pause['consoleName']>>().mockResolvedValue('_');
+    const c = started(vi.fn(), undefined, { showRow: showRow(value('10')), consoleName });
+
+    const seq = c.request('gemdbShowRow', { handle: 7, name: "'owner'", frameId: 2 });
+    await settle();
+
+    expect(consoleName).toHaveBeenCalledWith(2, "'owner'", 7);
+    expect(c.responseTo(seq)?.body).toEqual({ typed: '_' });
+  });
+
+  it('answers nothing to type after Evaluate with self', async () => {
+    const consoleName = vi.fn<NonNullable<Pause['consoleName']>>();
+    const c = started(vi.fn<Evaluate>().mockResolvedValue(value('2')), undefined, {
+      showRow: vi.fn(),
+      consoleName,
+    });
+
+    const seq = c.request('gemdbShowRow', { handle: 7, name: 'p', expression: 'self.x' });
+    await settle();
+
+    expect(consoleName).not.toHaveBeenCalled();
+    expect(c.responseTo(seq)?.body).toBeUndefined();
+  });
+
+  it('refuses where the pause has no console to show rows in', async () => {
+    const { request, responseTo } = started(undefined);
+
+    const seq = request('gemdbShowRow', { handle: 7, name: 'p' });
+    await settle();
+
+    expect(responseTo(seq)).toMatchObject({ success: false });
+  });
+});
+
+describe('GemDB’s % commands in the console', () => {
+  /** Run a % line and answer what came back. */
+  async function command(line: string, more: Partial<Pause> = {}, evaluate?: Evaluate) {
+    const evaluated = evaluate ?? vi.fn<Evaluate>();
+    const c = started(evaluated, undefined, more);
+    const seq = c.request('evaluate', { expression: line, frameId: 2, context: 'repl' });
+    await settle();
+    await settle();
+    return {
+      ...c,
+      reply: c.responseTo(seq),
+      said: c
+        .events('output')
+        .map((e) => (e.body as { output: string }).output)
+        .join(''),
+      evaluated,
+    };
+  }
+
+  it('answers %help with the commands, running nothing in the database', async () => {
+    const { reply, said, evaluated } = await command('%help');
+
+    expect(reply?.success).toBe(true);
+    expect(said).toMatch(/%persist p {3}or {3}%persist p as key/);
+    expect(evaluated).not.toHaveBeenCalled();
+  });
+
+  it('persists p by setting gemdb.root["p"] in the console’s own names, and shows it pending', async () => {
+    const executed = vi.spyOn(commands, 'executeCommand').mockReturnValue(Promise.resolve());
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value("(False, None, 'list')"));
+
+    const { reply, said } = await command(
+      '%persist p',
+      { ownerKey: 'nb', label: 'a.ipynb' },
+      evaluate,
+    );
+
+    const [source, frameId, context] = evaluate.mock.calls[0];
+    expect(frameId).toBe(2);
+    expect(context).toBe('repl');
+    expect(source).toContain('__import__("gemdb").root, "p", (p)');
+    expect(executed).toHaveBeenCalledWith('gemdb.savedObjects.notePersisted', {
+      key: 'p',
+      type: 'list',
+      ownerKey: 'nb',
+      notebook: 'a.ipynb',
+    });
+    expect(said).toMatch(
+      /Added p to Persisted Objects as gemdb.root\["p"\]\. It is saved when a\.ipynb commits/,
+    );
+    expect(reply?.success).toBe(true);
+  });
+
+  it('says so when %persist replaces what was there', async () => {
+    vi.spyOn(commands, 'executeCommand').mockReturnValue(Promise.resolve());
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value("(True, None, 'int')"));
+
+    const { said } = await command('%persist p as total', { ownerKey: 'nb' }, evaluate);
+
+    expect(said).toMatch(/as gemdb.root\["total"\], replacing what was there/);
+  });
+
+  it('shows the traceback when what is persisted does not exist', async () => {
+    const executed = vi.spyOn(commands, 'executeCommand');
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue({
+      kind: 'error',
+      output: '',
+      traceback: "NameError: name 'q' is not defined",
+    } as ConsoleAnswer);
+
+    const { reply } = await command('%persist q', {}, evaluate);
+
+    expect(reply).toMatchObject({ success: false, message: "NameError: name 'q' is not defined" });
+    expect(executed).not.toHaveBeenCalledWith(
+      'gemdb.savedObjects.notePersisted',
+      expect.anything(),
+    );
+  });
+
+  it('commits the notebook on %commit, as ✓ in Persisted Objects does', async () => {
+    const executed = vi.spyOn(commands, 'executeCommand').mockReturnValue(Promise.resolve());
+    const query = vi.fn((code: string) =>
+      Promise.resolve(code.includes('commit') ? "'committed'" : ''),
+    );
+
+    const { reply, said } = await command('%commit', { query, label: 'a.ipynb' });
+
+    expect(query).toHaveBeenCalledWith(commitQuery());
+    expect(executed).toHaveBeenCalledWith('gemdb.savedObjects.refresh');
+    expect(said).toMatch(/Committed a\.ipynb/);
+    expect(reply?.success).toBe(true);
+  });
+
+  it('commits a saved stack’s own session on %commit, as a notebook’s', async () => {
+    vi.spyOn(commands, 'executeCommand').mockReturnValue(Promise.resolve());
+    const query = vi.fn((code: string) =>
+      Promise.resolve(code.includes('commit') ? "'committed'" : ''),
+    );
+
+    const { reply, said } = await command('%commit', {
+      saved: true,
+      query,
+      label: 'Saved stack: a.ipynb (today)',
+    });
+
+    expect(query).toHaveBeenCalledWith(commitQuery());
+    expect(said).toMatch(/Committed Saved stack: a\.ipynb \(today\)/);
+    expect(reply?.success).toBe(true);
+  });
+
+  it('lists what the console has bound on %names', async () => {
+    const consoleNames = vi
+      .fn()
+      .mockResolvedValue([{ name: 'p', type: 'list', repr: "[('B400', '2', 'str')]" }]);
+
+    const { said } = await command('%names', { consoleNames });
+
+    expect(consoleNames).toHaveBeenCalledWith(2);
+    expect(said).toBe("p: list = [('B400', '2', 'str')]\n");
+  });
+
+  it('fails a mistyped command in the console’s error colour, with the commands named', async () => {
+    const { reply } = await command('%persit p');
+
+    expect(reply).toMatchObject({ success: false });
+    expect((reply as { message: string }).message).toMatch(/%persit is not a GemDB command/);
+  });
+
+  it('claims completions, triggered by %, and offers the commands and then the console’s names', async () => {
+    const consoleNames = vi.fn().mockResolvedValue([{ name: 'p', type: 'list', repr: '[]' }]);
+    const c = started(vi.fn(), undefined, { consoleNames });
+    const init = c.request('initialize', { adapterID: 'gemdb' });
+    const commandsListed = c.request('completions', { text: '%pe', column: 4, frameId: 1 });
+    const namesListed = c.request('completions', { text: '%persist ', column: 10, frameId: 1 });
+    const python = c.request('completions', { text: 'len(', column: 5, frameId: 1 });
+    await settle();
+    await settle();
+
+    expect(c.responseTo(init)?.body).toMatchObject({
+      supportsCompletionsRequest: true,
+      completionTriggerCharacters: ['%'],
+    });
+    expect(
+      (c.responseTo(commandsListed)?.body as { targets: Array<{ label: string }> }).targets.map(
+        (t) => t.label,
+      ),
+    ).toEqual(['%persist']);
+    expect(
+      (c.responseTo(namesListed)?.body as { targets: Array<{ label: string }> }).targets.map(
+        (t) => t.label,
+      ),
+    ).toEqual(['p']);
+    expect(c.responseTo(python)?.body).toEqual({ targets: [] });
+    // Typing Python asks the database nothing.
+    expect(consoleNames).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows the one-line tip about the commands at the first stop of a window, and only then', () => {
+    consoleTip.shown = false;
+    const first = started(vi.fn());
+    const second = started(vi.fn());
+
+    const tip = (c: ReturnType<typeof started>) =>
+      c.events('output').map((e) => (e.body as { output: string }).output);
+    expect(tip(first)).toEqual([expect.stringMatching(/type % in the Debug Console/)]);
+    expect(tip(second)).toEqual([]);
+  });
+
+  it('says a pause’s opening note when it opens, after the tip, every time', () => {
+    consoleTip.shown = false;
+    const said = (c: ReturnType<typeof started>) =>
+      c.events('output').map((e) => (e.body as { output: string }).output);
+
+    const first = started(vi.fn(), undefined, { openingNote: 'careful\n' });
+    const second = started(vi.fn(), undefined, { openingNote: 'careful\n' });
+
+    expect(said(first)).toEqual([
+      expect.stringMatching(/type % in the Debug Console/),
+      'careful\n',
+    ]);
+    expect(said(second)).toEqual(['careful\n']);
+  });
+
+  it('shows no tip where the pause has no console', () => {
+    consoleTip.shown = false;
+    const saved = started(undefined);
+
+    expect(saved.events('output')).toEqual([]);
+    consoleTip.shown = true;
+  });
+
+  it('offers persisted.o while o is typed, reading the persisted keys once until a console line runs', async () => {
+    const persistedKeys = vi.fn().mockResolvedValue(['o', 'orders']);
+    const c = started(vi.fn<Evaluate>().mockResolvedValue(value('1')), undefined, {
+      persistedKeys,
+    });
+    const labels = async (text: string) => {
+      const seq = c.request('completions', { text, column: text.length + 1, frameId: 1 });
+      await settle();
+      await settle();
+      return (c.responseTo(seq)?.body as { targets: Array<{ label: string }> }).targets.map(
+        (t) => t.label,
+      );
+    };
+
+    const typingO = await labels('o');
+    const typingOr = await labels('or');
+    const afterDot = await labels('persisted.');
+    const readsBefore = persistedKeys.mock.calls.length;
+    c.request('evaluate', { expression: 'o = 1', frameId: 1, context: 'repl' });
+    await settle();
+    await labels('o');
+
+    expect(typingO).toEqual(['persisted.o', 'persisted.orders']);
+    expect(typingOr).toEqual(['persisted.orders']);
+    expect(afterDot).toEqual(['o', 'orders']);
+    // Once a pause, not once a keystroke; again after a line that may have changed them.
+    expect(readsBefore).toBe(1);
+    expect(persistedKeys).toHaveBeenCalledTimes(2);
+  });
+
+  it('still answers %persist when Persisted Objects cannot be told about it', async () => {
+    vi.spyOn(commands, 'executeCommand').mockReturnValue(Promise.reject(new Error('no view')));
+    const evaluate = vi.fn<Evaluate>().mockResolvedValue(value("(False, None, 'list')"));
+
+    const { reply, said } = await command('%persist p', { ownerKey: 'nb' }, evaluate);
+    await settle();
+
+    expect(reply?.success).toBe(true);
+    expect(said).toMatch(/^Added p to Persisted Objects/);
+  });
+
+  it('labels a persisted name with where it comes from', () => {
+    expect(originLine('o')).toBe(
+      'o is gemdb.root["o"], from Persisted Objects (also persisted.o)\n',
+    );
+  });
+});
diff --git a/src/__tests__/debugger.test.ts b/src/__tests__/debugger.test.ts
index 3003c67..8a3e84c 100644
--- a/src/__tests__/debugger.test.ts
+++ b/src/__tests__/debugger.test.ts
@@ -881,26 +881,19 @@ describe('the debug adapter', () => {
     });
   });
 
-  it('answers Copy Value with the value alone, and still refuses other evaluation', () => {
+  it('answers Copy Value with the value alone, and runs nothing for another context', () => {
     const { request, response } = adapterFor({ answer: () => {} });
     request('initialize');
     request('launch', { gemdbPause: '1' });
 
     request('evaluate', { expression: "{str} 'hello'", frameId: 1, context: 'clipboard' });
     const copied = response('evaluate');
-    request('evaluate', { expression: 'p.x', frameId: 1, context: 'repl' });
-    const repl = response('evaluate');
-    // Only the clipboard: answering another context would echo text back as if evaluated.
+    // Not the clipboard: running a row's text as Python would answer nonsense, or worse.
     request('evaluate', { expression: '{int} 3', frameId: 1, context: 'variables' });
 
     expect(response('initialize')?.body).toMatchObject({ supportsClipboardContext: true });
     expect(copied).toMatchObject({ success: true, body: { result: "'hello'" } });
-    for (const refused of [repl, response('evaluate')]) {
-      expect(refused).toMatchObject({
-        success: false,
-        message: "Evaluating expressions isn't supported yet.",
-      });
-    }
+    expect(response('evaluate')).toMatchObject({ success: false });
   });
 
   it('declines Restart with a message, leaving the pause alone', () => {
diff --git a/src/__tests__/persistedObjectsView.test.ts b/src/__tests__/persistedObjectsView.test.ts
index 25f3f5c..6464d76 100644
--- a/src/__tests__/persistedObjectsView.test.ts
+++ b/src/__tests__/persistedObjectsView.test.ts
@@ -111,6 +111,10 @@ class FakeGem {
       additions.clear();
       return "'aborted'";
     }
+    if (code.includes("System abortTransaction. 'aborted'")) {
+      additions.clear();
+      return 'aborted';
+    }
     const taken = /"([^"]+)" in gemdb\.root/.exec(code);
     if (taken) return this.committed.has(taken[1]) || additions.has(taken[1]) ? 'true' : 'false';
     throw new Error(`the fake gem does not answer: ${code.slice(0, 80)}`);
@@ -118,6 +122,8 @@ class FakeGem {
 }
 
 let gem: FakeGem;
+/** The sessions closed, by owner key. */
+const closedSessions: string[] = [];
 let running = true;
 const connected: Array<{ key: string; label: string }> = [];
 const paused = new Map<string, Pause>();
@@ -131,6 +137,13 @@ vi.mock('../session', () => ({
       openedAt: 0,
       idleMs: 0,
     })),
+  PAUSED_QUERY_BUDGET_MS: 2000,
+  interruptSessionFor: () => {},
+  // A saved stack opened in the debugger works in a session of its own.
+  sessionFor: (owner: { key: string }) => ({
+    executeAsync: (code: string) => Promise.resolve(gem.run(owner.key, code)),
+  }),
+  closeSessionFor: (key: string) => closedSessions.push(key),
   sessionForIfOpen: (key: string) =>
     connected.some((o) => o.key === key)
       ? { executeAsync: (code: string) => Promise.resolve(gem.run(key, code)) }
@@ -146,6 +159,8 @@ vi.mock('../debugger', () => ({
     return Promise.resolve(true);
   },
   openCellTexts: () => [],
+  rowHandles: () => ({ remember: () => {}, handleFor: () => undefined }),
+  debugConsole: () => ({ evaluate: () => Promise.reject(new Error('not in these tests')) }),
   toDapVariable: (v: { name: string; value: string; ref: number }) => ({
     name: v.name,
     value: v.value,
@@ -316,6 +331,35 @@ describe('adding an object from the debugger', () => {
     );
   });
 
+  it('shows a %persist from the Debug Console as waiting under its notebook, and reveals it', async () => {
+    pauseIn(NB);
+    connected.push({ key: NB, label: 'breakpoint.ipynb' });
+    const { view } = setUp();
+    // What %persist p did in the paused session, before telling the view.
+    gem.pending.set(NB, new Map([['p', 'list']]));
+
+    await command('gemdb.savedObjects.notePersisted')({
+      key: 'p',
+      type: 'list',
+      ownerKey: NB,
+      notebook: 'breakpoint.ipynb',
+    });
+    await vi.waitFor(() => expect(__treeViews.get(DEBUG_VIEW_ID)!.reveals).toHaveLength(1));
+    const rows = await topOf(view);
+
+    const notebook = rows.find((r) => r.kind === 'notebook')!;
+    const [waiting] = view.getChildren(notebook);
+    expect(item(view, waiting)).toMatchObject({
+      label: 'p',
+      description: 'list · added, not persisted yet',
+      contextValue: 'gemdbSavedPending',
+    });
+    expect(__treeViews.get(DEBUG_VIEW_ID)!.reveals[0].element).toMatchObject({
+      kind: 'pending',
+      save: { key: 'p' },
+    });
+  });
+
   it('opens Persisted Objects in Run and Debug on the new row, leaving focus in Variables', async () => {
     pauseIn(NB);
     connected.push({ key: NB, label: 'breakpoint.ipynb' });
@@ -662,6 +706,65 @@ describe('saved stacks', () => {
     );
   });
 
+  it('opens the stack in a session of its own, which closes with it', async () => {
+    gem.committed.set('stack_bp', 'dict');
+    gem.stacks.set('stack_bp', snapshot('breakpoint.ipynb'));
+    opened.length = 0;
+    closedSessions.length = 0;
+    const { view } = setUp();
+    const [root] = await topOf(view);
+
+    await command('gemdb.savedObjects.openStack')(view.getChildren(root)[0]);
+    const [pause] = opened;
+    const warned = vi.spyOn(window, 'showWarningMessage');
+    pause.answer('stop');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(pause.ownerKey).toBe('saved-stack:stack_bp');
+    expect(gem.queries.some((q) => q.session === 'saved-stack:stack_bp')).toBe(true);
+    // Nothing was changed, so nothing is asked.
+    expect(warned).not.toHaveBeenCalled();
+    expect(closedSessions).toEqual(['saved-stack:stack_bp']);
+  });
+
+  it('asks about changes made in its Debug Console when it closes, and commits them if told to', async () => {
+    gem.committed.set('stack_bp', 'dict');
+    gem.stacks.set('stack_bp', snapshot('breakpoint.ipynb'));
+    opened.length = 0;
+    closedSessions.length = 0;
+    const { view } = setUp();
+    const [root] = await topOf(view);
+    await command('gemdb.savedObjects.openStack')(view.getChildren(root)[0]);
+    const warned = vi.spyOn(window, 'showWarningMessage').mockResolvedValue('Commit' as never);
+    // A console line changed something in the stack's session.
+    gem.pending.set('saved-stack:stack_bp', new Map([['changed', 'Employee']]));
+
+    opened[0].answer('stop');
+    await vi.waitFor(() => expect(closedSessions).toHaveLength(1));
+
+    expect(warned.mock.calls[0][0]).toMatch(/stack_bp.*has changes made in the Debug Console/);
+    expect(warned.mock.calls[0][1]).toMatchObject({ modal: true });
+    expect(gem.committed.get('changed')).toBe('Employee');
+  });
+
+  it('discards them when not told to commit', async () => {
+    gem.committed.set('stack_bp', 'dict');
+    gem.stacks.set('stack_bp', snapshot('breakpoint.ipynb'));
+    gem.committed.delete('changed');
+    opened.length = 0;
+    closedSessions.length = 0;
+    const { view } = setUp();
+    const [root] = await topOf(view);
+    await command('gemdb.savedObjects.openStack')(view.getChildren(root)[0]);
+    vi.spyOn(window, 'showWarningMessage').mockResolvedValue(undefined as never);
+    gem.pending.set('saved-stack:stack_bp', new Map([['changed', 'Employee']]));
+
+    opened[0].answer('stop');
+    await vi.waitFor(() => expect(closedSessions).toHaveLength(1));
+
+    expect(gem.committed.has('changed')).toBe(false);
+  });
+
   it('opens one saved stack at a time', async () => {
     gem.committed.set('stack_bp', 'dict');
     gem.stacks.set('stack_bp', snapshot('breakpoint.ipynb'));
diff --git a/src/__tests__/variableCommands.test.ts b/src/__tests__/variableCommands.test.ts
new file mode 100644
index 0000000..7552064
--- /dev/null
+++ b/src/__tests__/variableCommands.test.ts
@@ -0,0 +1,217 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { DebugStackFrame, __commands, commands, debug, window } from '../__mocks__/vscode';
+import type { Pause } from '../debugger';
+
+/**
+ * Show in Debug Console and Evaluate with self… on a Variables row, without a
+ * database: which row's object they name, what they ask the paused session,
+ * and that they open the console. What the adapter does with the request is
+ * `debugConsole.test.ts`; the whole path at a real pause is the row-menu test
+ * in `__integration__/debugConsole.test.ts`.
+ */
+
+let pause: Partial<Pause> | undefined;
+vi.mock('../debugger', () => ({
+  DEBUG_TYPE: 'gemdb',
+  pauseForDebugSession: (id: string | undefined) => (id === 's1' ? pause : undefined),
+}));
+
+const {
+  EVALUATE_WITH_SELF,
+  SHOW_IN_CONSOLE,
+  evaluateWithSelf,
+  registerVariableCommands,
+  showInDebugConsole,
+} = await import('../variableCommands');
+
+type CustomRequest = (command: string, args?: unknown) => Promise<unknown>;
+
+/** A paused GemDB session whose rows under container 5 have handles by name. */
+function paused(customRequest: CustomRequest = () => Promise.resolve({})) {
+  const session = { id: 's1', type: 'gemdb', name: 'GemDB: a.ipynb', customRequest };
+  debug.activeDebugSession = session;
+  pause = { handleFor: (container, name) => (container === 5 && name === 'n' ? 12 : undefined) };
+  return session;
+}
+
+/** Record the commands run and the errors shown, in order. */
+function watching() {
+  const seen: string[] = [];
+  vi.spyOn(commands, 'executeCommand').mockImplementation((id: string) => {
+    seen.push(`command ${id}`);
+    return undefined;
+  });
+  vi.spyOn(window, 'showErrorMessage').mockImplementation((message: string) => {
+    seen.push(`error ${message}`);
+    return Promise.resolve(undefined);
+  });
+  return seen;
+}
+
+const row = (name: string, variablesReference: number) => ({
+  sessionId: 's1',
+  container: { variablesReference: 5 },
+  variable: { name, value: '…', variablesReference },
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  debug.activeDebugSession = undefined;
+  debug.activeStackItem = undefined;
+  pause = undefined;
+});
+
+describe('Show in Debug Console', () => {
+  it('opens the console, then asks the session to show the row’s object there', async () => {
+    const seen = watching();
+    const customRequest = vi.fn<CustomRequest>(async (command, args) => {
+      seen.push(`request ${command} ${JSON.stringify(args)}`);
+      return {};
+    });
+    paused(customRequest);
+
+    await showInDebugConsole(row('p', 7));
+
+    expect(seen).toEqual([
+      'command workbench.debug.action.focusRepl',
+      'request gemdbShowRow {"handle":7,"name":"p"}',
+    ]);
+  });
+
+  it('leaves what to type at the console’s prompt, as the adapter answers it', async () => {
+    const seen = watching();
+    vi.spyOn(commands, 'executeCommand').mockImplementation((id: string, ...args: unknown[]) => {
+      seen.push(`command ${id}${args.length ? ' ' + JSON.stringify(args[0]) : ''}`);
+      return undefined;
+    });
+    paused(() => Promise.resolve({ typed: 'entry' }));
+
+    await showInDebugConsole(row('entry', 7));
+
+    expect(seen).toEqual([
+      'command workbench.debug.action.focusRepl',
+      'command type {"text":"entry"}',
+    ]);
+  });
+
+  it('types nothing when the adapter answers nothing to type', async () => {
+    const seen = watching();
+    paused(() => Promise.resolve({}));
+
+    await showInDebugConsole(row('p', 7));
+
+    expect(seen).toEqual(['command workbench.debug.action.focusRepl']);
+  });
+
+  it('finds a leaf row’s object by its handle, as Add to Persisted Objects does', async () => {
+    watching();
+    const customRequest = vi.fn<CustomRequest>().mockResolvedValue({});
+    paused(customRequest);
+
+    await showInDebugConsole(row('n', 0));
+
+    expect(customRequest).toHaveBeenCalledWith('gemdbShowRow', { handle: 12, name: 'n' });
+  });
+
+  it('says so, and asks nothing, for a row with no object of its own', async () => {
+    const seen = watching();
+    const customRequest = vi.fn<CustomRequest>();
+    paused(customRequest);
+
+    await showInDebugConsole(row('...', 0));
+
+    expect(customRequest).not.toHaveBeenCalled();
+    expect(seen).toEqual(['error "..." is not an object of its own.']);
+  });
+
+  it('says it needs a paused GemDB run when there is none', async () => {
+    const seen = watching();
+    debug.activeDebugSession = { id: 'py', type: 'debugpy' };
+
+    await showInDebugConsole(row('p', 7));
+
+    expect(seen).toEqual([expect.stringMatching(/^error .*paused in the debugger/)]);
+  });
+
+  it('shows the error when the request fails', async () => {
+    const seen = watching();
+    paused(() => Promise.reject(new Error('the pause is over')));
+
+    await showInDebugConsole(row('p', 7));
+
+    expect(seen).toContain('error the pause is over');
+  });
+});
+
+describe('Evaluate with self…', () => {
+  it('runs the expression typed with self bound to the row, in the frame selected in Call Stack', async () => {
+    watching();
+    const customRequest = vi.fn<CustomRequest>().mockResolvedValue({});
+    const session = paused(customRequest);
+    debug.activeStackItem = new DebugStackFrame(session, 1, 3);
+    vi.spyOn(window, 'showInputBox').mockResolvedValue('len(self.history)');
+
+    await evaluateWithSelf(row('p', 7));
+
+    expect(customRequest).toHaveBeenCalledWith('gemdbShowRow', {
+      handle: 7,
+      name: 'p',
+      expression: 'len(self.history)',
+      frameId: 3,
+    });
+  });
+
+  it('leaves the frame to the adapter when none is selected in this session', async () => {
+    watching();
+    const customRequest = vi.fn<CustomRequest>().mockResolvedValue({});
+    paused(customRequest);
+    debug.activeStackItem = new DebugStackFrame(
+      { id: 'other', type: 'gemdb', customRequest },
+      1,
+      3,
+    );
+    vi.spyOn(window, 'showInputBox').mockResolvedValue('self');
+
+    await evaluateWithSelf(row('p', 7));
+
+    expect(customRequest.mock.calls[0][1]).not.toHaveProperty('frameId');
+  });
+
+  it('does nothing when the input box is dismissed or left empty', async () => {
+    const seen = watching();
+    const customRequest = vi.fn<CustomRequest>();
+    paused(customRequest);
+    const input = vi.spyOn(window, 'showInputBox');
+
+    input.mockResolvedValueOnce(undefined);
+    await evaluateWithSelf(row('p', 7));
+    input.mockResolvedValueOnce('   ');
+    await evaluateWithSelf(row('p', 7));
+
+    expect(customRequest).not.toHaveBeenCalled();
+    expect(seen).toEqual([]);
+  });
+});
+
+describe('registering the commands', () => {
+  it('registers both under the ids package.json puts on the Variables menu, and removes them on dispose', async () => {
+    const registration = registerVariableCommands();
+    const { default: manifest } = (await import('../../package.json')) as unknown as {
+      default: {
+        contributes: { menus: Record<string, Array<{ command: string; when?: string }>> };
+      };
+    };
+
+    expect(__commands.has(SHOW_IN_CONSOLE)).toBe(true);
+    expect(__commands.has(EVALUATE_WITH_SELF)).toBe(true);
+    const onVariables = manifest.contributes.menus['debug/variables/context'];
+    expect(onVariables).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ command: SHOW_IN_CONSOLE, when: 'debugType == gemdb' }),
+        expect.objectContaining({ command: EVALUATE_WITH_SELF, when: 'debugType == gemdb' }),
+      ]),
+    );
+    registration.dispose();
+    expect(__commands.has(SHOW_IN_CONSOLE)).toBe(false);
+  });
+});
diff --git a/src/consoleCommands.ts b/src/consoleCommands.ts
new file mode 100644
index 0000000..152bf6f
--- /dev/null
+++ b/src/consoleCommands.ts
@@ -0,0 +1,213 @@
+/**
+ * GemDB's own commands in the Debug Console: a line that starts with `%`.
+ *
+ * Everything typed into the console reaches the debug adapter first, so it can
+ * take a `%` line as a command before treating it as Python — as CodeLLDB does
+ * with `/` and Ruby's debugger with `,`. `%` is IPython's and Jupyter's sign
+ * for the same idea (`%store`, `%timeit`), so a Python developer is likely to
+ * guess it, and no Python line can start with it, so nothing a user means as
+ * Python is ever taken for a command.
+ *
+ * This file only reads the line and describes the commands; the adapter runs
+ * them (`PauseDebugAdapter.runCommand`).
+ */
+
+/** One command, as `%help` and autocomplete describe it. */
+export interface ConsoleCommandInfo {
+  name: string;
+  /** How it is typed. */
+  usage: string;
+  /** What it does, in one line. */
+  summary: string;
+}
+
+export const CONSOLE_COMMANDS: ConsoleCommandInfo[] = [
+  {
+    name: '%persist',
+    usage: '%persist p   or   %persist p as key',
+    summary: 'Add p to Persisted Objects (gemdb.root); it is saved when the notebook commits.',
+  },
+  {
+    name: '%commit',
+    usage: '%commit',
+    summary: "Commit the notebook's changes, as ✓ in Persisted Objects does.",
+  },
+  {
+    name: '%names',
+    usage: '%names',
+    summary: 'List the names you have bound in the Debug Console at this pause.',
+  },
+  {
+    name: '%help',
+    usage: '%help',
+    summary: "List GemDB's Debug Console commands.",
+  },
+];
+
+/** A `%` line, read. */
+export type ConsoleCommand =
+  | { kind: 'persist'; expression: string; key: string }
+  | { kind: 'commit' }
+  | { kind: 'names' }
+  | { kind: 'help' }
+  | { kind: 'invalid'; message: string };
+
+/** A Python identifier: a name a console line can bind. */
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/** Whether a console line is a GemDB command rather than Python. */
+export function isConsoleCommand(line: string): boolean {
+  return line.trimStart().startsWith('%');
+}
+
+/** Read a `%` line. Undefined for a line that is not one. */
+export function parseConsoleCommand(line: string): ConsoleCommand | undefined {
+  const text = line.trim();
+  if (!text.startsWith('%')) return undefined;
+  const [, word = '', rest = ''] = /^%(\S*)\s*([\s\S]*)$/.exec(text) ?? [];
+  switch (word) {
+    case 'persist': {
+      if (!rest) return { kind: 'invalid', message: `Persist what? ${usageOf('%persist')}` };
+      const as = /^([\s\S]+?)\s+as\s+(.+)$/.exec(rest);
+      const expression = (as ? as[1] : rest).trim();
+      const key = as ? unquoted(as[2].trim()) : expression;
+      if (!as && !IDENTIFIER.test(expression)) {
+        return {
+          kind: 'invalid',
+          message: `Give it a key: %persist ${expression} as some_key`,
+        };
+      }
+      if (!key) return { kind: 'invalid', message: `Give it a key. ${usageOf('%persist')}` };
+      return { kind: 'persist', expression, key };
+    }
+    case 'commit':
+    case 'names':
+    case 'help':
+      return rest
+        ? { kind: 'invalid', message: `%${word} takes nothing after it.` }
+        : { kind: word };
+    default:
+      return {
+        kind: 'invalid',
+        message: `${word ? `%${word} is not a GemDB command.` : 'A command goes after the %.'} ${commandList()}`,
+      };
+  }
+}
+
+/** A key typed in quotes, `"orders"` or `'orders'`, without them. */
+function unquoted(text: string): string {
+  const quoted = /^(["'])(.*)\1$/.exec(text);
+  return quoted ? quoted[2] : text;
+}
+
+function usageOf(name: string): string {
+  const info = CONSOLE_COMMANDS.find((c) => c.name === name);
+  return info ? `Type ${info.usage}.` : '';
+}
+
+function commandList(): string {
+  return `Commands: ${CONSOLE_COMMANDS.map((c) => c.name).join(', ')}.`;
+}
+
+/** What `%help` prints. */
+export function helpText(): string {
+  const width = Math.max(...CONSOLE_COMMANDS.map((c) => c.usage.length));
+  return [
+    "GemDB's Debug Console commands (Python still works as usual):",
+    ...CONSOLE_COMMANDS.map((c) => `  ${c.usage.padEnd(width)}   ${c.summary}`),
+    '',
+    'What Persisted Objects holds is here by name (o for gemdb.root["o"]), and always as',
+    'persisted.o, even when o means something else at this pause. Type persisted to list it.',
+    '',
+  ].join('\n');
+}
+
+/** The one-line tip the console shows at the first pause of a window. */
+export const CONSOLE_TIP =
+  'GemDB: type % in the Debug Console for its commands. %persist p keeps p in Persisted Objects; %help lists them all.\n';
+
+/** One autocomplete suggestion, as the Debug Adapter Protocol spells it. */
+export interface CompletionItem {
+  label: string;
+  text?: string;
+  detail?: string;
+  type?: 'function' | 'variable' | 'keyword';
+  /** 1-based column in the typed text where the completion replaces from. */
+  start?: number;
+  length?: number;
+}
+
+/**
+ * What to suggest for the text before the cursor. Only after a `%`: a command
+ * name while it is being typed, and after `%persist `, the names bound in the
+ * console (`names`). Anything else is Python, which this does not complete.
+ */
+export function commandCompletions(beforeCursor: string, names: string[]): CompletionItem[] {
+  const word = /^(\s*)%([A-Za-z]*)$/.exec(beforeCursor);
+  if (word) {
+    const start = word[1].length + 1;
+    return CONSOLE_COMMANDS.filter((c) => c.name.startsWith(`%${word[2]}`)).map((c) => ({
+      label: c.name,
+      detail: c.summary,
+      type: 'keyword',
+      start,
+      length: word[2].length + 1,
+    }));
+  }
+  const persisting = /^\s*%persist\s+([A-Za-z0-9_]*)$/.exec(beforeCursor);
+  if (persisting) {
+    const typed = persisting[1];
+    return names
+      .filter((n) => n.startsWith(typed))
+      .map((n) => ({
+        label: n,
+        type: 'variable',
+        start: beforeCursor.length - typed.length + 1,
+        length: typed.length,
+      }));
+  }
+  return [];
+}
+
+/** A Python name, the only kind of persisted key reachable as `persisted.key`. */
+const PYTHON_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Suggestions for Persisted Objects while Python is typed, so a persisted
+ * object can be found without knowing `persisted` exists:
+ *
+ * - after `persisted.`, the persisted keys;
+ * - while a name is typed (not after a dot), `persisted.key` for each
+ *   persisted key it starts, described as the `gemdb.root` entry it is.
+ *
+ * `keys` is what Persisted Objects holds. Keys that are not Python names are
+ * left out: they are reachable only as `gemdb.root["…"]`.
+ */
+export function persistedCompletions(beforeCursor: string, keys: string[]): CompletionItem[] {
+  const names = keys.filter((k) => PYTHON_NAME.test(k));
+  const after = /(?:^|[^A-Za-z0-9_.])persisted\.([A-Za-z0-9_]*)$/.exec(beforeCursor);
+  if (after) {
+    const typed = after[1];
+    return names
+      .filter((k) => k.startsWith(typed))
+      .map((k) => ({
+        label: k,
+        detail: `gemdb.root[${JSON.stringify(k)}] in Persisted Objects`,
+        type: 'variable',
+        start: beforeCursor.length - typed.length + 1,
+        length: typed.length,
+      }));
+  }
+  const word = /(?:^|[^A-Za-z0-9_.])([A-Za-z_][A-Za-z0-9_]*)$/.exec(beforeCursor);
+  if (!word) return [];
+  const typed = word[1];
+  return names
+    .filter((k) => k.startsWith(typed))
+    .map((k) => ({
+      label: `persisted.${k}`,
+      detail: `gemdb.root[${JSON.stringify(k)}] in Persisted Objects`,
+      type: 'variable',
+      start: beforeCursor.length - typed.length + 1,
+      length: typed.length,
+    }));
+}
diff --git a/src/consoleTraceback.ts b/src/consoleTraceback.ts
new file mode 100644
index 0000000..ccdef28
--- /dev/null
+++ b/src/consoleTraceback.ts
@@ -0,0 +1,101 @@
+import { ConsoleError, TracebackFrame } from './pauseVariables';
+
+/**
+ * A Debug Console error, written the way a Jupyter notebook shows one:
+ *
+ * ```
+ * ---------------------------------------------------------------------------
+ * ZeroDivisionError                         Traceback (most recent call last)
+ * Debug Console, line 1
+ * ----> 1 boom(0)
+ *
+ * Cell [2], line 2, in boom
+ *       1 def boom(d):
+ * ----> 2     return 10 / d
+ *
+ * ZeroDivisionError: division by zero
+ * ```
+ *
+ * Python developers read tracebacks in that shape every day, and IPython's is
+ * the one they meet in notebooks, which is where GemDB's pauses mostly are.
+ * Each frame is placed by `place`: its label and, when the source can be
+ * found, its lines, so the frame shows a few lines around the one that
+ * raised. A frame whose source cannot be found shows the text Grail recorded
+ * for it. A SyntaxError has no frames, and shows the line it could not read
+ * with a caret, as IPython does.
+ */
+
+/** Where a traceback frame's source is: what to call it, and its lines when they can be read. */
+export interface PlacedFrame {
+  /** `Debug Console`, `Cell [2]`, or for a file the path: `File /w/mod.py`. */
+  label: string;
+  /** Whether `label` names a file, which takes `:line` rather than `, line N`. */
+  isFile: boolean;
+  lines?: string[];
+}
+
+/** IPython's rule, the width of its header. */
+const RULE = '-'.repeat(75);
+
+/** Width of the line-number gutter, arrow included. */
+const GUTTER = 7;
+
+/** Lines shown on either side of the one that raised. */
+const CONTEXT = 2;
+
+export function jupyterTraceback(
+  error: ConsoleError,
+  place: (frame: TracebackFrame, index: number) => PlacedFrame,
+): string {
+  const last = error.message ? `${error.type}: ${error.message}` : error.type;
+  if (error.syntax) {
+    const { line, offset, text } = error.syntax;
+    const where = place({ file: error.syntax.file || '<grail>', line, name: '<module>', text }, 0);
+    const lineText = text.replace(/\r?\n$/, '');
+    const indent = lineText.length - lineText.trimStart().length;
+    const caret = offset > 0 ? [`    ${' '.repeat(Math.max(0, offset - 1 - indent))}^`] : [];
+    return [
+      `  ${where.isFile ? `${where.label}:${line}` : `${where.label}, line ${line}`}`,
+      `    ${lineText.trim()}`,
+      ...caret,
+      last,
+    ].join('\n');
+  }
+  const blocks = error.frames.map((frame, index) => frameBlock(frame, place(frame, index)));
+  return [
+    RULE,
+    `${error.type.padEnd(41)} Traceback (most recent call last)`,
+    blocks.join('\n\n'),
+    '',
+    last,
+  ].join('\n');
+}
+
+function frameBlock(frame: TracebackFrame, placed: PlacedFrame): string {
+  const inName = frame.name === '<module>' ? '' : `, in ${frame.name}`;
+  const header = placed.isFile
+    ? `${placed.label}:${frame.line}${inName}`
+    : `${placed.label}, line ${frame.line}${inName}`;
+  const shown: Array<[number, string]> = [];
+  const lines = placed.lines;
+  if (lines && frame.line >= 1 && frame.line <= lines.length) {
+    const from = Math.max(1, frame.line - CONTEXT);
+    const to = Math.min(lines.length, frame.line + CONTEXT);
+    for (let n = from; n <= to; n++) shown.push([n, lines[n - 1]]);
+  } else if (frame.line >= 1) {
+    shown.push([frame.line, frame.text.replace(/\r?\n[\s\S]*$/, '')]);
+  }
+  const body = shown.map(([n, text]) => `${gutter(n, n === frame.line)} ${text.trimEnd()}`);
+  return [header, ...body].join('\n');
+}
+
+/**
+ * IPython's line-number gutter: the number right-aligned in seven columns,
+ * and on the line that raised, an arrow filling the columns before it —
+ * `----> 9`, `---> 10`, beside `     10`.
+ */
+function gutter(n: number, raised: boolean): string {
+  const number = String(n);
+  if (!raised) return number.padStart(GUTTER);
+  return `${'-'.repeat(Math.max(1, GUTTER - number.length - 2))}> ${number}`;
+}
diff --git a/src/debugger.ts b/src/debugger.ts
index 16978b0..17cba5f 100644
--- a/src/debugger.ts
+++ b/src/debugger.ts
@@ -5,18 +5,46 @@ import { runFileOf } from './fileOwner';
 import { CellText, PythonFrame, firstLineOf, locateCell } from './haltStack';
 import { errorMessage, log } from './log';
 import {
+  CONSOLE_TIP,
+  commandCompletions,
+  helpText,
+  isConsoleCommand,
+  parseConsoleCommand,
+  persistedCompletions,
+} from './consoleCommands';
+import { PlacedFrame, jupyterTraceback } from './consoleTraceback';
+import {
+  ChildKind,
+  ConsoleScope,
+  NameOrigin,
   MAIN_MODULE,
   PAGE,
   PauseVariable,
+  TracebackFrame,
   childrenQuery,
   clearRegistryQuery,
+  commitQuery,
+  consoleNameQuery,
+  consoleNamesQuery,
+  consoleQuery,
+  describeRowQuery,
   parseChildren,
+  parseConsoleNames,
+  parseConsoleReply,
   parsePausedStack,
+  parsePersistedKeys,
   pausedStackQuery,
+  persistedKeysQuery,
   setVariableQuery,
 } from './pauseVariables';
 import { DotsByFile, armedLinesQuery, parseArmed } from './redDots';
-import { HaltAnswer, HaltRequest, setHaltHandler, setRedDotSource } from './session';
+import {
+  HaltAnswer,
+  HaltRequest,
+  PausedQueryOptions,
+  setHaltHandler,
+  setRedDotSource,
+} from './session';
 
 /**
  * A debugger for Python paused at `breakpoint()` or at a red dot in a `.py` file.
@@ -38,11 +66,11 @@ import { HaltAnswer, HaltRequest, setHaltHandler, setRedDotSource } from './sess
  *
  * Deliberately small for now: the call stack, the highlight, each frame's
  * Locals and the notebook's Globals, Set Value on a row, Continue and Stop,
- * red dots in `.py` files, and saving a row's object under gemdb.root
- * (`savedObjects.ts`). Stepping, evaluation and Restart answer "not yet"
- * rather than pretending, and so do red dots in notebook cells and dots with a
- * condition, hit count or log message. The one evaluation answered is Copy
- * Value's, which only takes a row's type badge off its text (`copyText`).
+ * red dots in `.py` files, the Debug Console and the Watch pane, and saving a
+ * row's object under gemdb.root (`savedObjects.ts`). Stepping and Restart
+ * answer "not yet" rather than pretending, and so do red dots in notebook
+ * cells and dots with a condition, hit count or log message. Copy Value's
+ * evaluation only takes a row's type badge off its text (`copyText`).
  *
  * The adapter is inline (`DebugAdapterInlineImplementation`) and speaks the
  * Debug Adapter Protocol directly rather than through `@vscode/debugadapter`:
@@ -87,6 +115,33 @@ export interface DapVariable {
   presentationHint?: { attributes?: string[] };
 }
 
+/** Where an `evaluate` came from: the Debug Console, or the Watch pane. */
+export type ConsoleContext = 'repl' | 'watch';
+
+/**
+ * What one Debug Console line or watch came back with. `output` is what it
+ * printed, sent to the console before the answer; on an error, `traceback`
+ * reads as a Jupyter notebook's does.
+ */
+export type ConsoleAnswer =
+  | {
+      kind: 'value';
+      output: string;
+      /** The result's repr, without a type badge; '' for None or a statement. */
+      value: string;
+      type?: string;
+      /** Opens the result like a Variables row; 0 for a leaf. */
+      variablesReference: number;
+      indexedVariables?: number;
+      namedVariables?: number;
+      /** How its children are read: a container's items, or an object's attributes. */
+      children?: ChildKind;
+      /** For a bare name that is a Persisted Objects entry, `persisted` (`NameOrigin`). */
+      origin?: NameOrigin;
+    }
+  | { kind: 'error'; output: string; traceback: string }
+  | { kind: 'interrupted'; output: string };
+
 /** One evaluation sitting at a breakpoint(), waiting for the user. */
 export interface Pause {
   label: string;
@@ -112,10 +167,37 @@ export interface Pause {
   handleFor?(containerRef: number, name: string): number | undefined;
   /** Run a query in the paused session (see `HaltRequest.query`). */
   query?(code: string): Promise<string>;
+  /**
+   * Run Debug Console or watch input in frame `frameId`, with that frame's
+   * names in scope, until it finishes or `signal` aborts it. On a saved stack
+   * it runs in the stack's own session (`ConsoleHost`).
+   */
+  evaluate?(
+    source: string,
+    frameId: number,
+    context: ConsoleContext,
+    signal: AbortSignal,
+    /** A registry entry to run with as `self`: a Variables row's object (`consoleQuery`). */
+    selfHandle?: number,
+  ): Promise<ConsoleAnswer>;
+  /** The object of registry entry `handle`, as a console entry named `name`. */
+  showRow?(handle: number, name: string): Promise<ConsoleAnswer>;
+  /**
+   * What to type in frame `frameId`'s console to reach registry entry
+   * `handle`'s object: `name` when it already means that object there, else
+   * `_`, which it is then bound to (`consoleNameQuery`).
+   */
+  consoleName?(frameId: number, name: string, handle: number): Promise<string>;
+  /** What Persisted Objects holds: its string keys (`persistedKeysQuery`). */
+  persistedKeys?(): Promise<string[]>;
+  /** The names bound in frame `frameId`'s console so far (`consoleNamesQuery`). */
+  consoleNames?(frameId: number): Promise<Array<{ name: string; type: string; repr: string }>>;
   /** Each frame's whole cell or file, by frame index, so the stack can be saved. */
   texts?: Array<string[] | undefined>;
   /** The saved source behind a frame's `sourceReference`, for a stack opened from the database. */
   sourceText?(sourceReference: number): string | undefined;
+  /** What the Debug Console says when the pause opens, after the commands tip; a saved stack's warning. */
+  openingNote?: string;
   /** What the stop says in the Call Stack; `Paused on breakpoint()` when absent. */
   description?: string;
   /** A saved stack opened again: nothing to resume, and nothing more to save. */
@@ -209,6 +291,23 @@ export function toDapVariable(v: PauseVariable): DapVariable {
   };
 }
 
+/**
+ * Tell the Persisted Objects view (`savedObjects.ts`) about a `%` command's
+ * effect, through its command, so neither file imports the other. Never fails
+ * the command it reports on: the view's refresh is a courtesy.
+ */
+function tellView(command: string, ...args: unknown[]): void {
+  Promise.resolve(vscode.commands.executeCommand(command, ...args)).catch((e: unknown) =>
+    log(`Could not update Persisted Objects: ${errorMessage(e)}`),
+  );
+}
+
+/**
+ * Whether this window has shown the console's one-line tip about GemDB's `%`
+ * commands. A test resets it.
+ */
+export const consoleTip = { shown: false };
+
 /** Pauses by id, so a launch request can find the one it was started for. */
 const pauses = new Map<string, Pause>();
 let nextPauseId = 1;
@@ -513,6 +612,35 @@ interface DapRequest {
 
 const NOT_YET_STEP = "Stepping isn't supported yet. Use Continue to resume or Stop to end the run.";
 const NOT_CHANGEABLE = 'This is a saved stack: its values cannot be changed.';
+const NOT_HERE = 'Evaluating expressions is not available here.';
+const NO_HOVER = "GemDB doesn't evaluate on hover: a hover must not run code.";
+const INTERRUPTED = 'Interrupted.';
+const WATCH_TOO_LONG =
+  'Took too long for a watch (over 2 seconds). Run it in the Debug Console, which has no limit.';
+
+/**
+ * How long a console line runs before a notification offers to stop it. The
+ * Debug Console has no stop button of its own, and VS Code shows no Pause in
+ * the toolbar while the program is paused.
+ */
+export const OFFER_STOP_AFTER_MS = 4_000;
+
+/**
+ * Where the references for `PauseDebugAdapter.preview`'s containers start:
+ * far above any registry position, which is what every other reference is.
+ */
+const SHOWN_REFS = 1_000_000_000;
+
+/** An object with up to this many attributes has them listed in the console; one with more opens like a container. */
+const SHOW_ALL = 20;
+
+/** The most group rows (`special`, `class`, `function`, `module variables`) an object's listing starts with. */
+const GROUPS = 4;
+
+/** A folded group heading among an object's rows: it opens, but has no value or type of its own. */
+function isGroupRow(row: DapVariable): boolean {
+  return row.variablesReference > 0 && row.value === '' && !row.type;
+}
 const NOT_YET_RESTART =
   "Restarting isn't supported yet. Use Continue to resume or Stop to end the run.";
 
@@ -547,6 +675,18 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
   private dotWork: Promise<void>;
   /** Resolves at launch: VS Code may send setBreakpoints before it, and they wait. */
   private markLaunched: () => void = () => {};
+  /** Whether VS Code said, in `initialize`, that it reads the `invalidated` event. */
+  private clientInvalidates = false;
+  /** Console lines still running, by request seq, so `cancel` can stop one. */
+  private readonly running = new Map<number, AbortController>();
+  /**
+   * The containers `showRow` hands the console, by their reference
+   * (`preview`), each answered here rather than by the gem.
+   */
+  private readonly shown = new Map<number, DapVariable[]>();
+  private nextShown = SHOWN_REFS;
+  /** Persisted Objects' keys for autocomplete; dropped after every console line. */
+  private persistedKeysCache: Promise<string[]> | undefined;
 
   constructor(
     private readonly lookup: (id: string) => Pause | undefined,
@@ -560,6 +700,7 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
     if (request.type !== 'request') return;
     switch (request.command) {
       case 'initialize':
+        this.clientInvalidates = request.arguments?.supportsInvalidatedEvent === true;
         this.respond(request, {
           supportsConfigurationDoneRequest: true,
           supportsTerminateRequest: true,
@@ -567,6 +708,11 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
           // Copy Value asks for the row's text through evaluate in this
           // context, and copies the answer: see copyText.
           supportsClipboardContext: true,
+          // A console line can run for as long as the user's code does.
+          supportsCancelRequest: true,
+          // For GemDB's own `%` commands only: typing `%` lists them.
+          supportsCompletionsRequest: true,
+          completionTriggerCharacters: ['%'],
           // Claimed so Restart arrives as a request this adapter can decline.
           // Unclaimed, VS Code restarts by disconnecting — which stops the
           // cell — and relaunching at a pause that no longer exists.
@@ -650,6 +796,11 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
         // "... N more not shown" row instead.
         const count = Number(request.arguments?.count ?? 0) || PAGE;
         const pause = this.pause;
+        const shown = this.shown.get(ref);
+        if (shown) {
+          this.respond(request, { variables: shown.slice(start, start + count) });
+          return;
+        }
         if (!pause) {
           this.respond(request, { variables: [] });
           return;
@@ -702,16 +853,19 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
         // Only offered while running, and a paused evaluation is never running here.
         this.respond(request);
         return;
-      case 'evaluate': {
-        const context = String(request.arguments?.context ?? '');
-        if (context === 'clipboard') {
-          // Copy Value on a Variables row: the expression is the row's value
-          // text, and what is copied is the value without its type badge.
-          const expression = String(request.arguments?.expression ?? '');
-          this.respond(request, { result: copyText(expression), variablesReference: 0 });
-          return;
-        }
-        this.fail(request, "Evaluating expressions isn't supported yet.", false);
+      case 'evaluate':
+        this.evaluate(request);
+        return;
+      case 'gemdbShowRow':
+        this.showRow(request);
+        return;
+      case 'completions':
+        void this.complete(request);
+        return;
+      case 'cancel': {
+        const id = Number(request.arguments?.requestId ?? 0);
+        this.running.get(id)?.abort();
+        this.respond(request);
         return;
       }
       case 'terminate':
@@ -761,7 +915,378 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
     this.respond(request, { breakpoints: verifiedDots(file, wanted, armed, live) });
   }
 
+  /**
+   * Answer a Debug Console line or a watch. Hover is refused: `initialize`
+   * does not claim it, and a hover must never run code that could change
+   * something.
+   *
+   * What the line printed goes to the console first, then the answer: its
+   * value, which opens like a Variables row, or a failure whose message is a
+   * Jupyter traceback, or "Interrupted.". After a console line, failed or not
+   * — it may have changed something first — VS Code is told to read the
+   * variables again. Never after a watch: VS Code re-runs the watches when it
+   * re-reads, and each would invalidate the next.
+   *
+   * A console line runs as long as it takes; past `OFFER_STOP_AFTER_MS` a
+   * notification offers to stop it, as DAP's `cancel` does. A watch keeps the
+   * two-second budget the Variables rows have, since every watch re-runs at
+   * every stop.
+   */
+  private evaluate(request: DapRequest): void {
+    const context = String(request.arguments?.context ?? 'repl');
+    const source = String(request.arguments?.expression ?? '');
+    const pause = this.pause;
+    if (context === 'clipboard') {
+      // Copy Value on a Variables row: the expression is the row's value
+      // text, and what is copied is the value without its type badge.
+      this.respond(request, { result: copyText(source), variablesReference: 0 });
+      return;
+    }
+    if (context === 'hover') {
+      this.fail(request, NO_HOVER, false);
+      return;
+    }
+    // Only the console and Watch run code. Another context — `variables`, which
+    // a client without the clipboard context sends for Copy Value with the
+    // row's text — would run that text as Python.
+    if (!pause?.evaluate || (context !== 'repl' && context !== 'watch')) {
+      this.fail(request, NOT_HERE, false);
+      return;
+    }
+    const kind: ConsoleContext = context;
+    const frameId = Number(request.arguments?.frameId ?? pause.frames[0]?.id ?? 1);
+    // Any console line may change what Persisted Objects holds.
+    if (kind === 'repl') this.persistedKeysCache = undefined;
+    if (kind === 'repl' && isConsoleCommand(source)) {
+      void this.runCommand(request, source, frameId);
+      return;
+    }
+    const { controller, finish } = this.track(request, kind === 'repl');
+    pause.evaluate(source, frameId, kind, controller.signal).then(
+      (answer) => {
+        finish();
+        if (answer.output) this.event('output', { category: 'stdout', output: answer.output });
+        // A bare name that is a Persisted Objects entry: say where it comes from.
+        if (answer.kind === 'value' && answer.origin === 'persisted') {
+          this.event('output', { category: 'console', output: originLine(source.trim()) });
+        }
+        if (answer.kind === 'value') {
+          this.respond(request, {
+            result: answer.value,
+            ...(answer.type ? { type: answer.type } : {}),
+            variablesReference: answer.variablesReference,
+            ...(answer.indexedVariables ? { indexedVariables: answer.indexedVariables } : {}),
+            ...(answer.namedVariables ? { namedVariables: answer.namedVariables } : {}),
+          });
+        } else if (answer.kind === 'error') {
+          this.fail(request, answer.traceback, false);
+        } else {
+          this.fail(
+            request,
+            kind === 'watch' && !controller.signal.aborted ? WATCH_TOO_LONG : INTERRUPTED,
+            false,
+          );
+        }
+        if (kind === 'repl' && this.clientInvalidates) {
+          this.event('invalidated', { areas: ['variables'] });
+        }
+      },
+      (e: unknown) => {
+        finish();
+        this.fail(request, errorMessage(e), false);
+      },
+    );
+  }
+
+  /**
+   * Note a running console line under its request, so `cancel` can stop it,
+   * and, when `offerStop`, offer to stop it from a notification once it has
+   * run `OFFER_STOP_AFTER_MS`. `finish` when it is done.
+   */
+  private track(
+    request: DapRequest,
+    offerStop: boolean,
+  ): { controller: AbortController; finish: () => void } {
+    const controller = new AbortController();
+    this.running.set(request.seq, controller);
+    let finished = false;
+    let markDone: () => void = () => {};
+    const done = new Promise<void>((resolve) => (markDone = resolve));
+    const offer = offerStop
+      ? setTimeout(() => {
+          if (finished) return;
+          void vscode.window.withProgress(
+            {
+              location: vscode.ProgressLocation.Notification,
+              title: 'GemDB: the Debug Console is still running',
+              cancellable: true,
+            },
+            (_progress, token) => {
+              token.onCancellationRequested(() => controller.abort());
+              return done;
+            },
+          );
+        }, OFFER_STOP_AFTER_MS)
+      : undefined;
+    const finish = (): void => {
+      finished = true;
+      if (offer) clearTimeout(offer);
+      this.running.delete(request.seq);
+      markDone();
+    };
+    return { controller, finish };
+  }
+
+  /**
+   * Put a Variables row in the Debug Console (`gemdbShowRow`), for the
+   * row's menu (`variableCommands.ts`): its object (`preview`), or with
+   * `expression`, what that gives with
+   * `self` bound to the object, run in the frame `frameId` as a console line
+   * is, shown the same way. Shown as `output` events, since there is no
+   * console request to answer: an echo of the expression, what it printed,
+   * then the value, a traceback, or
+   * "Interrupted.". Showing answers `typed`: what to give the console's
+   * prompt to reach the object (`Pause.consoleName`).
+   */
+  private showRow(request: DapRequest): void {
+    const pause = this.pause;
+    const handle = Number(request.arguments?.handle ?? 0);
+    const name = String(request.arguments?.name ?? '');
+    const expression =
+      request.arguments?.expression === undefined
+        ? undefined
+        : String(request.arguments.expression);
+    if (!pause?.showRow || !pause.evaluate || handle <= 0) {
+      this.fail(request, NOT_HERE, true);
+      return;
+    }
+    const frameId = Number(request.arguments?.frameId ?? pause.frames[0]?.id ?? 1);
+    const { controller, finish } = this.track(request, expression !== undefined);
+    if (expression !== undefined) {
+      this.event('output', {
+        category: 'console',
+        output: `>>> ${expression}  # self is ${name}\n`,
+      });
+    }
+    const answered =
+      expression === undefined
+        ? pause.showRow(handle, name)
+        : pause.evaluate(expression, frameId, 'repl', controller.signal, handle);
+    answered
+      .then(async (answer) => {
+        if (answer.output) this.event('output', { category: 'stdout', output: answer.output });
+        if (answer.kind === 'value') {
+          const text = `${expression === undefined ? `${name}: ` : ''}${answer.value}`;
+          if (answer.value !== '' || answer.variablesReference > 0) {
+            this.event('output', {
+              category: 'console',
+              output: '',
+              variablesReference: await this.preview(pause, text, answer),
+            });
+          }
+        } else {
+          this.event('output', {
+            category: 'stderr',
+            output: `${answer.kind === 'error' ? answer.traceback : INTERRUPTED}\n`,
+          });
+        }
+        if (expression !== undefined && this.clientInvalidates) {
+          this.event('invalidated', { areas: ['variables'] });
+        }
+        // What the console's prompt should be given, so the next line can use the object.
+        const typed =
+          expression === undefined && answer.kind === 'value' && pause.consoleName
+            ? await pause.consoleName(frameId, name, handle).catch(() => undefined)
+            : undefined;
+        this.respond(request, typed === undefined ? undefined : { typed });
+      })
+      .catch((e: unknown) => this.fail(request, errorMessage(e), true))
+      .finally(finish);
+  }
+
+  /**
+   * A reference for the console holding what `showRow` shows, every line of
+   * it, so all of it reads alike. A list, tuple, set or dict is one row,
+   * labelled `text` and closed, that opens like the Variables row; so is an
+   * object with more than `SHOW_ALL` attributes. An object with fewer is a
+   * row for `text` and then a row for each attribute, so the one looked for
+   * needs no click; each that has children opens. A leaf is the one row.
+   *
+   * The labels are in the text because an `output` event's
+   * `variablesReference` is read by VS Code as a list of values, as a
+   * JavaScript debugger's console.log arguments are: it shows each child of
+   * the reference with its name hidden (measured: a dict's own reference
+   * showed its three values unlabelled). So the console is handed a container
+   * of the adapter's own (`shown`), answered here rather than by the gem.
+   */
+  private async preview(
+    pause: Pause,
+    text: string,
+    answer: Extract<ConsoleAnswer, { kind: 'value' }>,
+  ): Promise<number> {
+    const counts = {
+      ...(answer.indexedVariables ? { indexedVariables: answer.indexedVariables } : {}),
+      ...(answer.namedVariables ? { namedVariables: answer.namedVariables } : {}),
+    };
+    const total = (answer.indexedVariables ?? 0) + (answer.namedVariables ?? 0);
+    const listed =
+      answer.variablesReference > 0 &&
+      (answer.children === 'obj' || answer.children === 'ivars') &&
+      total <= SHOW_ALL;
+    const rows: DapVariable[] = listed
+      ? [
+          { name: text, value: text, variablesReference: 0 },
+          ...(await pause.variables(answer.variablesReference, 0, (total || SHOW_ALL) + GROUPS))
+            // An object's rows start with its folded groups (special, class,
+            // function variables), which are noise here: the data is the point.
+            .filter((kid) => !isGroupRow(kid))
+            .map((kid) => {
+              const label = `${kid.name}: ${copyText(kid.value) || kid.value}`;
+              return { ...kid, name: label, value: label };
+            }),
+        ]
+      : [
+          {
+            name: text,
+            value: text,
+            ...(answer.type ? { type: answer.type } : {}),
+            variablesReference: answer.variablesReference,
+            ...counts,
+          },
+        ];
+    const ref = this.nextShown++;
+    this.shown.set(ref, rows);
+    return ref;
+  }
+
+  /**
+   * Run one of GemDB's `%` commands (`consoleCommands.ts`), typed in the
+   * Debug Console. Its answer goes to the console as text, and a mistake in
+   * the command fails the request, so it reads in the console's error colour.
+   */
+  private async runCommand(request: DapRequest, line: string, frameId: number): Promise<void> {
+    const pause = this.pause;
+    const command = parseConsoleCommand(line);
+    const say = (text: string): void =>
+      this.event('output', {
+        category: 'console',
+        output: text.endsWith('\n') ? text : `${text}\n`,
+      });
+    const done = (): void => this.respond(request, { result: '', variablesReference: 0 });
+    if (!pause || !command) {
+      this.fail(request, NOT_HERE, false);
+      return;
+    }
+    try {
+      switch (command.kind) {
+        case 'invalid':
+          this.fail(request, command.message, false);
+          return;
+        case 'help':
+          say(helpText());
+          done();
+          return;
+        case 'names': {
+          const names = pause.consoleNames ? await pause.consoleNames(frameId) : [];
+          say(
+            names.length === 0
+              ? 'Nothing bound in the Debug Console yet at this pause. Try p = …, then %names.'
+              : names.map((n) => `${n.name}: ${n.type} = ${n.repr}`).join('\n'),
+          );
+          done();
+          return;
+        }
+        case 'commit': {
+          if (!pause.query) throw new Error('There is nothing to commit here.');
+          const answer = await pause.query(commitQuery());
+          if (answer.startsWith('Error: ')) throw new Error(answer.slice('Error: '.length));
+          tellView('gemdb.savedObjects.refresh');
+          say(`Committed ${pause.label}: its changes are saved in the database.`);
+          done();
+          return;
+        }
+        case 'persist': {
+          if (!pause.evaluate) throw new Error('Nothing can be persisted from here.');
+          // The expression is run once, in the console's own names, so p means what it means here.
+          const source =
+            `(lambda _gemdb_r, _gemdb_k, _gemdb_v: (_gemdb_k in _gemdb_r, ` +
+            `_gemdb_r.__setitem__(_gemdb_k, _gemdb_v), type(_gemdb_v).__name__))` +
+            `(__import__("gemdb").root, ${JSON.stringify(command.key)}, (${command.expression}))`;
+          const answer = await pause.evaluate(
+            source,
+            frameId,
+            'repl',
+            new AbortController().signal,
+          );
+          if (answer.output) this.event('output', { category: 'stdout', output: answer.output });
+          if (answer.kind !== 'value') {
+            this.fail(request, answer.kind === 'error' ? answer.traceback : INTERRUPTED, false);
+            return;
+          }
+          const replaced = answer.value.startsWith('(True');
+          const type = /'([^']*)'\)$/.exec(answer.value)?.[1] ?? '';
+          const where = `${command.expression} to Persisted Objects as gemdb.root[${JSON.stringify(command.key)}]${replaced ? ', replacing what was there' : ''}`;
+          tellView('gemdb.savedObjects.notePersisted', {
+            key: command.key,
+            type,
+            ownerKey: pause.ownerKey,
+            notebook: pause.label,
+          });
+          say(
+            `Added ${where}. It is saved when ${pause.label} commits: ` +
+              'type %commit, or click ✓ in Persisted Objects.',
+          );
+          if (this.clientInvalidates) this.event('invalidated', { areas: ['variables'] });
+          done();
+          return;
+        }
+      }
+    } catch (e) {
+      this.fail(request, errorMessage(e), false);
+    }
+  }
+
+  /**
+   * Autocomplete. For a `%` line, GemDB's commands, and after `%persist ` the
+   * console's names. For Python, only Persisted Objects: `persisted.o` while
+   * `o` is typed, and the keys after `persisted.` (`persistedCompletions`).
+   * Python names themselves are not completed here.
+   *
+   * It runs on keystrokes, so it never runs the user's code: the persisted keys
+   * are read once a pause and read again only after a console line, which may
+   * have changed them (`persistedKeysCache`).
+   */
+  private async complete(request: DapRequest): Promise<void> {
+    const text = String(request.arguments?.text ?? '');
+    const column = Number(request.arguments?.column ?? text.length + 1);
+    const before = text.slice(0, Math.max(0, column - 1));
+    const pause = this.pause;
+    if (!pause) {
+      this.respond(request, { targets: [] });
+      return;
+    }
+    if (isConsoleCommand(before)) {
+      const frameId = Number(request.arguments?.frameId ?? pause.frames[0]?.id ?? 1);
+      const names =
+        /^\s*%persist\s+/.test(before) && pause.consoleNames
+          ? (await pause.consoleNames(frameId).catch(() => [])).map((n) => n.name)
+          : [];
+      this.respond(request, { targets: commandCompletions(before, names) });
+      return;
+    }
+    this.respond(request, { targets: persistedCompletions(before, await this.persistedKeys()) });
+  }
+
+  /** What Persisted Objects holds, read once and kept until a console line runs. */
+  private persistedKeys(): Promise<string[]> {
+    const pause = this.pause;
+    if (!pause?.persistedKeys) return Promise.resolve([]);
+    this.persistedKeysCache ??= pause.persistedKeys().catch(() => []);
+    return this.persistedKeysCache;
+  }
+
   dispose(): void {
+    for (const controller of this.running.values()) controller.abort();
     // The session went away without Continue or Stop — a closed window, say.
     // Leaving the evaluation paused would strand its cell, so stop it.
     this.settle('stop');
@@ -778,6 +1303,14 @@ export class PauseDebugAdapter implements vscode.DebugAdapter {
       threadId: THREAD_ID,
       allThreadsStopped: true,
     });
+    // Once a window: where a developer will look next, say that GemDB's commands exist.
+    if (!consoleTip.shown && this.pause?.evaluate) {
+      consoleTip.shown = true;
+      this.event('output', { category: 'console', output: CONSOLE_TIP });
+    }
+    if (this.pause?.openingNote) {
+      this.event('output', { category: 'console', output: this.pause.openingNote });
+    }
   }
 
   /** The first of Continue, Stop or disposal decides; the rest are echoes. */
@@ -866,6 +1399,8 @@ interface PauseView {
   texts: Array<string[] | undefined>;
   /** Registry position of the notebook's or file run's globals; 0 for none. */
   globals: number;
+  /** Where each frame's Debug Console names come from, by DAP frame id. */
+  consoles: Map<number, ConsoleScope>;
 }
 
 /**
@@ -876,6 +1411,8 @@ interface PauseView {
  * notebook's under a frame a cell compiled (`<grail>`), a run file's under its
  * own frames. A frame in an imported module has that module's globals, which
  * Grail does not hand over here, and showing the run's under it would mislead.
+ * Its Debug Console does see them: the console finds the module by its file
+ * when the frame's first line is typed (`consoleQuery`).
  */
 async function readPause(request: HaltRequest): Promise<PauseView> {
   try {
@@ -889,9 +1426,16 @@ async function readPause(request: HaltRequest): Promise<PauseView> {
     );
     const ownFile = owner.kind === 'file' ? runFileOf(owner.key) : '<grail>';
     const scopes = new Map<number, DapScope[]>();
-    frames.forEach((frame, index) =>
-      scopes.set(index + 1, scopesFor(frame.locals ?? 0, frame.file === ownFile ? globals : 0)),
-    );
+    const consoles = new Map<number, ConsoleScope>();
+    frames.forEach((frame, index) => {
+      const own = frame.file === ownFile;
+      scopes.set(index + 1, scopesFor(frame.locals ?? 0, own ? globals : 0));
+      consoles.set(index + 1, {
+        locals: frame.locals ?? 0,
+        globals: own ? globals : 0,
+        ...(!own && frame.file !== '<grail>' ? { moduleFile: frame.file } : {}),
+      });
+    });
     const { running, cells } = notebookCells(owner.key);
     const texts: Array<string[] | undefined> = [];
     return {
@@ -899,10 +1443,11 @@ async function readPause(request: HaltRequest): Promise<PauseView> {
       scopes,
       texts,
       globals,
+      consoles,
     };
   } catch (e) {
     log(`Could not read the stack at a pause: ${errorMessage(e)}`);
-    return { frames: [], scopes: new Map(), texts: [], globals: 0 };
+    return { frames: [], scopes: new Map(), texts: [], globals: 0, consoles: new Map() };
   }
 }
 
@@ -941,6 +1486,25 @@ function remember(listed: ListedRows, ref: number, row: PauseVariable): void {
   else listed.badges.delete(key);
 }
 
+/**
+ * Remember the registry handle of each row as it is listed, and find it again
+ * by its container and name (`Pause.handleFor`): how a command on a row that
+ * does not open, such as an int, reaches its object. For a pause that lists its
+ * rows itself, a saved stack's.
+ */
+export function rowHandles(): {
+  remember(ref: number, rows: PauseVariable[]): void;
+  handleFor(containerRef: number, name: string): number | undefined;
+} {
+  const listed: ListedRows = { handles: new Map(), badges: new Map() };
+  return {
+    remember: (ref, rows) => {
+      for (const row of rows) remember(listed, ref, row);
+    },
+    handleFor: (containerRef, name) => listed.handles.get(handleKey(containerRef, name)),
+  };
+}
+
 /**
  * The children of one registered object. A failure shows as no children, not
  * an error. Each row is remembered (`ListedRows`) for the commands and Set
@@ -994,6 +1558,244 @@ function handleKey(containerRef: number, name: string): string {
   return `${containerRef}\u0000${name}`;
 }
 
+/**
+ * Where a console traceback's frame is, for `jupyterTraceback`: the first
+ * frame is the console's own input; a `<grail>` frame is in the notebook cell
+ * holding its line (`locateCell`, the call stack's own match); anything else
+ * is a file, read from disk.
+ */
+function placeFrame(
+  ownerKey: string,
+  source: string,
+): (frame: TracebackFrame, index: number) => PlacedFrame {
+  const { running, cells } = notebookCells(ownerKey);
+  return (frame, index) => {
+    if (frame.file === '<grail>') {
+      if (index === 0 && frame.name === '<module>') {
+        return { label: 'Debug Console', isFile: false, lines: source.split(/\r?\n/) };
+      }
+      const uri = locateCell(
+        { ...frame, column: 0, endLine: frame.line, endColumn: 0, lineText: frame.text },
+        running,
+        cells,
+      );
+      const cell = cells.find((c) => c.uri === uri);
+      return cell
+        ? { label: cell.label ?? 'Cell', isFile: false, lines: cell.lines }
+        : { label: 'Cell', isFile: false };
+    }
+    if (frame.file === '<string>' || frame.file === '') {
+      return { label: 'Debug Console', isFile: false, lines: source.split(/\r?\n/) };
+    }
+    return { label: `File ${frame.file}`, isFile: true, lines: readFileLines(frame.file) };
+  };
+}
+
+/**
+ * The line the console prints above a bare name's value when it is a Persisted
+ * Objects entry, so it is not mistaken for a name of the paused code's own. A
+ * name of the code's own gets no line: it is what a bare name always means.
+ */
+export function originLine(name: string): string {
+  return `${name} is gemdb.root[${JSON.stringify(name)}], from Persisted Objects (also persisted.${name})\n`;
+}
+
+/** A Python identifier, which a console line can use as a name. */
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const KEYWORDS = new Set([
+  'False',
+  'None',
+  'True',
+  'and',
+  'as',
+  'assert',
+  'async',
+  'await',
+  'break',
+  'class',
+  'continue',
+  'def',
+  'del',
+  'elif',
+  'else',
+  'except',
+  'finally',
+  'for',
+  'from',
+  'global',
+  'if',
+  'import',
+  'in',
+  'is',
+  'lambda',
+  'nonlocal',
+  'not',
+  'or',
+  'pass',
+  'raise',
+  'return',
+  'try',
+  'while',
+  'with',
+  'yield',
+]);
+
+/**
+ * Where a pause's Debug Console runs: the paused session for a live pause, or
+ * the session a saved stack opened again has of its own (`savedObjects.ts`),
+ * whose registry holds the saved frames' names the same way.
+ */
+export interface ConsoleHost {
+  /** Run Smalltalk there, as `HaltRequest.query` does. */
+  query(code: string, options?: PausedQueryOptions): Promise<string>;
+  /** The session owner, for placing a console traceback's frames in cells. */
+  ownerKey: string;
+  /** Where each frame's Debug Console names come from, by DAP frame id. */
+  consoles: Map<number, ConsoleScope>;
+}
+
+/** A pause's Debug Console, run through `host`. */
+export function debugConsole(
+  host: ConsoleHost,
+): Pick<Pause, 'evaluate' | 'showRow' | 'consoleName' | 'consoleNames' | 'persistedKeys'> {
+  const consoleRefs = new Map<number, number>();
+  return {
+    evaluate: (source, frameId, context, signal, selfHandle) =>
+      evaluateAt(host, consoleRefs, source, frameId, context, signal, selfHandle),
+    showRow: (handle, name) => showRowAt(host, handle, name),
+    consoleName: (frameId, name, handle) => consoleNameAt(host, consoleRefs, frameId, name, handle),
+    consoleNames: (frameId) => consoleNamesAt(host, consoleRefs, frameId),
+    persistedKeys: async () => parsePersistedKeys(await host.query(persistedKeysQuery())),
+  };
+}
+
+/** The names bound in one frame's console so far (`Pause.consoleNames`). */
+async function consoleNamesAt(
+  host: ConsoleHost,
+  consoleRefs: Map<number, number>,
+  frameId: number,
+): Promise<Array<{ name: string; type: string; repr: string }>> {
+  const scope = host.consoles.get(frameId) ?? { locals: 0, globals: 0 };
+  const { consoleRef, names } = parseConsoleNames(
+    await host.query(consoleNamesQuery(scope, consoleRefs.get(frameId) ?? 0)),
+  );
+  if (consoleRef > 0) consoleRefs.set(frameId, consoleRef);
+  return names;
+}
+
+/** What to type to reach a shown row's object in one frame's console (`Pause.consoleName`). */
+async function consoleNameAt(
+  host: ConsoleHost,
+  consoleRefs: Map<number, number>,
+  frameId: number,
+  name: string,
+  handle: number,
+): Promise<string> {
+  const scope = host.consoles.get(frameId) ?? { locals: 0, globals: 0 };
+  const usable = IDENTIFIER.test(name) && !KEYWORDS.has(name) ? name : '';
+  const raw = await host.query(
+    consoleNameQuery(scope, consoleRefs.get(frameId) ?? 0, usable, handle),
+  );
+  if (raw.startsWith('Error: ')) throw new Error(raw.slice('Error: '.length));
+  const [ref, typed] = raw.split(' ');
+  if (Number(ref) > 0) consoleRefs.set(frameId, Number(ref));
+  return typed ?? '_';
+}
+
+/** A Variables row's object as a console entry (`Pause.showRow`). */
+async function showRowAt(host: ConsoleHost, handle: number, name: string): Promise<ConsoleAnswer> {
+  const raw = await host.query(describeRowQuery(handle, name));
+  if (raw.startsWith('Error: ')) {
+    return { kind: 'error', output: '', traceback: raw.slice('Error: '.length) };
+  }
+  const [row] = parseChildren(raw);
+  if (!row) return { kind: 'error', output: '', traceback: 'The row could not be read.' };
+  const dap = toDapVariable(row);
+  return {
+    kind: 'value',
+    output: '',
+    // The plain repr, as the console prints a value, without the row's badge.
+    value: row.value,
+    ...(dap.type ? { type: dap.type } : {}),
+    variablesReference: dap.variablesReference,
+    ...(dap.indexedVariables ? { indexedVariables: dap.indexedVariables } : {}),
+    ...(dap.namedVariables ? { namedVariables: dap.namedVariables } : {}),
+    ...(row.kind ? { children: row.kind } : {}),
+  };
+}
+
+/**
+ * Run a Debug Console line or a watch in one frame of a pause (`Pause.evaluate`).
+ * The frame's console scope is made by its first line and found again by
+ * `consoleRefs` after that. A console line runs without the paused queries'
+ * time budget, a watch with it; both run straight past a breakpoint() in
+ * code they call, as debugpy's evaluation does.
+ */
+async function evaluateAt(
+  host: ConsoleHost,
+  consoleRefs: Map<number, number>,
+  source: string,
+  frameId: number,
+  context: ConsoleContext,
+  signal: AbortSignal,
+  selfHandle = 0,
+): Promise<ConsoleAnswer> {
+  const scope = host.consoles.get(frameId) ?? { locals: 0, globals: 0 };
+  const reply = parseConsoleReply(
+    await host.query(
+      consoleQuery(
+        scope,
+        consoleRefs.get(frameId) ?? 0,
+        source,
+        selfHandle,
+        context === 'repl' && IDENTIFIER.test(source.trim()) ? source.trim() : '',
+      ),
+      {
+        budget: context === 'watch',
+        signal,
+        passHalts: true,
+      },
+    ),
+  );
+  if (reply.consoleRef > 0) consoleRefs.set(frameId, reply.consoleRef);
+  const output = reply.output;
+  switch (reply.kind) {
+    case 'value': {
+      const row = toDapVariable(reply.row);
+      return {
+        kind: 'value',
+        output,
+        // A watch is a row and reads as one, type badge and all; a console
+        // line prints the plain repr, as Python's debuggers do.
+        value: context === 'watch' ? row.value : reply.row.value,
+        ...(row.type ? { type: row.type } : {}),
+        variablesReference: row.variablesReference,
+        ...(row.indexedVariables ? { indexedVariables: row.indexedVariables } : {}),
+        ...(row.namedVariables ? { namedVariables: row.namedVariables } : {}),
+        ...(reply.row.kind ? { children: reply.row.kind } : {}),
+        ...(reply.origin ? { origin: reply.origin } : {}),
+      };
+    }
+    case 'none':
+      return { kind: 'value', output, value: '', variablesReference: 0 };
+    case 'interrupted':
+      return { kind: 'interrupted', output };
+    case 'error':
+      return {
+        kind: 'error',
+        output,
+        // A watch row shows one line, and a traceback's first is its rule: a
+        // watch gets the line that says what went wrong instead.
+        traceback:
+          context === 'watch'
+            ? `${reply.error.type}: ${reply.error.message}`
+            : jupyterTraceback(reply.error, placeFrame(host.ownerKey, source)),
+      };
+    case 'failed':
+      return { kind: 'error', output, traceback: reply.message };
+  }
+}
+
 /**
  * Answer every breakpoint() and red dot in this window with a debug session.
  *
@@ -1063,7 +1865,8 @@ export function registerBreakpointDebugger(): vscode.Disposable {
 
         const where = request.reason === 'red dot' ? 'a red dot' : 'breakpoint()';
         log(`${where} in ${label}: paused`);
-        void readPause(request).then(({ frames, scopes, texts, globals }) => {
+        void readPause(request).then((view) => {
+          const { frames, scopes, texts, globals } = view;
           if (settled) return;
           const listed: ListedRows = { handles: new Map(), badges: new Map() };
           pauses.set(id, {
@@ -1077,6 +1880,11 @@ export function registerBreakpointDebugger(): vscode.Disposable {
             answer,
             handleFor: (containerRef, name) => listed.handles.get(handleKey(containerRef, name)),
             query: (code) => request.query(code),
+            ...debugConsole({
+              query: (code, options) => request.query(code, options),
+              ownerKey: request.session.owner.key,
+              consoles: view.consoles,
+            }),
             rearm: (dots) => request.rearm(dots),
             armedDots: request.armedDots,
             reason: request.reason,
diff --git a/src/extension.ts b/src/extension.ts
index 179e580..64798d1 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -34,6 +34,7 @@ import {
 import { collectGarbageCommand, startMaintenance, stopSessionCommand } from './maintenance';
 import { isMcpRunning, startMcpServer, stopMcpServer } from './mcp';
 import { registerBreakpointDebugger } from './debugger';
+import { registerVariableCommands } from './variableCommands';
 import { registerSavedObjects } from './savedObjects';
 import { onSavedStacksChanged } from './savedStacks';
 import { cloneBrainFreeze, initPendingReadme, showPromisedReadme } from './demo';
@@ -192,6 +193,7 @@ export function activate(context: vscode.ExtensionContext): void {
   // paused cell — no Debug command, no launch configuration: the user just
   // runs the code. Continue resumes the cell; Stop ends it.
   context.subscriptions.push(registerBreakpointDebugger());
+  context.subscriptions.push(registerVariableCommands());
 
   // Every command that changes state refreshes the view afterwards, so the
   // status readout can never disagree with what just happened.
diff --git a/src/haltStack.ts b/src/haltStack.ts
index 18cbe44..ed848cb 100644
--- a/src/haltStack.ts
+++ b/src/haltStack.ts
@@ -122,7 +122,9 @@ export interface StackQueryExtras {
  * source records (`___curPosPositionsFromSource___:`). A frame is
  * qualified with its class when its method belongs to a Python class rather
  * than to a module — the receiver-side test Grail's own walk makes, done on
- * the defining class.
+ * the defining class. A classmethod or staticmethod is compiled on the
+ * class's metaclass, whose name reads `Account class`, so the class it
+ * belongs to names it instead: `Account.open`, as CPython says.
  *
  * Each frame is described inside its own error guard: a frame Grail cannot
  * place becomes a `?` row with no line, rather than failing the query and
@@ -166,6 +168,8 @@ both isNil ifFalse: [
     meth := p at: 1.
     home := [meth homeMethod] on: Error do: [:e | meth].
     cls := home inClass.
+    "A classmethod or staticmethod is compiled class-side; its class, not the metaclass, names it."
+    (cls notNil and: [cls isMeta]) ifTrue: [cls := cls thisClass].
     name := (p at: 3) asString.
     (cls notNil and: [modCls notNil and: [(cls inheritsFrom: modCls) not]])
       ifTrue: [name := cls name asString , '.' , name].
diff --git a/src/pauseVariables.ts b/src/pauseVariables.ts
index ad6f621..6ac1b77 100644
--- a/src/pauseVariables.ts
+++ b/src/pauseVariables.ts
@@ -70,8 +70,16 @@ export interface PauseVariable {
   size: number;
   /** The row cannot be changed with Set Value: a tuple's item, a group heading, a method's `self`. */
   readOnly: boolean;
+  /**
+   * How its children are read, when it has any (`CHILDREN_OF`): `seq`, `coll`
+   * and `dict` are containers, `obj` and `ivars` an object's attributes.
+   * Absent on a row with no object, such as a group heading.
+   */
+  kind?: ChildKind;
 }
 
+export type ChildKind = 'seq' | 'coll' | 'dict' | 'obj' | 'ivars';
+
 /**
  * Smalltalk that answers `{kind. source. size}` for an object's children, or
  * nil for a leaf. `kind` is `#seq` (read by position), `#coll` (a set: read in
@@ -135,7 +143,8 @@ const CHILDREN_OF = `
 /**
  * Smalltalk that writes one row for `v`, named `nm`, and registers `v` — as
  * the row's `ref` when it has children, and always as its `handle`. Whether
- * the row can be changed is `ro`, which the caller sets for each row.
+ * the row can be changed is `ro`, which the caller sets for each row. The row
+ * ends with the kind `childrenOf` reads its children by, or nothing for a leaf.
  *
  * Its repr is the user's `__repr__`, run through `reprOf`: a big container
  * shows its size instead (a container only: a module or an object with many
@@ -182,7 +191,8 @@ const DESCRIBE = `
       ifFalse: [out nextPutAll: '0'].
     out nextPut: field; print: idx; nextPut: field; print: named; nextPut: field; print: reg size; nextPut: field.
     out print: (container ifTrue: [n] ifFalse: [-1]);
-      nextPut: field; nextPutAll: (ro == true ifTrue: ['1'] ifFalse: ['0']); nextPut: record]].`;
+      nextPut: field; nextPutAll: (ro == true ifTrue: ['1'] ifFalse: ['0']);
+      nextPut: field; nextPutAll: (kids isNil ifTrue: [''] ifFalse: [kids at: 1]); nextPut: record]].`;
 
 /**
  * Smalltalk for the blocks every row needs.
@@ -285,6 +295,13 @@ SessionTemps current at: #'GrailConsole' put: (Array with: (WriteStream on: Unic
     ifFalse: [SessionTemps current at: #'GrailConsole' put: saved]].`;
 }
 
+/**
+ * The temps `HELPERS`, `CHILDREN_OF` and `DESCRIBE` use beyond the row's own
+ * (`reg out field record none describe childrenOf reprOf late clean
+ * isLeaf`), for a query that writes rows without listing children.
+ */
+const ROW_TEMPS = 'ro isDunder typeNameOf broke classCounts classData isMethodType tooLong';
+
 const PREAMBLE = `field := Character codePoint: 31.
 record := Character codePoint: 30.
 none := System myUserProfile symbolList objectNamed: #'None'.
@@ -598,7 +615,8 @@ export function parseChildren(raw: string): PauseVariable[] {
     .split(RECORD)
     .filter((r) => r.length > 0)
     .map((record): PauseVariable => {
-      const [name, value, type, ref, indexed, named, handle, size, readOnly] = record.split(FIELD);
+      const [name, value, type, ref, indexed, named, handle, size, readOnly, kind] =
+        record.split(FIELD);
       const int = (s: string | undefined): number => Number.parseInt(s ?? '', 10) || 0;
       return {
         name: name ?? '?',
@@ -610,6 +628,7 @@ export function parseChildren(raw: string): PauseVariable[] {
         handle: int(handle),
         size: size === undefined || size === '' ? -1 : int(size),
         readOnly: readOnly === '1',
+        ...(kind ? { kind: kind as ChildKind } : {}),
       };
     });
 }
@@ -969,3 +988,466 @@ ${withQuietConsole(`
 ${LIST_CHILDREN}`)}
 out contents encodeAsUTF8]`;
 }
+
+// ---------------------------------------------------------------------------
+// The Debug Console and the Watch pane.
+// ---------------------------------------------------------------------------
+
+/**
+ * Where a frame's console names come from: its Locals (a registry position,
+ * 0 for none) over its globals. Those are the pause's Globals (a registry
+ * position) for a frame in the notebook's cells or the `.py` run's own file,
+ * and for a frame in an imported module, that module's, found by its file.
+ */
+export interface ConsoleScope {
+  locals: number;
+  globals: number;
+  moduleFile?: string;
+}
+
+/** One frame of a console error's traceback, outermost first. */
+export interface TracebackFrame {
+  /** A real path, or `<grail>` for the console's input or a notebook cell. */
+  file: string;
+  line: number;
+  name: string;
+  /** Text from the frame's line, as Grail's codegen recorded it — often a slice. */
+  text: string;
+}
+
+/** A console line's exception, as data. */
+export interface ConsoleError {
+  /** The type as a traceback's last line names it: `ZeroDivisionError`, `json.JSONDecodeError`. */
+  type: string;
+  message: string;
+  /** Where a SyntaxError could not read: 1-based line and column, and the line. */
+  syntax?: { file: string; line: number; offset: number; text: string };
+  frames: TracebackFrame[];
+}
+
+/**
+ * For a console line that is a bare name: `persisted` when its value is the
+ * Persisted Objects entry of that key, rather than a name of the paused code's
+ * own or one the console bound.
+ */
+export type NameOrigin = 'persisted';
+
+/** What `consoleQuery` answered. */
+export type ConsoleReply = { consoleRef: number; output: string } & (
+  | { kind: 'value'; row: PauseVariable; origin?: NameOrigin }
+  | { kind: 'none' }
+  | { kind: 'error'; error: ConsoleError }
+  | { kind: 'interrupted' }
+  | { kind: 'failed'; message: string }
+);
+
+/**
+ * Smalltalk that finds frame `scope`'s console scope at registry entry
+ * `consoleRef`, or makes it and registers it, leaving it in `console` and its
+ * position in `cref` (`consoleQuery` says what it holds). Needs the temps
+ * `reg dispatcher cref console dict g l bind nameAst none`.
+ */
+function consoleScopeSetup(scope: ConsoleScope, consoleRef: number): string {
+  const findModule = scope.moduleFile
+    ? `g := [dispatcher evaluateSource: '${escapeString(
+        [
+          'import sys as _gemdb_sys',
+          '_gemdb_found = None',
+          'for _gemdb_m in list(_gemdb_sys.modules.values()):',
+          `    if getattr(_gemdb_m, "__file__", None) == ${pythonString(scope.moduleFile)}:`,
+          '        _gemdb_found = _gemdb_m.__dict__',
+          '        break',
+          '_gemdb_found',
+        ].join('\n'),
+      )}' usingModuleScope: SymbolDictionary new]
+      on: AbstractException do: [:e | e return: nil].
+    (g notNil and: [g ~~ none and: [g respondsTo: #keysAndValuesDo:]])
+      ifTrue: [g keysAndValuesDo: [:k :x | bind value: k value: x]].`
+    : '';
+  return `reg := SessionTemps current at: #'${REGISTRY}' otherwise: nil.
+reg isNil ifTrue: [^ 'Error: the pause is over' encodeAsUTF8].
+dispatcher := System myUserProfile symbolList objectNamed: #'ModuleAst'.
+cref := ${consoleRef}.
+nameAst := System myUserProfile symbolList objectNamed: #'NameAst'.
+bind := [:k :x | | nm |
+  nm := k asString asSymbol.
+  nameAst notNil ifTrue: [nm := [nameAst doitScopeNameFor: nm] on: Error do: [:e | e return: nm]].
+  dict at: nm put: x].
+console := (cref between: 1 and: reg size) ifTrue: [reg at: cref] ifFalse: [nil].
+(console class == Array and: [console size = 4 and: [(console at: 1) == #gemdbConsole]]) ifFalse: [| persisted |
+  "Which names came from Persisted Objects, so a bare name typed later can say so."
+  persisted := SymbolDictionary new.
+  dict := SymbolDictionary new.
+  g := (${scope.globals} between: 1 and: reg size) ifTrue: [reg at: ${scope.globals}] ifFalse: [nil].
+  (g class == Array and: [g size >= 2 and: [(g at: 1) == #gemdbScope]])
+    ifTrue: [(g at: 2) keysAndValuesDo: [:k :x | bind value: k value: x]].
+  ${findModule}
+  "The frame's locals over its globals: a local shadows a global of its name."
+  l := (${scope.locals} between: 1 and: reg size) ifTrue: [reg at: ${scope.locals}] ifFalse: [nil].
+  (l class == Array and: [l size >= 2 and: [(l at: 1) == #gemdbScope]])
+    ifTrue: [(l at: 2) keysAndValuesDo: [:k :x | bind value: k value: x]].
+  "gemdb itself, unless the frame has a name of its own spelled so: a line copied from
+   Persisted Objects (gemdb.root[...]) then works in any program, imported or not."
+  (dict includesKey: #gemdb) ifFalse: [
+    g := [dispatcher evaluateSource: 'import gemdb
+gemdb' usingModuleScope: SymbolDictionary new] on: AbstractException do: [:e | e return: nil].
+    g notNil ifTrue: [dict at: #gemdb put: g]].
+  "persisted, the same entries by attribute (persisted.o), there even when o means something else.
+   Made once a session: its class is compiled on first use, and that is a write."
+  (dict includesKey: #persisted) ifFalse: [
+    g := SessionTemps current at: #'GemDbPersistedView' otherwise: nil.
+    g isNil ifTrue: [
+      g := [dispatcher evaluateSource: 'import gemdb
+class PersistedObjects:
+    """What Persisted Objects holds, by name: persisted.o is gemdb.root["o"]."""
+    def __getattr__(self, name):
+        try:
+            return gemdb.root[name]
+        except KeyError:
+            raise AttributeError(f"Persisted Objects has no {name!r}") from None
+    def __getitem__(self, key):
+        return gemdb.root[key]
+    def __dir__(self):
+        return sorted(k for k in gemdb.root.keys() if isinstance(k, str))
+    def __repr__(self):
+        return "Persisted Objects: " + (", ".join(self.__dir__()) or "nothing yet")
+PersistedObjects()' usingModuleScope: SymbolDictionary new]
+        on: AbstractException do: [:e | e return: nil].
+      g notNil ifTrue: [SessionTemps current at: #'GemDbPersistedView' put: g]].
+    g notNil ifTrue: [dict at: #persisted put: g]].
+  "Then what Persisted Objects holds, each under its key: o for gemdb.root['o']. Never over a
+   name the frame has, nor over a builtin (list, print), and only keys that are Python names."
+  g := [dispatcher evaluateSource: 'import gemdb, builtins, keyword
+[(k, v) for k, v in gemdb.root.items() if isinstance(k, str) and k.isidentifier() and not keyword.iskeyword(k) and not hasattr(builtins, k)]' usingModuleScope: SymbolDictionary new]
+    on: AbstractException do: [:e | e return: #()].
+  g do: [:pair | | nm |
+    nm := (pair at: 1) asString asSymbol.
+    nameAst notNil ifTrue: [nm := [nameAst doitScopeNameFor: nm] on: Error do: [:e | e return: nm]].
+    (dict includesKey: nm) ifFalse: [dict at: nm put: (pair at: 2). persisted at: nm put: (pair at: 2)]].
+  "The names it starts with, so the ones the console binds can be told apart (%names)."
+  console := { #gemdbConsole. dict. dict keys copy. persisted }.
+  reg add: console.
+  cref := reg size].
+`;
+}
+
+/**
+ * Smalltalk for **Show in Debug Console**: what to type at the console's
+ * prompt to reach registry entry `handle`'s object. When `name` — a Python
+ * identifier — already means that very object in the frame's console scope
+ * (a Locals or Globals row), the answer is
+ * `name`; otherwise the object is bound to `_`, Python's name for the last
+ * result, and the answer is `_`. Answers `<consoleRef> <name>`, or an
+ * `Error: …` line.
+ */
+export function consoleNameQuery(
+  scope: ConsoleScope,
+  consoleRef: number,
+  name: string,
+  handle: number,
+): string {
+  return `| reg dispatcher cref console dict g l bind nameAst none field record out o key |
+${PREAMBLE}
+${consoleScopeSetup(scope, consoleRef)}
+dict := console at: 2.
+${ROW_OBJECT(handle, 'o')}
+key := nil.
+${
+  name
+    ? `key := '${escapeString(name)}' asSymbol.
+nameAst notNil ifTrue: [key := [nameAst doitScopeNameFor: key] on: Error do: [:e | e return: key]].`
+    : ''
+}
+((key notNil and: [dict includesKey: key]) and: [(dict at: key) == o])
+  ifTrue: [^ (cref printString , ' ${escapeString(name)}') encodeAsUTF8].
+"Bound by Python itself: Grail carries \`_\` under a spelling of its own (measured: a read of a
+ dictionary's #'_' raised NameError for '___unused___')."
+dict at: #'_gemdb_shown' put: o.
+[dispatcher evaluateSource: '_ = _gemdb_shown' usingModuleScope: dict]
+  ensure: [dict removeKey: #'_gemdb_shown' ifAbsent: []].
+(cref printString , ' _') encodeAsUTF8`;
+}
+
+/**
+ * Smalltalk that runs Debug Console or watch input `source` in a frame's
+ * console scope and answers what came of it (`parseConsoleReply`).
+ *
+ * The scope is made on a frame's first line and kept in the pause's registry
+ * as `{#gemdbConsole. dict. startingNames. persisted}`, at `consoleRef` once made, so a name the
+ * console binds (`y = 5`, `import json`, a `def`) is there for the next line
+ * and gone with the registry at resume, as under debugpy. It is one
+ * SymbolDictionary run as a module scope: the frame's globals, copied, with
+ * its locals copied over them, so a local shadows a global as it does in the
+ * frame's own code, and a comprehension or lambda sees the locals — with
+ * locals in a dict of their own, as debugpy evaluates, it would not.
+ * `gemdb` is bound too when the frame has no name of that spelling, so a line
+ * copied from Persisted Objects (`gemdb.root["orders"]`) runs in a program
+ * that never imported it; and so is each entry of `gemdb.root` under its key
+ * (`orders`), below the frame's own names and never over a builtin, so what a
+ * user persisted is there by name at every later pause. `persisted` reaches
+ * the same entries by attribute (`persisted.o`), so a persisted object stays
+ * reachable by a short name when `o` means something else here.
+ * Because they are copies, rebinding a name (`x = 5`) stays in the console;
+ * the objects are the real ones, so `p.x = 10` changes the program's `p`.
+ * A frame's locals are keyed by their Python spelling, but a scope evaluated
+ * this way carries the six names that are Smalltalk pseudo-variables — `self`
+ * above all — under Grail's own stand-in, which `NameAst doitScopeNameFor:`
+ * answers (`___pyresv_self___`), so they are copied in under that; copied as
+ * `self`, a method's `self` read as undefined (measured).
+ *
+ * What the input prints is captured, as `withQuietConsole` does for a
+ * `__repr__`, and answered with the result. An exception is caught from
+ * Smalltalk, where Python never gave it a `__traceback__`; Grail's
+ * `pythonTracebackFrames` walks the stack the raise captured instead, which
+ * is the same walk Python's own outermost handler would have made. A soft
+ * break — the watch's time budget, or the user cancelling — lands as a
+ * ControlInterrupt and is answered as interrupted, not as an error in the
+ * user's code.
+ *
+ * `selfHandle`, when given, is a registry entry to run with as `self` — a
+ * Variables row's object, for **Evaluate with self…**. It is bound in a copy
+ * of the console scope, used for this input alone, so the frame's own `self`
+ * and the names the console has bound are left as they were.
+ */
+export function consoleQuery(
+  scope: ConsoleScope,
+  consoleRef: number,
+  source: string,
+  selfHandle = 0,
+  bareName = '',
+): string {
+  const origin = bareName
+    ? `kind == #value ifTrue: [| key |
+  key := '${escapeString(bareName)}' asSymbol.
+  nameAst notNil ifTrue: [key := [nameAst doitScopeNameFor: key] on: Error do: [:e | e return: key]].
+  (((console at: 4) includesKey: key) and: [((console at: 4) at: key) == r])
+    ifTrue: [origin := 'persisted']].`
+    : '';
+  return `| reg out field record none saved describe childrenOf reprOf late clean isLeaf dispatcher cref console dict g l r kind exc captured bind nameAst target origin ${ROW_TEMPS} |
+${PREAMBLE}
+${HELPERS}
+${CHILDREN_OF}
+${DESCRIBE}
+${consoleScopeSetup(scope, consoleRef)}target := console at: 2.
+${
+  selfHandle > 0
+    ? `${ROW_OBJECT(selfHandle, 'g')}
+dict := target copy.
+bind value: #self value: g.
+target := dict.`
+    : ''
+}
+kind := #value.
+exc := nil.
+captured := WriteStream on: Unicode7 new.
+saved := SessionTemps current at: #'GrailConsole' otherwise: nil.
+SessionTemps current at: #'GrailConsole' put: (Array with: captured).
+[r := [[dispatcher evaluateSource: '${escapeString(source)}' usingModuleScope: target]
+    on: AlmostOutOfStack do: [:e | kind := #stack. e return: nil]]
+  on: AbstractException do: [:e |
+    (e isKindOf: ControlInterrupt)
+      ifTrue: [kind := #interrupted]
+      ifFalse: [kind == #value ifTrue: [kind := #error. exc := e]].
+    e return: nil]]
+  ensure: [
+    saved isNil
+      ifTrue: [SessionTemps current removeKey: #'GrailConsole' ifAbsent: []]
+      ifFalse: [SessionTemps current at: #'GrailConsole' put: saved]].
+(kind == #value and: [r == none or: [r isNil]]) ifTrue: [kind := #none].
+origin := ''.
+${origin}
+out nextPutAll: kind; nextPut: field; print: cref; nextPut: field; nextPutAll: (clean value: captured contents);
+  nextPut: field; nextPutAll: origin; nextPut: record.
+kind == #value ifTrue: [
+  "The result's own row, as the Variables pane would write it, with its __repr__ quiet."
+  SessionTemps current at: #'GrailConsole' put: (Array with: (WriteStream on: Unicode7 new)).
+  [describe value: 'result' value: r] ensure: [
+    saved isNil
+      ifTrue: [SessionTemps current removeKey: #'GrailConsole' ifAbsent: []]
+      ifFalse: [SessionTemps current at: #'GrailConsole' put: saved]]].
+kind == #stack ifTrue: [
+  out nextPutAll: 'RecursionError'; nextPut: field; nextPutAll: 'maximum recursion depth exceeded'; nextPut: record].
+kind == #error ifTrue: [| payload frames tname msg attr sx |
+  attr := [:o :name | [o @env1:___pyAttrLoad___: name] on: AbstractException do: [:e | e return: nil]].
+  payload := [exc ensurePythonTraceback] on: AbstractException do: [:e | e return: exc].
+  frames := [exc pythonTracebackFrames] on: AbstractException do: [:e | e return: #()].
+  tname := [payload ___pythonTypeNameForTraceback___] on: AbstractException do: [:e | e return: exc class name asString].
+  msg := [payload ___safeStrForTraceback___] on: AbstractException do: [:e | e return: exc messageText asString].
+  "A SyntaxError says where it could not read, and str() of one is a tuple: its msg is the message."
+  sx := ((attr value: payload value: #'lineno') isNumber and: [(attr value: payload value: #'text') isString])
+    ifTrue: [{ attr value: payload value: #'filename'. attr value: payload value: #'lineno'.
+      attr value: payload value: #'offset'. attr value: payload value: #'text' }]
+    ifFalse: [nil].
+  (sx notNil and: [(attr value: payload value: #'msg') isString]) ifTrue: [msg := attr value: payload value: #'msg'].
+  out nextPutAll: (clean value: tname asString); nextPut: field; nextPutAll: (clean value: msg asString).
+  sx notNil ifTrue: [
+    out nextPut: field; nextPutAll: (clean value: ((sx at: 1) isString ifTrue: [sx at: 1] ifFalse: [''])); nextPut: field;
+      print: (sx at: 2); nextPut: field;
+      print: ((sx at: 3) isNumber ifTrue: [sx at: 3] ifFalse: [0]); nextPut: field;
+      nextPutAll: (clean value: (sx at: 4))].
+  out nextPut: record.
+  frames do: [:f |
+    out nextPutAll: (clean value: ((f at: 1) ifNil: ['<grail>']) asString); nextPut: field;
+      print: ((f at: 2) isNumber ifTrue: [f at: 2] ifFalse: [0]); nextPut: field;
+      nextPutAll: (clean value: ((f at: 3) ifNil: ['?']) asString); nextPut: field;
+      nextPutAll: (clean value: ((f at: 4) isString ifTrue: [f at: 4] ifFalse: [''])); nextPut: record]].
+out contents encodeAsUTF8`;
+}
+
+/**
+ * Smalltalk that puts in `into` the object of registry entry `handle`, the
+ * one a Variables row was registered with, or answers an `Error: …` line when
+ * there is none — a group row (`class variables`) or a scope is not an object.
+ */
+function ROW_OBJECT(handle: number, into: string): string {
+  return `${into} := (${handle} between: 1 and: reg size) ifTrue: [reg at: ${handle}] ifFalse: [nil].
+(${into} isNil or: [${into} class == Array and: [${into} size >= 2
+    and: [#(#gemdbScope #gemdbGroup #gemdbConsole) includes: (${into} at: 1)]]])
+  ifTrue: [^ 'Error: that row is not an object of its own' encodeAsUTF8].`;
+}
+
+/**
+ * Smalltalk that writes one row, named `name`, for the object of registry
+ * entry `handle` — what **Show in Debug Console** puts in the console — in
+ * `childrenQuery`'s format, or answers an `Error: …` line.
+ */
+export function describeRowQuery(handle: number, name: string): string {
+  return `| reg obj out field record none saved describe childrenOf reprOf late clean isLeaf ${ROW_TEMPS} |
+${PREAMBLE}
+reg := SessionTemps current at: #'${REGISTRY}' otherwise: nil.
+reg isNil ifTrue: [^ 'Error: the pause is over' encodeAsUTF8].
+${ROW_OBJECT(handle, 'obj')}
+${HELPERS}
+${CHILDREN_OF}
+${DESCRIBE}
+${withQuietConsole(`describe value: '${escapeString(name)}' value: obj`)}
+out contents encodeAsUTF8`;
+}
+
+/**
+ * Smalltalk answering the names bound in frame `scope`'s console since it was
+ * made — what the user typed, not the frame's own names — one per record, as
+ * `name`, field, `type`, field, short repr, in their Python spelling (`self`,
+ * not Grail's stand-in). GemDB's own `_gemdb…` names are left out, and so are
+Grail's own `___…___` ones that stay so spelled (a saved stack's console gains
+`___pyGlobals___` after it is made). For
+ * `%names`, and for completing a name after `%persist `.
+ */
+export function consoleNamesQuery(scope: ConsoleScope, consoleRef: number): string {
+  return `| reg dispatcher cref console dict g l bind nameAst none field record out names |
+${PREAMBLE}
+${consoleScopeSetup(scope, consoleRef)}
+dict := console at: 2.
+names := (dict keys reject: [:k | (console at: 3) includes: k]) asSortedCollection: [:a :b | a <= b].
+names do: [:k | | v nm tname text |
+  nm := nameAst isNil ifTrue: [k asString]
+    ifFalse: [[(nameAst doitScopeNameToPythonName: k) asString] on: Error do: [:e | e return: k asString]].
+  "Grail carries Python's _ under a spelling of its own (measured: ___unused___)."
+  nm = '___unused___' ifTrue: [nm := '_'].
+  ((nm size >= 6 and: [(nm copyFrom: 1 to: 6) = '_gemdb'])
+    or: [nm size > 6 and: [(nm copyFrom: 1 to: 3) = '___' and: [(nm copyFrom: nm size - 2 to: nm size) = '___']]])
+      ifFalse: [
+    v := dict at: k.
+    tname := [((v @env1:___pyAttrLoad___: #'__class__') @env1:___pyAttrLoad___: #'__name__') asString]
+      on: AbstractException do: [:e | e return: v class name asString].
+    text := [(v @env1:__repr__) asString] on: AbstractException do: [:e | e return: '?'].
+    text size > 80 ifTrue: [text := (text copyFrom: 1 to: 77) , '...'].
+    out nextPutAll: nm; nextPut: field; nextPutAll: tname; nextPut: field;
+      nextPutAll: (text collect: [:c | (c == field or: [c == record]) ifTrue: [$?] ifFalse: [c]]);
+      nextPut: record]].
+(cref printString , (String with: record) , out contents) encodeAsUTF8`;
+}
+
+/** Parse `consoleNamesQuery`'s answer: the console's position, and its names. */
+export function parseConsoleNames(raw: string): {
+  consoleRef: number;
+  names: Array<{ name: string; type: string; repr: string }>;
+} {
+  if (raw.startsWith('Error: ')) throw new Error(raw.slice('Error: '.length));
+  const [ref = '', ...records] = raw.split(RECORD);
+  return {
+    consoleRef: Number.parseInt(ref, 10) || 0,
+    names: records
+      .filter((r) => r.length > 0)
+      .map((r) => {
+        const [name = '', type = '', repr = ''] = r.split(FIELD);
+        return { name, type, repr };
+      }),
+  };
+}
+
+/**
+ * Smalltalk answering what Persisted Objects holds: the `gemdb.root` keys that
+ * are strings, separated by the field character, for the console's
+ * autocomplete. A read, run in the paused session, so it sees what the run
+ * has added too.
+ */
+export function persistedKeysQuery(): string {
+  return `| keys out |
+keys := [(System myUserProfile symbolList objectNamed: #'ModuleAst') evaluateSource: 'import gemdb
+sorted(k for k in gemdb.root.keys() if isinstance(k, str))' usingModuleScope: SymbolDictionary new]
+  on: AbstractException do: [:e | e return: #()].
+out := WriteStream on: Unicode7 new.
+keys do: [:k | out nextPutAll: k asString] separatedBy: [out nextPut: (Character codePoint: 31)].
+out contents encodeAsUTF8`;
+}
+
+/** Parse `persistedKeysQuery`'s answer. */
+export function parsePersistedKeys(raw: string): string[] {
+  return raw.split(FIELD).filter((k) => k.length > 0);
+}
+
+/** Parse `consoleQuery`'s answer. */
+export function parseConsoleReply(raw: string): ConsoleReply {
+  if (raw.startsWith('Error: ')) {
+    return { consoleRef: 0, output: '', kind: 'failed', message: raw.slice('Error: '.length) };
+  }
+  const [head = '', ...rest] = raw.split(RECORD);
+  const [kind, ref, printed, origin] = head.split(FIELD);
+  const consoleRef = Number.parseInt(ref ?? '', 10) || 0;
+  const output = (printed ?? '').replace(/\r\n?/g, '\n');
+  const records = rest.filter((r) => r.length > 0);
+  if (kind === 'value') {
+    const [row] = parseChildren(records.join(RECORD) + RECORD);
+    if (row) {
+      return {
+        consoleRef,
+        output,
+        kind,
+        row,
+        ...(origin === 'persisted' ? { origin } : {}),
+      };
+    }
+    return { consoleRef, output, kind: 'failed', message: 'The result could not be read.' };
+  }
+  if (kind === 'none' || kind === 'interrupted') return { consoleRef, output, kind };
+  if (kind === 'error' || kind === 'stack') {
+    const [type = '', message = '', file, line, offset, text] = (records[0] ?? '').split(FIELD);
+    const int = (s: string | undefined): number => Number.parseInt(s ?? '', 10) || 0;
+    const frames = records.slice(1).map((record): TracebackFrame => {
+      const [frameFile, frameLine, name, frameText] = record.split(FIELD);
+      return {
+        file: frameFile || '<grail>',
+        line: int(frameLine),
+        name: name || '?',
+        text: frameText ?? '',
+      };
+    });
+    return {
+      consoleRef,
+      output,
+      kind: 'error',
+      error: {
+        type,
+        message,
+        ...(line === undefined
+          ? {}
+          : {
+              syntax: { file: file ?? '', line: int(line), offset: int(offset), text: text ?? '' },
+            }),
+        frames,
+      },
+    };
+  }
+  return { consoleRef, output, kind: 'failed', message: raw || 'The console got no answer.' };
+}
diff --git a/src/savedObjects.ts b/src/savedObjects.ts
index ec4ac78..0ca2fbc 100644
--- a/src/savedObjects.ts
+++ b/src/savedObjects.ts
@@ -1,21 +1,24 @@
 import * as vscode from 'vscode';
 import {
+  ConsoleHost,
   Pause,
+  debugConsole,
   openCellTexts,
   openPause,
   pauseForDebugSession,
   pauseForOwner,
+  rowHandles,
   toDapVariable,
 } from './debugger';
 import { errorMessage, log } from './log';
 import { runFileOf } from './fileOwner';
 import {
+  ConsoleScope,
   MAIN_MODULE,
   PauseVariable,
   ROOT_LISTING_LIMIT,
   abortQuery,
   childrenQuery,
-  clearRegistryQuery,
   commitQuery,
   freeKeyQuery,
   inspectQuery,
@@ -32,6 +35,7 @@ import {
 } from './pauseVariables';
 import { isRunning, listProcesses } from './processes';
 import {
+  SAVED_STACK_NOTE,
   liveSourceWorld,
   openStackQuery,
   parseOpenedStack,
@@ -44,7 +48,16 @@ import {
   savedStackKeysQuery,
   stackKeyFor,
 } from './savedStacks';
-import { SessionOwner, executeAsync, sessionForIfOpen, sessionRegistry } from './session';
+import {
+  PAUSED_QUERY_BUDGET_MS,
+  SessionOwner,
+  closeSessionFor,
+  executeAsync,
+  interruptSessionFor,
+  sessionFor,
+  sessionForIfOpen,
+  sessionRegistry,
+} from './session';
 
 /**
  * Run Smalltalk in the extension's own session, one query at a time. The
@@ -775,7 +788,7 @@ async function targetOf(
 ): Promise<{ notebook: NotebookState; saves: PendingSave[] } | undefined> {
   if (clicked) return view.notebookOf(clicked);
   const connected = sessionRegistry()
-    .filter((info) => info.owner.kind === 'notebook' || info.owner.kind === 'file')
+    .filter((info) => ['notebook', 'file', 'stack'].includes(info.owner.kind))
     .map((info) => info.owner);
   if (connected.length === 0) {
     void vscode.window.showInformationMessage(
@@ -1027,11 +1040,110 @@ function setSavedStackOpen(open: boolean): void {
   void vscode.commands.executeCommand('setContext', 'gemdb.savedStackOpen', open);
 }
 
+/** The session a saved stack works in while it is open: one of its own, as a notebook has. */
+export function stackOwner(key: string): SessionOwner {
+  return { key: `saved-stack:${key}`, kind: 'stack', label: `Saved stack ${key}` };
+}
+
+/**
+ * Run Smalltalk in `owner`'s session, one query at a time, cut short as a
+ * paused query is (`PausedQueryOptions`): soft-broken when `signal` aborts
+ * and, with `budget`, every `PAUSED_QUERY_BUDGET_MS`.
+ */
+export function stackQuery(owner: SessionOwner): ConsoleHost['query'] {
+  let chain: Promise<unknown> = Promise.resolve();
+  return (code, { budget = true, signal } = {}) => {
+    let running = false;
+    const interrupt = (): void => {
+      if (running) interruptSessionFor(owner.key);
+    };
+    const run = chain.then(async () => {
+      running = true;
+      signal?.addEventListener('abort', interrupt);
+      const timer = budget ? setInterval(interrupt, PAUSED_QUERY_BUDGET_MS) : undefined;
+      if (signal?.aborted) interrupt();
+      try {
+        return await sessionFor(owner).executeAsync(code);
+      } finally {
+        running = false;
+        clearInterval(timer);
+        signal?.removeEventListener('abort', interrupt);
+      }
+    });
+    chain = run.catch(() => undefined);
+    return run;
+  };
+}
+
+/**
+ * A saved stack's Debug Console, in the stack's own session. Each frame's
+ * console is made first and what that wrote is undone (making one writes,
+ * measured: a frame's first line always left something to commit, the same
+ * line again never), so the session starts with nothing to commit, and what it
+ * has to commit later is only what the user changed — what closing the stack
+ * asks about.
+ */
+export async function savedStackConsole(
+  query: ConsoleHost['query'],
+  ownerKey: string,
+  consoles: Map<number, ConsoleScope>,
+): Promise<ReturnType<typeof debugConsole>> {
+  const con = debugConsole({ query, ownerKey, consoles });
+  for (const frameId of consoles.keys()) {
+    await con.evaluate!('None', frameId, 'repl', new AbortController().signal).catch(
+      () => undefined,
+    );
+  }
+  await query(`System abortTransaction. 'aborted' encodeAsUTF8`, { budget: false });
+  return con;
+}
+
+/**
+ * Close a saved stack's session when its debugger ends. Changes made in its
+ * Debug Console and not committed are asked about first: committing them
+ * changes the saved stack for good, and closing the session discards them.
+ */
+async function closeSavedStack(
+  key: string,
+  owner: SessionOwner,
+  query: ConsoleHost['query'],
+): Promise<void> {
+  try {
+    if ((await query(needsCommitQuery(), { budget: false })) === 'true') {
+      const commit = 'Commit';
+      const choice = await vscode.window.showWarningMessage(
+        `${accessCode(key)} has changes made in the Debug Console that are not committed.`,
+        {
+          modal: true,
+          detail:
+            'Commit saves them, and the saved stack keeps the changed values from now on. ' +
+            'Otherwise they are discarded, and the stack stays as it was saved.',
+        },
+        commit,
+      );
+      if (choice === commit) orThrow(await query(commitQuery(), { budget: false }));
+    }
+  } catch (e) {
+    void vscode.window.showErrorMessage(
+      `Could not commit the changes to ${accessCode(key)}: ${errorMessage(e)}`,
+    );
+  } finally {
+    closeSessionFor(owner.key);
+    // What it had added to Persisted Objects and not committed went with it.
+    Promise.resolve(vscode.commands.executeCommand('gemdb.savedObjects.refresh')).catch(
+      () => undefined,
+    );
+  }
+}
+
 /**
  * Open a committed saved stack in Run and Debug: the Call Stack, the
- * highlighted lines and the Variables, rebuilt from the objects saved with
- * it, read-only. Each frame shows the copy of its source saved with it, never
- * the live cell or file.
+ * highlighted lines and the Variables, rebuilt from the objects saved with it,
+ * and a Debug Console on them. It gets a session of its own
+ * (`stackOwner`), so what its console changes waits there, as a notebook's
+ * changes do, until `%commit` or ✓ commits it or closing the stack discards
+ * it. Each frame shows the copy of its source saved with it, never the live
+ * cell or file.
  */
 async function openSavedStack(key: string): Promise<void> {
   if (savedStackOpen) {
@@ -1040,39 +1152,51 @@ async function openSavedStack(key: string): Promise<void> {
     );
     return;
   }
+  const owner = stackOwner(key);
+  const query = stackQuery(owner);
+  setSavedStackOpen(true);
+  let started = false;
   try {
-    const { meta, locals, globals } = parseOpenedStack(await extensionQuery(openStackQuery(key)));
-    const { frames, scopes, texts } = restoredFrames(
+    const { meta, locals, globals } = parseOpenedStack(
+      await query(openStackQuery(key), { budget: false }),
+    );
+    const { frames, scopes, texts, consoles } = restoredFrames(
       meta,
       locals,
       globals,
       liveSourceWorld(openCellTexts),
     );
-    setSavedStackOpen(true);
+    const con = await savedStackConsole(query, owner.key, consoles);
+    const rows = rowHandles();
     const pause: Pause = {
       label: savedPauseLabel(meta),
+      ownerKey: owner.key,
       frames,
       scopes: (frameId) => scopes.get(frameId) ?? [],
       variables: async (ref, start, count) => {
         try {
-          // Read-only: a saved stack's objects are committed copies, with no run to change.
-          return parseChildren(await extensionQuery(childrenQuery(ref, start, count))).map((row) =>
-            toDapVariable({ ...row, readOnly: true }),
-          );
+          // Set Value is not offered here: the Debug Console is where a saved stack is changed.
+          const children = parseChildren(await query(childrenQuery(ref, start, count)));
+          rows.remember(ref, children);
+          return children.map((row) => toDapVariable({ ...row, readOnly: true }));
         } catch (e) {
           log(`Could not read a saved stack's variable ${ref}: ${errorMessage(e)}`);
           return [];
         }
       },
+      handleFor: rows.handleFor,
+      query: (code) => query(code, { budget: false }),
       answer: () => {
         setSavedStackOpen(false);
-        extensionQuery(clearRegistryQuery()).catch(() => undefined);
+        void closeSavedStack(key, owner, query);
       },
+      ...con,
       sourceText: (ref) => texts.get(ref),
-      description: `Saved stack from ${meta.saved_at} (read-only)`,
+      openingNote: SAVED_STACK_NOTE,
+      description: `Saved stack from ${meta.saved_at}`,
       saved: true,
     };
-    const started = await openPause(pause);
+    started = await openPause(pause);
     if (!started) {
       void vscode.window.showErrorMessage(
         `GemDB could not open ${accessCode(key)} in the debugger.`,
@@ -1084,8 +1208,12 @@ async function openSavedStack(key: string): Promise<void> {
       await vscode.commands.executeCommand('workbench.view.debug');
     }
   } catch (e) {
-    setSavedStackOpen(false);
     void vscode.window.showErrorMessage(`Could not open the saved stack: ${errorMessage(e)}`);
+  } finally {
+    if (!started) {
+      setSavedStackOpen(false);
+      closeSessionFor(owner.key);
+    }
   }
 }
 
@@ -1159,6 +1287,20 @@ export function registerSavedObjects(context: vscode.ExtensionContext): SavedObj
       saveVariable(view, treeViews, ctx),
     ),
     vscode.commands.registerCommand('gemdb.savedObjects.refresh', () => view.refresh()),
+    // Internal, for `%persist` in the Debug Console (`debugger.ts`): show the
+    // save as pending, as Add to Persisted Objects does.
+    vscode.commands.registerCommand(
+      'gemdb.savedObjects.notePersisted',
+      (save: Omit<PendingSave, 'at'>) => {
+        view.notePending({ ...save, at: new Date().toISOString() });
+        const shown = treeViews.get(DEBUG_VIEW_ID);
+        if (shown) {
+          view
+            .revealSaved(shown, save.key)
+            .catch((e: unknown) => log(`Could not show ${save.key}: ${errorMessage(e)}`));
+        }
+      },
+    ),
     vscode.commands.registerCommand('gemdb.saveStack', () => saveStack(view, treeViews)),
     vscode.commands.registerCommand('gemdb.restoreStack', () => restoreStack()),
     vscode.commands.registerCommand('gemdb.savedObjects.openStack', (row: SavedRow) =>
diff --git a/src/savedStacks.ts b/src/savedStacks.ts
index 5447001..c5a1bf2 100644
--- a/src/savedStacks.ts
+++ b/src/savedStacks.ts
@@ -4,7 +4,7 @@ import * as vscode from 'vscode';
 import { DapFrame, DapScope, Pause, scopesFor } from './debugger';
 import { FIELD } from './haltStack';
 import { runFileOf } from './fileOwner';
-import { MAIN_MODULE, MainModule, REGISTRY } from './pauseVariables';
+import { ConsoleScope, MAIN_MODULE, MainModule, REGISTRY } from './pauseVariables';
 import { escapeString } from './pythonQueries';
 
 /**
@@ -15,8 +15,11 @@ import { escapeString } from './pythonQueries';
  * This is a **snapshot**, not a continuation: each frame's name, position and
  * full source text, its locals as the real objects, and the notebook's
  * globals. Opening it rebuilds the Call Stack and Variables views from those
- * objects, read-only. Nothing is resumed — there is no process to resume —
- * so Continue and Stop just close it.
+ * objects, in a session of the stack's own, with a Debug Console on them
+ * (`savedObjects.ts`). Variables are read-only there; a console line can
+ * change the objects, which a commit then writes into the saved stack. Nothing
+ * is resumed — there is no process to resume — so Continue and Stop just
+ * close it.
  *
  * It is stored as an ordinary dict (`"kind": "gemdb.stack"`), so the
  * Persisted Objects view lists, commits, inspects and removes it like any
@@ -163,9 +166,9 @@ r encodeAsUTF8`;
 }
 
 /**
- * Smalltalk, for the extension's own session, that reads a committed saved
- * stack and registers its frames' locals and its globals for the Variables
- * view. Answers the stack's metadata as JSON, then each frame's locals ref,
+ * Smalltalk, for the session a saved stack is opened in, that reads it and
+ * registers its frames' locals and its globals for the Variables view and the
+ * Debug Console. Answers the stack's metadata as JSON, then each frame's locals ref,
  * then the globals ref (0 for none), separated by the field character.
  */
 export function openStackQuery(key: string): string {
@@ -205,6 +208,15 @@ g := r at: 3.
 out contents encodeAsUTF8`;
 }
 
+/**
+ * What a saved stack's Debug Console says when the stack opens. Its objects
+ * are the stack's own, so a commit of a change made there writes into the
+ * saved stack. It starts with a badge in black on yellow (ANSI codes, which
+ * the Debug Console renders), so a glance tells a saved stack from a live run.
+ */
+export const SAVED_STACK_NOTE =
+  '\u001b[30;43m SAVED STACK \u001b[0m Changes stay uncommitted until %commit, which overwrites what was saved.\n';
+
 /** Parse `openStackQuery`'s answer. */
 export function parseOpenedStack(raw: string): {
   meta: SavedStackMeta;
@@ -315,15 +327,26 @@ export function restoredSource(
     : undefined;
 }
 
-/** The debugger's view of a saved stack: frames, scopes and the saved texts behind them. */
+/**
+ * The debugger's view of a saved stack: frames, scopes, the saved texts behind
+ * them, and where each frame's Debug Console finds its names — as a live
+ * pause's console does, a frame in an imported module looks that module up by
+ * its file.
+ */
 export function restoredFrames(
   meta: SavedStackMeta,
   locals: number[],
   globals: number,
   world: SourceWorld,
-): { frames: DapFrame[]; scopes: Map<number, DapScope[]>; texts: Map<number, string> } {
+): {
+  frames: DapFrame[];
+  scopes: Map<number, DapScope[]>;
+  texts: Map<number, string>;
+  consoles: Map<number, ConsoleScope>;
+} {
   const scopes = new Map<number, DapScope[]>();
   const texts = new Map<number, string>();
+  const consoles = new Map<number, ConsoleScope>();
   const frames = meta.frames.map((frame, index): DapFrame => {
     const id = index + 1;
     const source = restoredSource(frame, id, world, meta.saved_at);
@@ -334,6 +357,11 @@ export function restoredFrames(
       frame.path.startsWith('vscode-notebook-cell:') ||
       frame.path === runFileOf(meta.notebook);
     scopes.set(id, scopesFor(locals[index] ?? 0, ownFrame ? globals : 0));
+    consoles.set(id, {
+      locals: locals[index] ?? 0,
+      globals: ownFrame ? globals : 0,
+      ...(!ownFrame && frame.path ? { moduleFile: frame.path } : {}),
+    });
     return {
       id,
       name: frame.name,
@@ -343,7 +371,7 @@ export function restoredFrames(
       ...(source ? { source } : { presentationHint: 'subtle' as const }),
     };
   });
-  return { frames, scopes, texts };
+  return { frames, scopes, texts, consoles };
 }
 
 /** The world as it is: the disk, and the notebooks open in this window. */
diff --git a/src/session.ts b/src/session.ts
index 3ae3fde..e390cea 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -85,7 +85,7 @@ const SESSION_LIMIT_ERRORS = new Set([4039, 4041, 4050]);
 const GCI_LOGIN_QUIET = 0x10;
 
 /** What kind of user interface a session belongs to. */
-export type SessionKind = 'notebook' | 'file' | 'shell' | 'extension';
+export type SessionKind = 'notebook' | 'file' | 'shell' | 'extension' | 'stack';
 
 /**
  * Who a session is for.
@@ -138,6 +138,7 @@ const CACHE_NAME_TAGS: Record<SessionKind, string> = {
   file: 'GemDB py',
   shell: 'GemDB Shell',
   extension: 'GemDB Code',
+  stack: 'GemDB stack',
 };
 
 /**
@@ -304,15 +305,32 @@ export interface HaltRequest {
   /**
    * Run Smalltalk while the evaluation stays paused — what the debugger reads
    * the stack and the Variables with. Nonblocking, one query at a time, and
-   * soft-broken past a time budget; see `queryWhilePaused`. Refused once the
-   * pause is settled.
+   * soft-broken past a time budget unless `options` says otherwise; see
+   * `queryWhilePaused`. Refused once the pause is settled.
    */
-  query(code: string): Promise<string>;
+  query(code: string, options?: PausedQueryOptions): Promise<string>;
   /** Runs if the evaluation is interrupted or its session closed while paused,
    * so the handler can take down its debugger (the halt is already answered). */
   onCancel(callback: () => void): void;
 }
 
+/**
+ * How a query while paused runs. The defaults suit a Variables row: a two-second
+ * budget, and a query that reaches breakpoint() fails. The Debug Console asks for
+ * the opposite of both.
+ */
+export interface PausedQueryOptions {
+  /** Soft-break the query every `PAUSED_QUERY_BUDGET_MS`. Default true. */
+  budget?: boolean;
+  /** Soft-break the query when this aborts. */
+  signal?: AbortSignal;
+  /**
+   * Run straight past a breakpoint() or red dot the query reaches, as
+   * debugpy and PyCharm do for an evaluation, rather than failing. Default false.
+   */
+  passHalts?: boolean;
+}
+
 export type HaltHandler = (request: HaltRequest) => Promise<HaltAnswer>;
 
 let haltHandler: HaltHandler | undefined;
@@ -484,7 +502,7 @@ const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout
  * then how often it is broken again. A Variables row runs the user's own
  * `__repr__`, and one that never returns must not wedge the pause.
  */
-const PAUSED_QUERY_BUDGET_MS = 2000;
+export const PAUSED_QUERY_BUDGET_MS = 2000;
 
 /**
  * One logged-in session.
@@ -898,16 +916,19 @@ export class GciSession {
    * returned would freeze the extension host with no way to send a break.
    * Past `PAUSED_QUERY_BUDGET_MS` the query is soft-broken, again each budget
    * after; the Variables query catches that break around a `__repr__` and
-   * shows the rest without one.
+   * shows the rest without one. A Debug Console line runs without the budget
+   * and is broken only when its `signal` aborts (`PausedQueryOptions`).
    *
    * Queries run one at a time, chained, and the paused evaluation waits for
    * the chain before it resumes or ends. A query that itself stops — a
    * `__repr__` that reached breakpoint() or input(), or a break nothing
    * caught — has its stack cleared, which runs its `ensure:` blocks, and
-   * fails.
+   * fails; with `passHalts`, a breakpoint() is run past instead.
    */
-  private queryWhilePaused(code: string): Promise<string> {
-    const run = this.pausedQueries.then(() => this.runPausedQuery(code));
+  private queryWhilePaused(code: string, options: PausedQueryOptions = {}): Promise<string> {
+    const run = this.pausedQueries.then(() =>
+      this.runPausedQuery(code, options.budget ?? true, options),
+    );
     this.pausedQueries = run.then(
       () => undefined,
       () => undefined,
@@ -915,16 +936,44 @@ export class GciSession {
     return run;
   }
 
-  private async runPausedQuery(code: string, softBreak = true): Promise<string> {
+  private async runPausedQuery(
+    code: string,
+    softBreak = true,
+    { signal, passHalts = false }: PausedQueryOptions = {},
+  ): Promise<string> {
     const handle = this.requireHandle();
     let deadline = Date.now() + PAUSED_QUERY_BUDGET_MS;
     this.pausedQueryRunning = true;
+    // A soft break, like the budget's: the query catches it where it can and
+    // says it was interrupted, rather than losing its stack.
+    const onAbort = (): void => {
+      if (this.handle !== undefined) this.gci.GciTsBreak(handle, false);
+    };
+    if (signal?.aborted) onAbort();
+    signal?.addEventListener('abort', onAbort);
     try {
-      const { result: oop, err } = await this.submitAndWait(handle, code, () => {
+      let { result: oop, err } = await this.submitAndWait(handle, code, () => {
         if (!softBreak || Date.now() < deadline) return;
         deadline = Date.now() + PAUSED_QUERY_BUDGET_MS;
         this.gci.GciTsBreak(handle, false);
       });
+      // A breakpoint() or a red dot in code the query ran: go on past it. The
+      // run's flags stay 0, as every paused query's do, so no red dot fires and
+      // only breakpoint()'s Halt arrives here; BREAKPOINT is passed for safety.
+      while (
+        passHalts &&
+        oop === OOP_ILLEGAL &&
+        (err.number === HALT || err.number === BREAKPOINT) &&
+        isProcess(err.context)
+      ) {
+        ({ result: oop, err } = await this.gci.GciTsContinueWithAsync(
+          handle,
+          err.context,
+          OOP_ILLEGAL,
+          null,
+          0,
+        ));
+      }
       if (oop === OOP_ILLEGAL) {
         if (isProcess(err.context)) this.gci.GciTsClearStack(handle, err.context);
         throw new SessionError(err.message || 'The query failed.');
@@ -933,6 +982,7 @@ export class GciSession {
     } catch (e) {
       throw this.asSessionError(e);
     } finally {
+      signal?.removeEventListener('abort', onAbort);
       this.pausedQueryRunning = false;
     }
   }
@@ -1126,10 +1176,10 @@ export class GciSession {
           this.gci.GciTsBreak(this.handle, false);
         }
       };
-      const query = (code: string): Promise<string> =>
+      const query = (code: string, options?: PausedQueryOptions): Promise<string> =>
         settled
           ? Promise.reject(new SessionError('The pause is over.'))
-          : this.queryWhilePaused(code);
+          : this.queryWhilePaused(code, options);
       handler({
         session: this,
         process,
diff --git a/src/variableCommands.ts b/src/variableCommands.ts
new file mode 100644
index 0000000..4390956
--- /dev/null
+++ b/src/variableCommands.ts
@@ -0,0 +1,131 @@
+import * as vscode from 'vscode';
+import { DEBUG_TYPE, pauseForDebugSession } from './debugger';
+import { errorMessage } from './log';
+
+/**
+ * Two items on a Variables row's menu, each ending in the Debug Console:
+ *
+ * - **Show in Debug Console** puts the row's object there — an object with
+ *   its attributes listed, a container as one row that opens — so the next
+ *   line can be typed beside it without first clicking over to the console.
+ * - **Evaluate with self…** asks for an expression and runs it with `self`
+ *   bound to the row's object — `len(self.history)` on any row, however deep
+ *   — in the frame selected in Call Stack, as a console line runs.
+ *
+ * The row's object is reached the way **Add to Persisted Objects…** reaches
+ * it: by its registry handle (`Pause.handleFor`), not by a Python path, so a
+ * row nested deep in the tree needs no expression to name it. The work is the
+ * adapter's `gemdbShowRow` request (`PauseDebugAdapter.showRow`), sent through
+ * the debug session so the output lands in that session's console.
+ */
+
+export const SHOW_IN_CONSOLE = 'gemdb.showInDebugConsole';
+export const EVALUATE_WITH_SELF = 'gemdb.evaluateWithSelf';
+
+/** What VS Code hands a `debug/variables/context` command. */
+export interface VariableContext {
+  sessionId?: string;
+  container?: { variablesReference?: number };
+  variable?: { name: string; value: string; variablesReference: number };
+}
+
+const NOT_PAUSED =
+  'This works on a variable in Run and Debug, while a GemDB notebook cell or Debug Python File ' +
+  'run is paused in the debugger.';
+
+/** The paused session, and the right-clicked row's name and registry handle; undefined after saying why. */
+function rowTarget(
+  context: VariableContext,
+): { session: vscode.DebugSession; name: string; handle: number } | undefined {
+  const session = vscode.debug.activeDebugSession;
+  const pause = pauseForDebugSession(context.sessionId ?? session?.id);
+  const variable = context.variable;
+  if (
+    !session ||
+    session.type !== DEBUG_TYPE ||
+    (context.sessionId !== undefined && session.id !== context.sessionId) ||
+    !pause ||
+    !variable
+  ) {
+    void vscode.window.showErrorMessage(NOT_PAUSED);
+    return undefined;
+  }
+  const handle =
+    variable.variablesReference > 0
+      ? variable.variablesReference
+      : pause.handleFor?.(context.container?.variablesReference ?? 0, variable.name);
+  if (!handle) {
+    void vscode.window.showErrorMessage(`"${variable.name}" is not an object of its own.`);
+    return undefined;
+  }
+  return { session, name: variable.name, handle };
+}
+
+/** The frame selected in Call Stack, when it is in this session. */
+function selectedFrame(session: vscode.DebugSession): number | undefined {
+  const item = vscode.debug.activeStackItem;
+  return item instanceof vscode.DebugStackFrame && item.session.id === session.id
+    ? item.frameId
+    : undefined;
+}
+
+async function showRow(session: vscode.DebugSession, args: Record<string, unknown>): Promise<void> {
+  // The console first, so a line that takes a while is seen to be running.
+  await vscode.commands.executeCommand('workbench.debug.action.focusRepl');
+  try {
+    const body = (await session.customRequest('gemdbShowRow', args)) as
+      { typed?: string } | undefined;
+    // VS Code offers no way to set the console's input; focusRepl leaves the
+    // focus in it, and `type` inserts into whichever editor has the focus.
+    if (body?.typed) await vscode.commands.executeCommand('type', { text: body.typed });
+  } catch (e) {
+    void vscode.window.showErrorMessage(errorMessage(e));
+  }
+}
+
+/**
+ * Show the right-clicked row's object in the Debug Console, and leave its
+ * name at the console's prompt — or `_`, bound to it, when its name means
+ * nothing there — so the next line can do something with it.
+ */
+export async function showInDebugConsole(context: VariableContext): Promise<void> {
+  const target = rowTarget(context);
+  if (!target) return;
+  const frameId = selectedFrame(target.session);
+  await showRow(target.session, {
+    handle: target.handle,
+    name: target.name,
+    ...(frameId === undefined ? {} : { frameId }),
+  });
+}
+
+/** Ask for an expression and show what it gives with `self` bound to the right-clicked row's object. */
+export async function evaluateWithSelf(context: VariableContext): Promise<void> {
+  const target = rowTarget(context);
+  if (!target) return;
+  const expression = await vscode.window.showInputBox({
+    title: `Evaluate with self = ${target.name}`,
+    prompt: `Python, with self bound to ${target.name}. The result opens in the Debug Console.`,
+    value: 'self',
+    ignoreFocusOut: true,
+  });
+  if (expression === undefined || !expression.trim()) return;
+  const frameId = selectedFrame(target.session);
+  await showRow(target.session, {
+    handle: target.handle,
+    name: target.name,
+    expression,
+    ...(frameId === undefined ? {} : { frameId }),
+  });
+}
+
+export function registerVariableCommands(): vscode.Disposable {
+  return vscode.Disposable.from(
+    vscode.commands.registerCommand(SHOW_IN_CONSOLE, (context: VariableContext) =>
+      showInDebugConsole(context),
+    ),
+    vscode.commands.registerCommand(EVALUATE_WITH_SELF, (context: VariableContext) =>
+      evaluateWithSelf(context),
+    ),
+  );
+}