Skip to content

SEP 49: The TDSE response on native (implementation) - #771

Merged
jtravs merged 27 commits into
mainfrom
feature/sep-0049-tdse-on-native
Nov 13, 2026
Merged

jtravs merged 27 commits into
mainfrom
feature/sep-0049-tdse-on-native

Conversation

@jtravs

@jtravs jtravs commented Nov 12, 2026 •

Copy link
Copy Markdown
Contributor

Implementation of SEP 49 (docs/dev/seps/sep-0049-tdse-on-native.md, tracking issue #764): phases 0–4 of 4, including the manual check with a real Pyroraptor (§7.4). Draft; phase reports are in the SEP's Part II on this branch.

This branch merges the native restructuring (#770), which is not on main yet. Until #770 merges, this diff also shows #770's commits. Once #770 lands, main will be merged in again.

Done

  • Phase 0: baseline. poe size at the base commit, and the host TDSE source assembly's time per evaluation with a manufactured binding: 0.13–0.26 ms on the test window, 1.2–1.9 ms on a production-sized lattice (17 nodes, n_to = 9216). That is below the SEP's 10–100 ms estimate.
  • Phase 1: the shared source. solprop.backends.tdse_source is a pure move of numpy_ref/tdse.py, plus node_fields. It imports neither backend, and numpy_ref calls it. New tests/backends/test_tdse_source.py states each shared term independently: taper, node synthesis, edge scaling, the off-band zero and the floors. A deliberate defect in each named term fails a test; the table is in Part II.
  • Phase 2: the provider worker.
    • solprop.driver._source_worker is provider-agnostic. It covers subprocess start, a session of its own, stdout redirected to stderr, ignored SIGINT and SIGTERM, a watchdog on parent EOF, length-prefixed frames with no pickle and bounded sizes, a handshake, and a wait loop that polls signals (held ones included) and the stop flag. It kills the worker on cancellation and reaps it on every path.
    • solprop.driver._pyroraptor is the adapter. The binding, presets, bases and DiagnosticSession all go through the worker, so solprop's process never imports the provider.
    • The ledger gains tdse_transport memory rows.
    • The §6.3 failure boundary holds on numpy_ref.
    • _interrupts.raise_held is added for the native hook to use later.
    • No Pyroraptor companion change was needed.
  • Phase 3: the native hook.
    • C++. include/solprop_native/host_source.hpp defines a generic HostSource. The resident Adams march calls it from the thread that called advance, outside any parallel region:
      • begin(cost) runs after the budget check;
      • evaluate(field, z, purpose, out) runs at each source evaluation;
      • end(outcome) runs after the decision, and after the commit for an accepted attempt.
    • Abandoned attempts. An attempt that leaves without a decision ends abandoned, which only releases its reservation.
    • What the engine skips. The engine's own response pass is skipped. Its stage finish applies only the collar, the in-stage absorber and the propagator.
    • Field and source rows. The stage's entry kernel writes the lab-frame field (unscaled, noise included) into the hook's field row. The hook receives that row read-only and writes F in place into its source row. Both rows are allocated when the source is bound, and appear as host_source in the ledger.
    • Binding layer. It catches nb::python_error under the interpreter lock. The march reports a host failure with its stage; before the commit the attempt is abandoned, after the commit it is returned.
    • Device builds refuse a TDSE problem by name.
    • Native adapter. _host_source.TDSEHostSource uses the shared assembly with the reference's own scalars and prefactor. The native backend:
      • binds the hook for its lifetime (closing the state drops it, even while a session leases the state);
      • records atomic_calls, tdse_execution, tdse_last_evaluation and tdse_source;
      • lists the binding's tdse_* rows;
      • restores atomic ledgers;
      • wraps advance in _interrupts.interruptible();
      • re-raises the kept exception unchanged, and attaches an abandoned attempt's failed release to the run's error as a note.
    • solprop side. The registry hands the binding to native, and backend="auto" now runs TDSE on native.
    • Docs. Updated kernel-contract.md §6, backends.md, AGENTS.md, native/AGENTS.md, the TDSE manual and Choosing a backend, and added a release note.
    • Bitwise check. Non-TDSE runs on native are unchanged bit for bit against the Native structure and bound structs (PR-5) #770 build, with SOLPROP_FFTW_PLAN=estimate SOLPROP_CALIBRATION=off on one thread: gnlse_soliton, rdw_one_mode (both Adams formulations), argon_blueshift, radial_filament_256 and dense_output.
    • Checks. poe tidy-native reports no finding on the changed C++.
  • Phase 3 review fixes (the review of 478b3808; details in Part II):
    • Critical, fixed. The binding passed ownerless NumPy views, which nanobind copies. F therefore never reached the engine. The views now have a no-op capsule owner, and the field view is read-only.
    • Critical, fixed. The hook was given the field divided by n_to (read from the fine spectrum). It now reads the unscaled stage input, which the entry kernel writes.
    • High, fixed. The tests are no longer vacuous:
      • §7.3 item 1 goes through the C++ gather and the binding: field and F bit for bit, and history row zero bit for bit without the absorber, within fft_bound(n_to) with it. This covers both formulations, both descriptors, and runs with and without input noise.
      • The remainder is ×1e9, and every budgeted run checks that F moves the field a millionfold beyond its budget.
      • The eight-step 128ε budget is restored.
      • A real held SIGTERM is now tested.
    • Medium, fixed. close() under a session lease no longer unbinds.
    • Low, fixed.
      • The host error is attached as a note and cleared per attempt.
      • A failed accepted end keeps the proposal and the replay cursor.
    • Nit. The memory row is now 2 rows under the generic name, recorded as a deviation.
    • Q12 is closed.
    • Each defect, put back locally, fails the new tests. Non-TDSE runs are still bit for bit unchanged.
  • Phase 3 follow-ups (the re-review of 0625619d):
    • Leak fixed. close() now drops the host source after the state is closed. The state's reference to it was invisible to the GC, so a cycle through a kept exception was never freed. The held-signal test now asserts with a weakref that the binding is collected.
    • Item 4 corrected. The old eight-step run actually took nine accepted attempts, because its last step was split. It is now eight binary-exact steps of 2^-27 m.
  • Phase 4: qualification and documentation.
    • ADR-078. Covers the host source hook (its scope and the device refusal), the provider worker, the failure boundary and auto. It amends ADR-077.
    • Docs. testing.md gains a section on shared code and the worker contract. backends.md and kernel-contract.md cite the ADR. The rest of §8 was already done.
    • Size report against §6.8, in Part II.
    • Manual check procedure for a real Pyroraptor, written into Part II as pending: CPU and CUDA/HIP install commands and a script with two modes, compare (native against numpy_ref, at most three atomic calls) and cancel (SIGINT during a call). Both modes were dry-run with the manufactured provider.
    • Maintainer decisions. ADR-078 is accepted. No Pyroraptor revision is pinned: solprop uses the installed provider (by default the latest main) and records the revision the provider reports. The handshake still refuses another protocol version or a device mismatch.
    • Manual check (§7.4) with Pyroraptor main 7658b61 and solprop 7a5ca1f, run on a Slurm cluster:
      • CPU compare (32 cores): numpy_ref and native gave identical ledgers and status, and final fields 4.1e-13 apart (relative). Each atomic call took about 100 s, after about 8.4 min of model preparation.
      • CPU cancel: KeyboardInterrupt came 0.13 s after SIGINT, sent 5 s into a call. The worker was gone, the call was charged and nothing was left reserved.
      • A40 with a CUDA Pyroraptor beside native's CPU wheel: device="cpu" was refused by name. cancel cuda raised KeyboardInterrupt 0.47 s after SIGINT, the worker was gone and the GPU had no process and 0 MiB in use afterwards.
      • No GPU compare, because the A40 is too slow at FP64. That comparison is left manual for the provider's next production GPU use (Q10).
    • Not done here. The SEP is not marked Final and this PR is not marked ready.

Phase 3 line counts against the SEP's estimates for the hook:

layer lines SEP estimate
C++ +332 −11 +0.3k
native Python +251 −12 +0.4k
src/solprop +49 −58 —
tests +464 −30 +0.5k

Size

Against main (97a902bd), tools/size_report.py (src/solprop, lines):

code public docstrings private docstrings comments total
main 113,232 76,886 17,090 4,239 225,295
this PR 114,268 76,937 17,376 4,285 226,899
change +1,036 +51 +286 +46 +1,604

By file (code, docstrings, comments, total; main → this PR):

file code docstrings comments total
driver/tdse.py 1,787 → 1,651 583 → 628 56 → 57 2,575 → 2,506
driver/_source_worker.py 0 → 522 0 → 131 0 → 23 0 → 761
driver/_pyroraptor.py 0 → 605 0 → 93 0 → 21 0 → 786
backends/numpy_ref/tdse.py 530 → 0 248 → 0 21 → 0 845 → 0
backends/tdse_source.py 0 → 564 0 → 297 0 → 22 0 → 937
backends/numpy_ref/backend.py 2,005 → 1,999 792 → 796 105 → 105 3,019 → 3,017
backends/host/adams.py 472 → 481 279 → 284 28 → 28 818 → 834
_interrupts.py 85 → 90 49 → 57 3 → 3 162 → 177
driver/simulation.py 6,192 → 6,195 3,662 → 3,664 234 → 234 10,517 → 10,522
these files 11,071 → 12,107 (+1,036) 5,613 → 5,950 (+337) 447 → 493 (+46) 17,936 → 19,540 (+1,604)

The growth gate's excess is the worker (_source_worker.py) plus the adapter's request handlers and the parent's view of the haCC model (_pyroraptor.py, tdse.py). The binding's validation and normalisation stayed in solprop's process, as §6.5 asks. I looked for code that could go without losing behaviour and removed only a dead flag, a duplicated preset-field list and a dead dataclass branch. Nothing larger can go without moving validation into the worker or merging the parent and worker views of the haCC model; both are design changes. The private cross-package import ratchet is unchanged at 89; this PR's one new private-module import was replaced by public names.

Tests added

  • tests/backends/test_tdse_source.py (10)
  • tests/driver/test_source_worker.py (21, real workers; 3 slow)
  • tests/driver/test_tdse_worker.py (8, real workers with a manufactured haCC provider; 1 slow)
  • tests/backends/test_tdse_native.py (23, native against numpy_ref, SEP §7.3)
  • failure-boundary tests in test_tdse_march.py, and one test in test_interrupts.py
  • helpers: tests/source_adapters.py and tests/source_channel.py

The existing binding tests now serve their fakes through the same adapter and codec in-process; their claims are unchanged.

Run locally: the affected modules, 958 passed before the follow-up commit and 698 of the driver set after it. The 4 that failed are native-only: the editable native build here is stale after merging main, and these phases change no native code.

Maintainer decision (2026-11-12)

A worker is never used again after a failure of any kind. That covers a provider exception, a result the binding refuses, a worker exit, a protocol error and a cancellation. The binding's next evaluation or diagnostic starts and prepares a fresh worker. This is recorded in Part II and tested (test_after_a_provider_exception_the_retry_gets_a_fresh_worker).

Deviations (details in Part II)

  • Three checks that need the provider's own classes run in the worker: naming the result type, comparing the haCC model, and evaluating shadow components.
  • Interrupted evaluations are archived as raised with classification interrupted, so the archive format is unchanged.
  • The hook's end takes an outcome (rejected, accepted or abandoned) rather than a boolean.
  • A host failure is the march's error reason with a new host category, not a reason of its own.
  • §7.3 item 1 compares F bit for bit. The stage output is compared through whole runs instead; open question Q12 explains why.
  • Item 4 is a short adaptive run of about 400 attempts, within attempts × 16 ε, rather than eight steps.

Left

  • Phase 4: qualification and documentation. This covers the manual Pyroraptor check (§7.4), the ADR, the remaining pages, Q12, and the final size comparison.

🤖 Generated with Claude Code

https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3

jtravs and others added 11 commits November 12, 2026 12:50
The synthesis to the nodes, the assembly of P, g S and g' S and their projection
move out of numpy_ref into a module that imports neither backend; numpy_ref calls
it. New tests state the taper scaling, node synthesis, edge-array scaling,
off-band zero and the diagnostics' floors independently of the module.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
_interrupts.raise_held, for a host source's wait inside native's advance
(SEP 49 section 6.7); a no-op outside a commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
Start with subprocess (never multiprocessing) in a session of its own, protocol
on private descriptors with stdout pointed at stderr, SIGINT and SIGTERM ignored,
a watchdog that exits on parent-pipe EOF; length-prefixed frames, JSON control,
arrays as raw bytes, no pickle, bounded frames; handshake with protocol version
and provider identity; a reader thread and a 0.2 s wait loop that polls signals
(held ones included) and the stop flag; kill at once on cancellation, a short
grace only for close; reap and close on every path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The binding, basis_from_preset, hacc_preset, hacc_basis and DiagnosticSession
talk to Pyroraptor's adapter in a worker; solprop's process never imports the
provider. Budgets, the archive, validation, normalisation and warnings stay in
the binding, on plain records. Transport copies join the memory ledger and the
estimate; the run's stop flag reaches the binding; a stop during a call kills
the worker, keeps the charge and records the evaluation as interrupted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The host Adams march releases a trial's reservation on every exit and attaches
a failed release to the original error as a note; tests of an archive failure
after an accepted commit and of the note.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The maintainer's decision: a worker is never used again after a failure, so a
provider exception or a refused result ends it and the binding's next call
prepares a fresh one. Resolve the three cross-reference warnings Read the Docs
raised; drop a dead flag, derive the preset record names, and record the decision
in Part II.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
@read-the-docs-community

read-the-docs-community Bot commented Nov 12, 2026 •

Copy link
Copy Markdown

jtravs and others added 8 commits November 12, 2026 13:55
Queue a failure for any reader exception; leave the worker through os._exit on
every path; map a write to a dead worker to its exit; kill in close's finally;
static reader threads and a finaliser; no blocking close of a stream still read;
a stop owns an exit seen after it; -P and BLAS idle defaults for the worker;
raise_held only inside an interruptible() scope on the main thread. Bounded
manufactured hangs, signal guards and a zombie-aware orphan check in the tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The resident Adams march calls a generic host source -- begin(cost) after its
budget check, evaluate(field, z, purpose, out) at each source evaluation, and
end(outcome) after the decision and the commit -- from the advancing thread,
outside every parallel region; the binding layer takes the interpreter lock
and keeps a Python exception for the session to raise. The engine's own
response pass is skipped and its finish applies the collar, absorber and
propagator. Device builds refuse a TDSE problem by name. The native adapter
binds the driver's binding through the shared source assembly, records the
TDSE metadata and memory rows, restores atomic ledgers and opens an
interruptible scope around advance; auto now runs TDSE on native.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The host source now reaches the engine: the binding hands `evaluate` its
two rows with a no-op capsule owner (nanobind copied the ownerless views),
the field read-only, and the stage's entry kernel writes the unscaled lab
field, noise included, into the hook's field row instead of the hook
reading the fine spectrum (the field divided by n_to). The rows are two,
as the SEP says, under the generic `host_source`.

A failed `end` after an accepted commit keeps the step's proposal, count
and replay cursor. `NativeBackend.close` no longer unbinds under a leased
state. An abandoned attempt's failed release rides on the run's error as a
note, and the kept error is cleared per attempt.

The native TDSE tests go through the C++ gather and the binding (field, F
and the history's first row against the reference), use a remainder strong
enough that F moves every compared field far beyond its budget and check
that it does, restore the eight-step 128 eps budget, and exercise a real
held SIGTERM, the floor's note, the terminal proposal and close under a
session. Each defect, put back, fails them. Part II records the review and
closes Q12. A stale import in test_tdse_edge_free is fixed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The review's follow-ups to phase 3: NativeBackend.close drops the host
source once the state is closed, since the state's reference to it is
invisible to the collector and a cycle through a kept exception was never
freed (the held-signal test now checks the binding is collected); and item
4's run is eight binary-exact steps, where 8e-8 m in 10 nm steps split its
last step into two.

ADR-078 records the host source hook, its scope and the device refusal,
the provider worker and the failure boundary, amending ADR-077's
exception for the TDSE response. testing.md states the oracle boundary for
shared code and the worker-contract tests. Part II records phase 4, the
size against section 6.8, and the maintainer's manual check with a real
Pyroraptor as a pending, copy-pasteable procedure (install, a two-mode
script, pass criteria), dry-run with the manufactured provider.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
Maintainer decisions of 2026-11-12. ADR-078 is accepted. Until Pyroraptor
has a release, solprop uses whatever provider is installed (by default the
latest main): `_PROVIDER_REVISION` and `pinned_revision` are removed, and
the handshake refuses only another protocol version or an execution space
other than `TDSEExecution.device`. The worker's reported revision, build
and execution space remain the run's build record; presets and bases name
that revision in their source, the consistency cache keys on it
(`tdse.provider_revision`), and the archive contexts drop `provider_pin`.
Tests check that another revision is recorded, not refused. The SEP's
§6.5, §7.2, §7.4, §9.3, Q10 and Part II, dependencies.md and ADR-078 say
so, with a release note.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The manual check of section 7.4, run with Pyroraptor main (7658b61) on a
Slurm cluster: on 32 EPYC 7763 cores, compare gave numpy_ref and native
equal ledgers and final fields 4.1e-13 apart (about 100 s a call after
8.4 min of model preparation), and cancel ended a run 0.13 s after SIGINT
mid-call with the worker gone, the call charged and nothing reserved; on
an A40 with Pyroraptor's CUDA build beside native's CPU wheel, a device
mismatch was refused by name and cancel ended the run 0.47 s after SIGINT
mid-call with the device released. No GPU compare: an A40's FP64 makes a
call hours long, and that comparison stays manual (Q10). The script gains
a refusal mode and starts its cancellation 5 s into the first call.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
jtravs and others added 2 commits November 12, 2026 19:39
Brings in #770, #768 and #774 (main 33172a5). The TDSE changes of this
branch move with #768's split of simulation.py: the numpy_ref-only rule of
_admit_tdse_execution is gone from driver/settings.py, and driver/tdse_run.py
takes the stop flag to the binding, the installed provider's revision for
the consistency gate, no provider_pin in the archive context, and auto
resolving to native. ADR-077 keeps main's text with ADR-078's amendment
note; layers.svg is redrawn with docs/dev/figures/build.py. A docstring line
in test_tdse_hacc_installed.py is rewrapped.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
CI's Linux wheel failed check_strict_fma.py with 36 fused multiply-adds
"in" march::reached. In that wheel reached is 0x5d bytes with none; the 36
lie in 9 KB of unlabelled code LTO placed after it, the dispersive
response's Kokkos kernels (calls to GeneralDispersive::respond, sin, tanh,
pow, exp). The extension is stripped, so objdump labels only exported
functions and the check counted that code as reached's. It now bounds
each strict function by its symbol's size from `objdump -T` and `-t`,
with a test; the CI wheel passes (333 strict functions, none fused). No
native source changes; the non-TDSE runs are unchanged bit for bit.

ruff formats the Python block embedded in the SEP's Part II; the block is
formatted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
@jtravs jtravs added the size-ok Accepts a pull request's src/solprop growth over the 1,500-line budget label Nov 12, 2026
- test_snapshots: the TDSE snapshot test read the in-process haCC model
  and plans, which live in the provider's worker since phase 2; it now
  checks that the snapshots keep the same worker, model view and plans.
  The failure was the test's own hook, logged by the snapshot transaction;
  the snapshot path does not touch the model.
- test_tdse_worker: the import-isolation claim sets aside provider modules
  another test of the process loaded, then checks that the run through
  the worker imports neither pyroraptor nor the adapter.
- test_source_worker, test_tdse_worker: each test carries its own tier, so
  the slow ones are not also medium.
- check_skips: the POSIX-only worker tests' reason is expected on Windows.
- test_tdse_native: the interaction formulation's transported startup row
  is each engine's own complex product, which MSVC fuses on Arm64; it is
  compared within 4 eps of each value, the exponential row still bit for
  bit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
@codecov

codecov Bot commented Nov 12, 2026 •

Copy link
Copy Markdown

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

jtravs and others added 3 commits November 13, 2026 00:15
The coverage lane missed the source worker's child side, which runs in a
process of its own, and several new failure paths of the TDSE binding.

Tests:
- The worker's main, its private streams and the module's entry block run
  in this process on pipes standing in for descriptors 0 and 1, with
  os._exit recorded: requests in order until close, an adapter exception
  and a reply the codec refuses reported as errors, provider printing kept
  out of the frames, SIGINT and SIGTERM ignored, a failed start reported in
  place of the handshake, and the watchdog's exit at end of file or on
  garbage.
- Real workers: an answer before the handshake, a message out of turn, a
  close that overruns its grace, a grandchild holding standard error
  across a kill, an unstarted worker's close and kill.
- Frames: truncated, oversized and mistyped messages; the reply reader's
  endings; numpy scalars, callables and re-sent records in the codec.
- Binding: a provider that cannot start, a worker that dies in a call (a
  charged "worker" failure with its stderr attached), a stop during the
  consistency diagnostic's call, a missing result record, a refused shadow
  component, a fresh worker reporting another build, and the wrapping of
  worker and local preparation errors.
- Adapter: requests outside its protocol, and a result info its model
  comparison cannot read.

Code:
- A result that is not a record is refused by name, as a contract failure,
  instead of failing on a missing attribute as "unexpected".
- A worker's failure waits for its standard-error reader once it has
  exited, so the last lines it wrote are on the error (they could be lost
  to a race before).
- The diagnostic's close is always sent, suppressed when the worker is
  already ended; a killed worker refuses it at once, so the "alive" check
  only added a branch no run could take.

Removed as unreachable:
- tdse._json_default's dataclass branch: provider records now cross the
  worker as Records, and nothing else the binding encodes is a dataclass.
- tdse._component's "order must be one of" refusal: the worker evaluates
  every quantity at each order the shadow reports, and the binding asks
  only for orders it has checked against those labels.
- tdse_source._cubic_polarisation's checks: PropagationProblem.validate,
  which both backends run first, admits optmat_cubic only with its real
  Kerr coefficient and no plasma, Raman or dispersive Kerr beside it.
- Worker._exited's and _end's None checks: only a started worker, which
  always has its process and all three pipes, reaches them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
The A/B on non-TDSE cases shows no regression (geometric mean 0.986 against the limit
1.015), and the bitwise check is unchanged on all seven cases. CI's coverage lane now
covers the worker's own side. Archive the SEP, move its index and toctree entries, drop
its roadmap entry, link it from the TDSE manual page, and record the completion and the
issues the open questions moved to (#785, #777).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
jtravs and others added 2 commits November 13, 2026 01:23
…or inactivity)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HAYtF5P9QqEd3HQx3WJkA3
…-on-native

# Conflicts:
#	docs/dev/architecture.md
#	docs/dev/figures/layers.svg
@jtravs
jtravs marked this pull request as ready for review November 13, 2026 05:37
@jtravs
jtravs merged commit 22f886e into main Nov 13, 2026
98 of 100 checks passed
@jtravs
jtravs deleted the feature/sep-0049-tdse-on-native branch November 13, 2026 05:37
@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Nov 13, 2026 •

Copy link
Copy Markdown
Codex Review Summary: ✅ Completed

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-11-13T05:38:58.312707Z b6b22ee Draft marked ready
🔒 Security Review ✅ Completed 2026-11-13T05:39:40.672811Z b6b22ee Draft marked ready
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

size-ok Accepts a pull request's src/solprop growth over the 1,500-line budget

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant