Tighten XEUS status-field guard and extend to cleanup cell

e.args tuple comparison survives any upstream change to KeyError
message formatting, which str(e) equality would silently miss.

The cell source in the synthetic traceback field was redundant with
the rendered output — the source is already shown next to the error
block — and inflated error output for large cells. Traceback entries
are conventionally stack frames, not source dumps.

The kernel-deps cleanup_cell execute_cell call has the same exposure:
any XEUS-based Python kernel (e.g. xeus-python) would hit it via
cleanup.py. Guarded symmetrically but non-fatally, since cleanup
failures shouldn't abort the render.

Author: cderv

news/changelog-1.10.md

@@ -48,6 +48,12 @@ All changes included in 1.10:
 
 - ([#14297](https://github.com/quarto-dev/quarto-cli/pull/14297)): Fix `quarto.utils.is_empty_node()` returning inverted results for text nodes (`Str`, `Code`, `RawInline`).
 
+## Engines
+
+### Jupyter
+
+- ([#14374](https://github.com/quarto-dev/quarto-cli/pull/14374)): Avoid a crash when a XEUS-based kernel (e.g. Maple 2025) returns `execute_reply` without the required `status` field. The failing cell is recorded as an error instead of aborting the render. (author: @ChrisJefferson)
+
 ## Other fixes and improvements
 
 - ([#6651](https://github.com/quarto-dev/quarto-cli/issues/6651)): Fix dart-sass compilation failing in enterprise environments where `.bat` files are blocked by group policy.

src/resources/jupyter/notebook.py

@@ -380,9 +380,18 @@ def handle_meta_object(obj):
     if cleanup_cell:
         kernel_supports_daemonization = True
         nb.cells.append(cleanup_cell)
-        client.execute_cell(
-            cell=cleanup_cell, cell_index=len(client.nb.cells) - 1, store_history=False
-        )
+        try:
+            client.execute_cell(
+                cell=cleanup_cell, cell_index=len(client.nb.cells) - 1, store_history=False
+            )
+        except KeyError as e:
+            # Same XEUS-based protocol violation as in cell_execute.
+            # Cleanup failures are non-fatal: trace and continue so the
+            # render still completes (kernel deps just won't be collected).
+            if e.args == ("status",):
+                trace("cleanup cell failed with missing 'status' in execute_reply; kernel deps unavailable")
+            else:
+                raise
         nb.cells.pop()
 
         # record kernel deps after execution (picks up imports that occurred
@@ -574,12 +583,12 @@ def cell_execute(client, cell, index, execution_count, eval_default, store_histo
             # Some kernels (e.g. XEUS-based Maple) omit 'status' from
             # execute_reply on error, violating the Jupyter protocol.
             # Record the error in the cell outputs rather than crashing.
-            if str(e) == "'status'":
+            if e.args == ("status",):
                 cell.outputs.append(nbformat.v4.new_output(
                     output_type="error",
                     ename="KernelProtocolError",
                     evalue="Kernel returned execute_reply without status field",
-                    traceback=["Cell source:", source],
+                    traceback=[],
                 ))
             else:
                 raise