🟠 P1 (Important — should fix)

1. Staging fail-loud has a hole: comment-prefixed staging statements aren't detected → re-opens the silent-no-op data bug — kernel/client.py:85-90, 396. _is_staging_statement takes the first
   whitespace-delimited token without stripping SQL comments. I reproduced it: '-- upload\nPUT ... INTO ...' → False, '/* c / PUT ...' → False. A comment-prefixed staging op (common in ETL) flows into
   stmt.execute(), and since kernel KernelResultSet.is_staging_operation is hardcoded False, _handle_staging_operation never fires — the exact silent stale/missing-data bug this PR exists to close. (Thrift
   classifies staging server-side via isStagingOperation, so it handles comment-prefixed staging that this heuristic misses.) → strip leading --…\n and /…*/ comments before extracting the verb; add tests for
   both comment forms.
2. Sync-cancel early-cancel window may propagate an exception out of Cursor.cancel() — kernel/client.py:432-443, 485-507. The canceller is registered before stmt.execute(), but the server statement id is
   populated mid-execute. A cancel() arriving in the first ms fires StatementCanceller.cancel() before the id exists; if that raises, cancel_running_cursor wraps it in _wrap_kernel_exception and propagates out
   of the public Cursor.cancel() — which PEP-249 callers expect to be tolerant. The e2e test sleeps 15s precisely to dodge this window, confirming it's unhandled. → confirm with the kernel team that
   StatementCanceller.cancel() is a safe no-op pre-id; if not, swallow/log (match cancel_command's tolerance). Untested.

🟡 P2 (Minor)

• id(cursor) reuse — adjudicated NOT exploitable. The live execute_command frame holds a strong ref to cursor for its whole duration, so the cursor can't be GC'd (and its id reused) while its entry is live;
  the finally dict.pop(..., None) always clears it and can't raise. The only collision is illegal same-cursor concurrent execute(), where a mis-fire cancels that cursor's own work, not an unrelated query. →
  optional: key by a per-execute monotonic token to be fully robust.
• Canceller use-after-teardown — cancel_running_cursor reads under lock, releases, then calls .cancel(); the execute thread may stmt.close() concurrently. Python exceptions are caught, but a native pyo3
  panic (if the kernel doesn't guard cancel-after-close) wouldn't be. → confirm StatementCanceller holds its own ref and is safe post-close.
• Older-wheel degradation — stmt.canceller() missing is swallowed by the registration try/except (cancel silently won't work — acceptable); new error attrs use getattr(..., None). Both graceful; note the
  KERNEL_REV bump means cancel/diagnostic features require the new kernel.
• e2e sync-cancel test sleeps 15s — slow + timing-fragile.

Thanks @gopalldb — addressed in 4413040 (+ KERNEL_REV bumped to the amended kernel #121).

P1 #1 — staging fail-loud missed comment-prefixed statements ✅ Fixed. _is_staging_statement now calls _strip_leading_sql_comments first, which skips leading -- … line and /* … */ block comments (multiple/mixed) before extracting the verb. So -- upload\nPUT … and /* c */ PUT … are correctly classified as staging and fail loud. Added unit cases for both comment forms, mixed comments, leading-whitespace, and the inverse (-- PUT …\nSELECT 1 / /* PUT */ SELECT 1 must NOT match), plus a live e2e (test_comment_prefixed_staging_put_raises_not_supported).

P1 #2 — early-cancel could propagate out of cursor.cancel() ✅ Fixed. cancel_running_cursor is now tolerant: it swallows + logs (exc_info=True) a canceller failure instead of re-raising via _wrap_kernel_exception, matching cancel_command's tolerance and the PEP-249 expectation that cursor.cancel() doesn't raise. It still returns True (a canceller was present and attempted) so the Cursor doesn't emit the misleading "no executing command" warning. (Also: the kernel-side StatementCanceller.cancel() is a documented no-op before the id is observed, so the common early-cancel case doesn't even reach this path.) Added a unit test asserting a raising canceller is swallowed and True is returned.

P2s — all acknowledged:

• id(cursor) reuse: agreed not exploitable (live execute_command frame pins the cursor; finally always pops). Left as-is.
• Use-after-teardown: the kernel StatementCanceller holds its own Arc<SessionInner> + id slot (not the Statement), and cancel_statement against a closed/terminal id is a server no-op; the connector now swallows any error regardless. Safe.
• Older-wheel degradation: intentional + graceful (getattr(..., None); canceller registration in try/except). The KERNEL_REV bump means these features require the new kernel — expected.
• e2e sleeps 15s: it's #[ignore]-style live-only and dodges the pre-id window deliberately; timing-fragile but only runs on the gated live job. Could shorten with a polling wait on query_id in a follow-up.