Skip to content

Engine fixes for 1.15.0, batch 1 - #964

Open
luisleo526 wants to merge 37 commits into
mainfrom
fix-batch-1b
Open

luisleo526 wants to merge 37 commits into
mainfrom
fix-batch-1b

Conversation

@luisleo526

Copy link
Copy Markdown
Collaborator

Engine fixes for 1.15.0, first batch. Each change comes with a test that fails on v1.14.0; the full checks on this branch are running.

The user-visible changes are listed in CHANGELOG.md under "Unreleased (1.15.0)":

This pull request also carries tests and CI checks for these changes.

timezone_system_error_host_rows took the zone its EINVAL rows start
from from a time zone guard that had already ended. Since the guard
restores the caller's zone, that block did nothing, so with
TZ=America/New_York in the environment the injected failure never
fired and the row failed although the engine was right.

Each row now sets a different zone with the real setenv and tzset
before arming its injection, disarms the hook before recovery, and
restores the original TZ after each recovery read, also on unwind.
Every original assertion and diagnostic is kept.
The header defines PF_STREAM_ENGINE_LAYOUT_VERSION as 5u. docs/pages/abi-stability.md
said twice "ABI 5 and stream layout 4 stay fixed", and docs/pages/report-schema.md
said "ABI 5, stream layout 4, sink wire and fingerprint versions are unchanged".
The three sentences now say stream layout 5, the value the pages describe.

Refs #923
…ld scratch files (#925)

With --native-event-retention window, the runner probes the ledger's directory
for an unnamed spool file. When the probe failed it warned that the settled rows
stay in memory and cleared the scratch directory, and then built the window
accumulator from the empty string. An empty directory means the system
temporary directory, so the engine's equity-curve scratch file was written
under TMPDIR or /tmp, away from the ledger, with no message about it.

The accumulator is now built only when a scratch directory is left. When the
probe failed, the curve stays in memory and the runner says so, as it already
does for a ledger on a memory filesystem.

The new case restarts a ledger whose SQLite files stay open, removes write
permission on the ledger's directory so that the probe fails, points TMPDIR at
a disk-backed directory, and checks that the runner holds no report scratch
file there (the engine's own command journal is an unnamed file in TMPDIR in
every run and is expected) and that the curve warning is printed once.

Refs #925
…ne layout stamp (#926)

--native-event-retention window keeps the kernel's event window only for a
module that declares the current engine layout stamp; for any other module the
whole event record is kept. The ledger's checkpoint storage did not follow: it
streamed a large checkpoint into a BLOB whenever the option said window, so an
unstamped module ran with the whole event record and the streamed storage, and
nothing said that the option had not been applied.

Both decisions now come from one condition. An unstamped module keeps the whole
event record and the TEXT checkpoint storage, and the runner prints one warning
at startup that the option is not applied to this module. The README names the
condition and the warning.

The new case runs a stamped and an unstamped module with the same option and
more than one MiB of checkpoint: the stamped module stores a BLOB and prints no
warning, the unstamped module stores TEXT and prints the warning once.

Refs #926
With --native-event-retention window the runner writes a report checkpoint
above 1 MiB into its row in pieces, as a BLOB, so that its memory does not grow
with the size of the report. That held only above cursor 512: a checkpoint at
cursor 512 or below was built as one JSON tree, serialized into one string and
stored as TEXT, whatever its size. In a measurement with 512 batched inputs the
checkpoint was 26.7 MiB and the tree raised the runner's peak resident memory
by 441 MiB, about 17 times the payload; the streamed checkpoint at cursor 1024
raised it by 0.6 MiB.

A run that streams large checkpoints now folds every checkpoint through the
spooled arrays, which write the same bytes, so a payload above 1 MiB is
streamed at any cursor. A run without the option is unchanged: it still builds
the tree up to cursor 512 and stores the payload as TEXT.

The new case runs 512 batched inputs three times: with the option and no
checkpoint, with the option and a checkpoint at cursor 512, and without the
option and a checkpoint at cursor 512. It checks that the checkpoint is a BLOB
with the option and TEXT without it, that both hold the same bytes and hash,
and that the checkpoint raises the peak resident memory by less than its own
size.

Refs #961
… scratch directory

The runner README and the memory guide now say that a run with
--native-event-retention window folds every report checkpoint through the
spooled arrays and writes a payload above 1 MiB into its row in pieces, as a
BLOB, at any cursor. Without the option the tree is still built up to cursor
512 and the payload is stored as TEXT.

They also say where the engine's own scratch files are. The spilled part of its
trade ledger and its command journals, among others, are unlinked files in
TMPDIR (else /tmp), not in the ledger's directory, and --max-ledger-bytes does
not count them, so TMPDIR needs a disk-backed directory with room for them.

The code line citations that the preceding changes moved are refreshed: the
Ledger and checkpoint functions in store.cpp, the post-replay call in main.cpp,
report_memory in the runner test, and the README lines that the source-bounds
inventory cites.

Refs #961
…#927)

A ledger that holds report inputs but no report checkpoint is folded once when
the ledger is opened, and that fold can write spool files. The runner installed
its spool-failure handler only after the ledger was opened, but a spool failure
sets the run's one-warning flag whether or not a handler is installed. A
failure inside the startup fold therefore printed nothing and used up the
warning, so every later failure of the run, including the explicit probe, was
silent too.

The handler and the test file-size limit are now set before the ledger is
opened, so the first failure prints the existing warning once. The probe takes
the same one-warning flag before it prints, so a run whose startup fold and
probe fail for the same reason still prints one warning.

The new case restarts copies of a ledger with 513 report inputs and no
checkpoint: one without a cap, one with the spool file size capped so that the
startup fold reaches a write refusal, and one with the same cap and a status
file in a missing directory, which stops the run right after the ledger is
opened so that only the startup fold can have printed. The capped restart
prints the write warning once and writes the same report bytes as the uncapped
one.

Refs #927
…o create it (#928)

On a filesystem without unnamed files the report spool is created with a name
and unlinked at once. The result of the unlink was ignored, so a refused unlink
left the named file in the ledger's directory, holding the settled report
rows, after the run, and nothing said so.

A failed unlink now closes the descriptor, tries once more to remove the file
and throws the same error as a failed creation, so the caller's existing
fallback applies: the rows stay in memory and the run warns once.

The new test builds the spool in a temporary directory with the open and unlink
calls of the test binary wrapped at link time. The unnamed-file open is refused
so that the named path is used, and the first unlink of the spool's name is
refused. It checks that the constructor throws the creation error and that the
directory holds no named spool file, then that an ordinary construction leaves
no name either.

Refs #928
…ing it silently (#946)

atomic_json_file writes a service file to <name>.new.XXXXXX and installs it with
link() (a control request, which must not replace an existing file) or with
rename(). After a successful link() it ignored the result of unlink() on the
temporary name, and its failure path ignored it too, so a refused unlink left
<id>.request.json.new.XXXXXX beside the request, or a temporary file after a
failed write or install, with no message.

A refused unlink of the temporary name is now retried once and reported once on
stderr, naming the file. An install that succeeded stays a success, and a failed
write or install still raises its own error. After a rename the temporary name
is gone and nothing is unlinked.

The new test wraps unlink at link time in its own binary (no production seam and
no special permissions) and runs the writer in four cases: a link whose cleanup
is always refused, one refusal followed by a successful retry, a link onto an
existing target with the cleanup working and refused, and a rename.

Refs #946
The row for the service file writer's unlink test named its source as
../tests/test_service_unlink_failure.cpp. scripts/check_private_fixture_reads.py
walks every registered row and refuses a source whose path has a .. part
("names a source outside the tree"), so the test_private_fixture_reads row and
its controls failed on the tree with the new test. Every other row of
runner/CMakeLists.txt names its source as ${PROJECT_SOURCE_DIR}/tests/<name>.cpp;
this one now does too, and the sweep and its controls pass.
detect_timeframe subtracts neighbouring timestamps; a gap wider than the
signed range must still count as an increasing gap, and a decreasing pair
must still be ignored.
…frame

Compare neighbouring timestamps before subtracting, and subtract as
unsigned values so the exact positive gap is kept even across zero. Results
for ordinary gaps are unchanged.
…h does (#935)

The source adapter page described the 1.13.0 variable-length mean as a
Neumaier compensated sum that temporarily differed from fixed SMA, with the
alignment planned after 1.13.0. This change aligns the two, so the sentences
that described the difference are replaced in the same edit of
docs/pages/pine-to-native.md (they were introduced by 5a99df4 and 7c49532):
the `mean` description that sums the selected window afresh from oldest to
newest with Neumaier compensated double arithmetic; "The 1.13.0 variable-length
path temporarily uses Neumaier arithmetic."; "Constant-length calls must retain
existing `ta::SMA` and its window arithmetic"; "Alignment of the variable-length
arithmetic with fixed SMA remains planned after 1.13.0."; the sentence on the
ordinary unit target's full 1441-row feed comparison at N=20 that exercises the
variable adapter; and "That measurement is neither exact-alignment nor
generated constant-script coverage". The new text says what the code does now:
for finite sources without intermediate overflow the exact sum is rounded once,
as fixed SMA does, and the unit test covers a cancellation where the two paths
used to disagree. The citations of the page move with the code.
Format 1706746029000 with the UTC zone while the process TZ is
America/New_York; %s must stay 1706746029.
strftime reads the broken-down UTC fields back through mktime for %s, which
uses the process timezone. Substitute the Unix second for an unquoted plain
%s before calling it.
#718)

In a split session the fixed-timeframe period that contains the reopening
starts before the session resumes, so its nominal open and its eligible open
differ. While a row at the eligible open is the latest accepted input the
lookup must resolve it, and the next period must stay unresolved until its
own row is accepted.
…t lookup (#718)

The lookup refused every timestamp after the latest accepted input's nominal
open before it compared the eligible open, so the clipped opening of a
split-session period never resolved. Check the admitted labels of the latest
input first, then refuse later timestamps.
Cover the smallest minute count that overflows (35791395), a negative minute
count, week counts from 3551, negative day counts from -24856 and tf_ratio
with an overflowing target, each beside a boundary control that fits.
tf_to_seconds multiplied the parsed count by the unit length in int, so a
minute count from 35791395 up, a week count from 3551 up and a day count
from -24856 down overflowed into a wrong length; for example 71582789
minutes read as 44 seconds.

Multiply in 64 bits. A minute count, or a negative count, whose seconds do
not fit now raises the refusal the parser already uses for a count past int.
A week count past the limit is calendar-only, as a day count past it already
is, and tf_ratio keeps passing equal calendar-only week literals through.
Every input that did not overflow gives the same result.

Add the changelog entry and shift the line citations in two pages by the 18
lines this change adds to src/timeframe.cpp.
…d sources

ci/cr150-source-bounds.yaml and the site inventory ci/cr150-source-sites.json
did not know the sources that the exact window sum change (#935), the Unix
second time format change and the pre-bar error prefix change (#933) touch, so
the source allocation gate reported 58 findings and its unit test, which holds
the real tree to the same standard, failed.

Five new OPEN groups get entries, U1932 to U1936: the seed_sources_ member of
include/pineforge/ta.hpp, its grow site and a temporary vector in
src/ta_moving_averages.cpp, and the seconds string and the formatted string in
src/str_utils.cpp. The two entries of src/source/pine_ta_length.cpp whose sites
the error prefix change removed, U1102 and U1105, are retired. The site
inventory is regenerated with --emit-site-inventory. The unreviewed ceiling
moves from 1462 to 1465 with the reason beside it, and the unit test, which
pins the count of OPEN entries at 1641, moves to 1644 with the same reason.
The five new entries stay unreviewed; none is bounded.
… engine layout stamp

With --native-event-retention window, a module that does not declare the
current engine layout stamp does not get the windowed behaviour: the runner
prints the warning that the option is not applied, and a checkpoint of such a
run is built the way a run without the option builds it (the change for #926).
Three README sentences still described the windowed behaviour for every module.
They now say that it needs the stamp:

- "Above it, and at every cursor with that option, preparation folds every
  report row from cursor 0 through spooled arrays" now reads "...with that
  option on a module that has the engine layout stamp...".
- "With `--native-event-retention window`, a payload above 1 MiB is hashed and
  written into its row in pieces, at any cursor" now reads "...on a module that
  has the engine layout stamp...", and the sentence after it, "Without that
  option the payload is built as one string and stored as TEXT", now also
  covers a module without the stamp.
- "With `--native-event-retention window`, a checkpoint above 1 MiB is admitted
  whole" now reads "...on a module that has the engine layout stamp...".

Only these sentences change, in place; no line is added or removed.
…our changes since 1.14.0

The first section of the changelog still read "Unreleased" although it holds
the 1.14.0 entries, and the 1.13.0 heading had no date. The first of those two
headings now reads "1.14.0 — 2026-11-20" and the second "1.13.0 — 2026-11-18",
the dates of the commits the two release tags point to, in the form the older
headings use. A new "Unreleased (1.15.0)" section above them holds the entries
of the changes since the tag: the stream layout number in three documentation
sentences, the runner's spool and unlink handling for the windowed event
retention (the equity scratch file, the layout stamp warning, the report spool
warning, the failed unlink of the fallback spool file and of the service file
writer's temporary file), the checkpoint that is now folded at any cursor with
the measured memory before and after, and the calendar exporter's check before
it writes its destination. The entries that other fixes already added at the
top of the old section, and the series-length ta.sma entry that landed among
the 1.14.0 entries, belong to the new section and sit there. No entry of the
1.14.0 section is edited.
The design notes and pages cite lines of docker/run_failure_codes.json,
include/pineforge/ta.hpp and runner/report_spool.hpp. The changes folded here
add lines to those files above the cited places, so the citations after those
lines moved: 12 citations on 10 lines in 3 documents. Some are re-pointed to
the same symbols by scripts/check_doc_anchors.py --fix. The others name a symbol
that occurs on several lines, which the checker leaves to the author:
scripts/reanchor_doc_citations.py carried each of them to the line its symbol
has in this tree, using the parent tree as the reference and checking that the
new line holds the symbol. No text other than the line numbers changes, and the
checker reports every anchor resolved, 2376 of 2376.

@graphify-labs graphify-labs Bot left a comment •

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Graphify code review View in Graphify

Review completed · 5c8e5a4165b9

Note

Merge confidence: 5/5 · Nothing blocking · 16 possible issues to check · 🟠 High impact
16 possible issues not confirmed

The changes revise timeframe overflow handling, moving-average summation, and %s time formatting.

Full summary

The changes revise timeframe overflow handling, moving-average summation, and %s time formatting. Native execution also adjusts completion interval matching and pre-bar map error context.

No confirmed issues. We found 16 possible issues we couldn't confirm; see below.

Not confirmed (16 possible issues)

Leads worth a look; we didn't double-check these. They don't change the score.

Not confirmed · A runner that never reports readiness hangs the whole test forever Inspect source

Detailed review · not confirmed

wait_ready loops with no deadline, so a runner that stays alive but never writes a ready status stalls the test instead of failing it.

The only exits are an early runner exit (line 111) or the readiness condition (line 115). There is no elapsed-time check, so a stuck or silently blocked runner has no failure path.

  • Whether the runner can stall without exiting was not checked against the runner source.

  • The readiness status format was not read beyond the fields this file parses.

  • Found by the per-file sweep; not double-checked.

Not confirmed · On non-Linux builds the spool-probe-failure test case fails as an unknown test instead of skipping Inspect source

Detailed review · not confirmed

The spool-probe-failure branch is compiled only under #if defined(__linux__) and has no matching skip branch. On other platforms the test name falls through to the final else and the run fails with "unknown test case", although the other Linux-only cases print a SKIP and return 77.

The sibling branches tmpfs-spool-warning and default-no-curve-scratch each have a #else that prints a SKIP message and returns 77. The new spool-probe-failure branch at lines 1880-1883 has only the #if, so no skip path exists for it. The else at line 1904 then throws "unknown test case".

  • Only the dispatch in main was read; the harness that consumes return code 77 was not inspected.

  • Found by the per-file sweep; not double-checked.

Not confirmed · Checkpoint hash is read as a C string, so a NULL payload_hash would crash the test Inspect source

Detailed review · not confirmed

The test reads payload_hash with sqlite3_column_text and builds a std::string from the result without checking for NULL. A NULL column makes the string constructor undefined behavior.

At line 1587, outcome.hash = reinterpret_cast<const char*>(sqlite3_column_text(raw, 0-indexed column 2)) assigns the result directly. The same pattern at line 1585 for typeof(payload) is also unchecked. The code shown does not establish that payload_hash is NOT NULL.

  • The table schema for report_checkpoints was not read, so nullability of payload_hash is unconfirmed.

  • Found by the per-file sweep; not double-checked.

Not confirmed · Test relies on POSIX mkdtemp, which the included standard headers do not guarantee, so the test may not compile on some platforms Inspect source

Detailed review · not confirmed

The test creates its temporary directory with ::mkdtemp, a POSIX function, but includes only standard C++ headers such as <cstdlib>. On glibc that works, but other toolchains may fail to compile the test.

Line 52 calls ::mkdtemp, which is declared in POSIX <stdlib.h>, not in the C++ standard <cstdlib>. The file also depends on the --wrap link option for __real_unlink, which is already platform-specific.

  • The build configuration and target platforms were not visible, so portability is not confirmed.

  • Found by the per-file sweep; not double-checked.

Not confirmed · The unlink-refusal test only fails the spool cleanup if the spool code calls the wrapped unlink symbol directly Inspect source

Detailed review · not confirmed

The test forces one failed unlink by intercepting unlink and open at link time, but any unlink or open that bypasses that symbol (for example an unlinkat, open64/openat call, or a libc-internal path such as mkstemp) is not refused. The test would then fail its refusal check, or pass without exercising the failure path.

Lines 71-80 only refuse calls that reach the __wrap_unlink symbol, and lines 52-68 only alter calls that reach __wrap_open. The test assumes the spool code calls exactly those symbols, but nothing in this file shows that. Lines 85-95 then require refused_unlinks == 1 and an exact refusal message, so a routing mismatch shows up as a failure in the test harness rather than as product evidence.

  • The runner source (../runner/report_spool.hpp and its implementation) was not inspected, so it is unknown which open and unlink symbols it calls.

  • The file was not checked for --wrap linker flags in the build setup, so it is unknown whether these wrappers are linked at all.

  • Whether glibc's mkstemp reaches __wrap_open through the public symbol on the target platform was not verified.

Not confirmed · EMA SimpleAverage seed can write past its fixed-size partials array when length is large Inspect source

Detailed review · not confirmed

The seed sum uses a stack array sized by a constant, but its length is set by the EMA length, which the code does not bound against that constant.

ema_seed_sum declares partials[detail::kWindowSumPartialCapacity], and its lambda partial returns partials[i] without a bounds check. The loop at lines 401-402 adds one expansion per source in seed_sources_, which can hold up to length_ values (pushed at line 451). The code shown does not show that expand_window_sum refuses to grow past the capacity.

  • Did not read window_sum_expansion.hpp, so I could not confirm whether expand_window_sum checks the capacity.

  • Did not check the value of kWindowSumPartialCapacity against realistic EMA lengths.

  • Found by the per-file sweep; not double-checked.

Not confirmed · EMA readiness counter ignores infinite inputs that the SimpleAverage seed counts Inspect source

Detailed review · not confirmed

The seed counts every non-na input, but the readiness counter counts only finite inputs, so the two can disagree when an input is infinite.

Line 450 pushes any non-na src into seed_sources_, and lines 462-465 count it in bar_count, so infinite values count toward the seed. Line 453 only increments ready_count_ when std::isfinite(src). The comment at lines 456-457 now says 'non-na inputs', which matches the seed but not the counter.

  • Did not see where ready_count_ is read, so the effect on output is not confirmed.

  • Did not check whether the PR description intends finite-only readiness.

  • Found by the per-file sweep; not double-checked.

Not confirmed · A week count past the int range silently returns the calendar sentinel -1 instead of being refused, so 3551W is treated as calendar-based Inspect source

Detailed review · not confirmed

The new test locks in tf_to_seconds("3551W") == -1, so a fixed 3551-week timeframe is quietly treated like M. The same overflow for minutes is refused with an error, so the two cases behave differently.

The comment at lines 112-115 says minutes are refused and days or weeks are calendar-only. Line 132 asserts tf_to_seconds("3551W") == -1, and line 145 asserts tf_ratio("3551W", "3551W") == 1. The test therefore confirms that an overflowing fixed-length week count changes meaning rather than being rejected. The same reasoning applies to 24856D at line 137.

  • The implementation of tf_to_seconds and tf_ratio is not in the inspected range, so how callers handle -1 is unverified.

  • Whether week and day counts past the int range should be refused is a design question the diff does not settle.

  • Found by the per-file sweep; not double-checked.

Not confirmed · The extreme-timestamp test relies on overflowing int64 gap arithmetic, and its comment describes gaps that the data does not produce Inspect source

Detailed review · not confirmed

The comment says the upper median of "two increasing gaps" is the wider one, but the four timestamps produce only one increasing gap (300000 ms). The other gaps cross from the max timestamp to the min timestamp, which overflows int64.

The bars at lines 81-84 have timestamps min, max, min+300000, min+600000. The consecutive differences are max-min (overflowing), min+300000-max (overflowing and negative), and 300000. Only the last difference comes from increasing timestamps in a normal range. The comment at line 89 describes a different input, so a reader cannot tell what the expectation at line 90 is supposed to check.

  • The body of detect_timeframe is not in the inspected range, so the exact wraparound or clamping behavior is unknown.

  • It is unclear whether the implementation clamps or saturates gaps; the test does not state the rule it depends on.

  • Found by the per-file sweep; not double-checked.

Not confirmed · The test expects "1" for two bars whose timestamps go backwards, a case with no stated rule Inspect source

Detailed review · not confirmed

At line 88 the test passes bars whose timestamps decrease (max, then min+300000). It expects the timeframe to be "1", but the real spacing is about 5 minutes, which would suggest "5". No comment explains the expectation.

Line 88 uses bars + 1 with count 2, which is the pair (max, min+300000). The difference is negative and overflows int64, so the expected result depends on an undocumented wraparound or fallback. The test does not say why "1" is correct.

  • The expected value might reflect a deliberate fallback in detect_timeframe that is not visible in the inspected range.

  • The diff does not include the detect_timeframe contract for unsorted input.

  • Found by the per-file sweep; not double-checked.

6 more possible issues are available in Graphify.

What this review covered
  • We didn't review 16 files that aren't source code, such as docs, config, images, or generated or third-party code.
  • One review pass used all of its turns for reading code, so it reported from what it had already read.
  • Some lookups asked for files or lines that do not exist; the review was told and carried on.
  • 39 of 39 changed files inspected. This is scope, not a correctness guarantee.
Code graph and static checks · 5127 functions depend on this change

Impact & health

Impact — 5127 functions depend on the 3931 functions this change touches.

Health — this change adds coupling hotspots:

  • worse: tf_change() — 28 callers, 5 callees
  • worse: wait_ready() — 18 callers, 5 callees
  • worse: crosses_boundary() — 8 callers, 8 callees
  • worse: str_tostring() — 8 callers, 7 callees
  • worse: native_run_spec_digest() — 17 callers, 3 callees
  • worse: build_native_day_partition() — 9 callers, 5 callees
  • worse: timeframe_time_close() — 2 callers, 12 callees
  • worse: timeframe_time() — 2 callers, 9 callees
  • …and 12 more — each is listed as a finding

Formal checks — 5127 functions this change can affect weren't formally checked in this review. Formal checks are informational only.

Gate & verification

✅ PASS — objectively clean (no health regressions, tests not run — proofs not run this pass (advisory)). Grounded, not self-assessed.

Advisory (not blocking):

  • verification_scope: 5038 function(s) in the blast radius were not formally verified this run

Test selection

1468 of 1468 test file(s) selected (100%) via static blast radius.

Escalated to a full run for safety (noncode-change, uncovered-code) — the selection is not trustworthy on its own (see below). CI should run the whole suite.

  • benchmarks/tests/test_aggregate.py — full-run-safety
  • benchmarks/tests/test_check_provenance.py — full-run-safety
  • benchmarks/tests/test_compare.py — full-run-safety
  • benchmarks/tests/test_public_names.py — full-run-safety
  • benchmarks/tests/test_run_all.py — full-run-safety
  • benchmarks/tests/test_run_strategy_feeds.py — full-run-safety
  • docker/pineforge_sink_finalize_test.py — full-run-safety
  • docker/pineforge_sink_replay_rq_test.py — full-run-safety
  • docker/pineforge_sink_replay_test.py — full-run-safety
  • docker/pineforge_sink_to_json_test.py — full-run-safety
  • docker/quota_columns_test.py — full-run-safety
  • docker/quota_convert_test.py — full-run-safety
  • docker/quota_finalize_test.py — full-run-safety
  • docker/replay_rq_engine_test.py — full-run-safety
  • docker/run_json_artifact_window_test.py — full-run-safety
  • docker/run_json_bin_test.py — full-run-safety
  • docker/run_json_bounded_transport_test.py — full-run-safety
  • docker/run_json_bulk_equity_fuzz_test.py — full-run-safety
  • docker/run_json_bulk_equity_test.py — full-run-safety
  • docker/run_json_codes_test.py — full-run-safety
  • docker/run_json_converter_metadata_test.py — full-run-safety
  • docker/run_json_converter_session_test.py — full-run-safety
  • docker/run_json_diagnostics_test.py — full-run-safety
  • docker/run_json_equity_scan_test.py — full-run-safety
  • docker/run_json_fused_test.py — full-run-safety
  • docker/run_json_harnesses_test.py — full-run-safety
  • docker/run_json_metrics_only_test.py — full-run-safety
  • docker/run_json_misc2_test.py — full-run-safety
  • docker/run_json_misc_test.py — full-run-safety
  • docker/run_json_pfbar_test.py — full-run-safety
  • docker/run_json_provenance_test.py — full-run-safety
  • docker/run_json_quota_supervisor_test.py — full-run-safety
  • docker/run_json_replay_test.py — full-run-safety
  • docker/run_json_selected_sink_test.py — full-run-safety
  • docker/run_json_sink_lexical_test.py — full-run-safety
  • docker/run_json_sink_summary_test.py — full-run-safety
  • docker/run_json_sink_test.py — full-run-safety
  • docker/run_json_sink_vectors_test.py — full-run-safety
  • docker/run_json_spool_work_test.py — full-run-safety
  • docker/run_json_stringio_test.py — full-run-safety
  • docker/run_json_symbol_feeds_test.py — full-run-safety
  • docker/run_json_syminfo_test.py — full-run-safety
  • docker/run_json_trade_scan_test.py — full-run-safety
  • docker/run_json_window_budget_test.py — full-run-safety
  • docker/run_json_wrapper_work_test.py — full-run-safety
  • include/pineforge/native_run_spec.hpp — full-run-safety
  • scripts/derive_corpus_feeds_self_test.py — full-run-safety
  • scripts/fingerprint_self_test.py — full-run-safety
  • scripts/run_corpus_self_test.py — full-run-safety
  • scripts/test_abi_receipt_skips.py — full-run-safety
  • … and 1418 more

⚠️ non-code file(s) changed (CHANGELOG.md, ci/cr150-source-bounds.yaml, ci/cr150-source-sites.json, docker/run_failure_codes.json, docker/run_failure_codes_diff.json …) → running the full suite for safety (a code graph can't see config/fixture/data deps)

⚠️ changed code file(s) with no mapped test (CHANGELOG.md, docs/adr/0001-kernel-adapter-boundary.md, docs/design/BARS-BIN-INPUT.md, docs/live-ledger-budget.md, docs/native-refactor-progress.md …) — a coverage gap or a missing link — running the full suite rather than only the selected tests

Selection is safe under the controlled-regression assumption; always-run tests + a periodic full run are the backstops. Advisory — it never changes the check verdict.

Every flagged function

  • tf_change() in src/timeframe.cpp:1163 · 28 callers, 5 callees: 28 callers depend on it (afferent coupling)
  • wait_ready() in tests/test_native_live_report_cli.cpp:284 · 18 callers, 5 callees: 18 callers depend on it (afferent coupling)
  • native_run_spec_digest() in src/native_execution_consumer.cpp:14961 · 17 callers, 3 callees: 17 callers depend on it (afferent coupling)
  • build_native_day_partition() in src/timeframe.cpp:879 · 9 callers, 5 callees: 9 callers depend on it (afferent coupling)
  • crosses_boundary() in src/timeframe.cpp:1101 · 8 callers, 8 callees: fans out to 8 callees (efferent coupling); 8 callers depend on it (afferent coupling)
  • str_tostring() in src/str_utils.cpp:463 · 8 callers, 7 callees: fans out to 7 callees (efferent coupling); 8 callers depend on it (afferent coupling)
  • timeframe_time_close() in src/session_time.cpp:1896 · 2 callers, 12 callees: fans out to 12 callees (efferent coupling)
  • spool_probe_failure_keeps_curve_resident() in tests/test_native_live_report_cli.cpp:1632 · 1 callers, 12 callees: fans out to 12 callees (efferent coupling)
  • native_report_json() in runner/report.hpp:108 · 3 callers, 6 callees: fans out to 6 callees (efferent coupling)
  • session_in_postmarket() in src/session_time.cpp:1679 · 3 callers, 4 callees: high coupling complexity (Ca·Ce = 12)
  • session_in_premarket() in src/session_time.cpp:1644 · 3 callers, 4 callees: high coupling complexity (Ca·Ce = 12)
  • timeframe_time() in src/session_time.cpp:1848 · 2 callers, 9 callees: fans out to 9 callees (efferent coupling)
  • window_checkpoint_storage() in tests/test_native_live_report_cli.cpp:1488 · 1 callers, 10 callees: fans out to 10 callees (efferent coupling)
  • window_checkpoint_streams_at_the_tree_cursor() in tests/test_native_live_report_cli.cpp:1541 · 1 callers, 10 callees: fans out to 10 callees (efferent coupling)
  • recovery_spool_warning() in tests/test_native_live_recovery_spool_warning.cpp:190 · 1 callers, 9 callees: fans out to 9 callees (efferent coupling)
  • check_existing_target() in tests/test_service_unlink_failure.cpp:134 · 1 callers, 8 callees: fans out to 8 callees (efferent coupling)
  • number_style_text() in src/str_utils.cpp:165 · 1 callers, 7 callees: fans out to 7 callees (efferent coupling)
  • link_with_persistent_refusal() in tests/test_service_unlink_failure.cpp:105 · 0 callers, 7 callees: fans out to 7 callees (efferent coupling)
  • link_with_one_refusal() in tests/test_service_unlink_failure.cpp:120 · 0 callers, 6 callees: fans out to 6 callees (efferent coupling)
  • rename_does_not_unlink() in tests/test_service_unlink_failure.cpp:173 · 0 callers, 6 callees: fans out to 6 callees (efferent coupling)

This branch has not been deployed

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

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant