[BUG] Exsh stack proof assumes incidental optimized symbol names #4
Labels
No labels
alpha-1
bug
ci
docs
duplicate
enhancement
help wanted
invalid
performance
phase-6
question
refactor
security
wontfix
No project
No assignees
1 participant
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
erix/exsh#4
Loading…
Reference in a new issue
No description provided.
Delete branch "%!s()"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Summary
The optimized cleanup-frame check originally depended on function and closure
names that Rust did not emit. Address-based analysis has replaced that assumption,
but the complete source and call-path proof remains unfinished. CI must continue
to reject incomplete evidence. No stack overflow was demonstrated by the original
failure.
Reproduction
Run the feature branch's CI workflow, including the native
exsh-runtime, realm-binding and all-feature builds and their paired developmentand release images. The workflow supplies the selected disassembler, packaged
ELF and native inputs to
scripts/check-descriptor-cleanup-frames.py.For the original failure, build Exsh
5249114a634ead34a32ccd44cba613021df1647fwith Rust 1.97.1, Integration helper
e2b1cf5995bcf6334839cda9a013e90fa97787d5, and that revision's Cargo dependencies.Use
x86_64-unknown-none, release PIC, one codegen unit, no red zone, no LTO orstripping, and
linker.ld. Both runtime and all-feature builds succeeded; theirchecker invocations failed on the missing
::evaluate_simple_command_resolved_innersymbol. Renaming a required closurecannot establish the missing path bound.
Expected and actual behavior
Prove the actual optimized paths within the existing limits:
Workspace mapping, individual frames and known direct routes are separate proof
domains. The current checker still returns incomplete for the combined proof.
Unknown calls, effects, source membership or cleanup must remain failures.
Acceptance requires the documented compiler and frame contract:
runtime, sysroot, features, target, environment and consumed compiler/linker
inputs to the actual build, emitted ELF/IR and packaged counterparts. No branch
substitution, path dependency, wrapper, pre-existing artifact, hash-only claim
or caller receipt may manufacture this authority.
authenticated transfer protocol. Preserve complete function/inlining ownership,
semantic metadata, statements, call operands, address escapes and source-position
correspondence through compaction. A changed input invalidates admission.
Do not introduce incidental function-count, recursion-depth or machine-word
ceilings, omit a refusal or treat a smaller representation as the full capture.
dependencies. Unknown values and transformations remain unresolved; recursive
claims cannot establish themselves. Register/write preservation and Kernel
syscall effects need their own machine-body and Kernel-bound proofs.
child/descriptor under their documented owners. Reserve effects before issuing
them, preserve the first error and uncertain results, and never replay an
uncertain close or consuming wait. Independent source/pin lifetimes, complete
descendant retirement, acknowledgement, reaping and parent release remain
required. Metadata equality cannot replace native identity or consumption.
for substituted tools, forged receipts, stale sources, mixed features/artifacts,
omitted dependencies or metadata, escaped callbacks, cancellation and cleanup.
Complete source proof cannot waive a separate frame or authority requirement.
The small checker profile remains 64 MiB aggregate input, 64 MiB output,
60 seconds total and 15 seconds without tool output. Packaging retains its
60-second deadline. The separately selected full compiler capture has these
candidate allowances:
The approved tools/runtime/sysroot alone contain 471,416,555 bytes; the measured
complete capture lower bound is 1,081,722,692 bytes before remaining package and
native inputs. These allowances do not establish sufficiency. Charge every input,
representation, channel copy and reservation; never restart the total clock.
Failure stops ordinary work, and unused loans return only after native retirement.
Retain earlier resource failures. A larger allowance cannot turn incomplete proof
into success.
Environment and identity
The original host was x86_64 Linux with Rust 1.97.1
(
8bab26f4f68e0e26f0bb7960be334d5b520ea452) and LLVM 22.1.6, targetingx86_64-unknown-none. The original runtime ELF digest was1e63b3930c3fb440e29461d96e19d7b63fb0977961d76ce3491ae739771ceecd;the all-feature digest was
b6b7676ac457308e8df150d12ecea60120e5325cf3a2d0dc2f90ea700ad22f75.No guest session or image was used for that reproduction. A last working
toolchain/artifact combination was not established.
Evidence and prior checks
CI 502 at
118ef9caef0c67d9f9382fee544589d92f2c1dc6passes the Rustand checker tests before the unfinished frame gate fails. Earlier reports and
different artifact configurations remain separate observations; their route
counts cannot be combined into a complete proof or performance claim.
Implementation details and ownership rules are maintained in the
frame contract and architecture. New status belongs
in comments. The separate tool-selection defect and
compiler-performance issue have their own evidence and scope.
Tracking
Implementation: Exsh PR #3. Related work:
native deployment, library audit and
manual documentation. Both full EriX guest build generations,
Rust/LLVM rebuilding inside EriX and the service/profiler VM requirements remain
tracked by Phase 6 completion. Host checks do not satisfy those tasks.
The related realm/profiler work retains both stale-generation refusals, all six
successful client exits, capacity refusals that preserve the Guarded mediator and
Sealed peer, and the existing 120/45-second guest limits. Its independent native
accounting must identify two zero-CPU NeverExecuted clients, six Measured clients
and six Measured mediators; cancellation or absence cannot replace these results.
erikinkinen referenced this issue2026-09-12 13:31:30 +02:00
erikinkinen referenced this issue from erix/integration2026-09-16 05:10:35 +02:00
erikinkinen referenced this issue from erix/docs2026-09-16 05:10:37 +02:00
erikinkinen referenced this issue from erix/integration2026-09-21 20:54:16 +02:00
erikinkinen referenced this issue from erix/loaderd2026-09-25 11:27:01 +02:00
erikinkinen referenced this issue from erix/docs2026-09-25 11:27:08 +02:00
Added a direct-child wait owner in 13d15fb8. It dispatches traced stops separately from terminal verification and retains uncertain consuming effects. All 662 cleanup-checker tests pass; the native controls also preserve cleanup on rejection. Compiler integration, descendant ownership and the full frame proof remain open.
34c91497 adds fixed trace operations tied to the child’s wait owner. An uncertain resume now freezes ordinary operations in both owners, and a second owner cannot reset the attempt history. The 692 checker tests and three native controls pass. Compiler integration, descendant tracking and the full frame proof remain open.
The full cleanup proof still fails in run 512 at 6ffb6994. The observed entry and fallback frames fit their limits, but the checker cannot establish the required source membership and direct versus nested cleanup routes. That proof remains the CI blocker.
I’m replacing the cleanup checker’s guessed symbol groups with explicit executable sections for the entry point, ordinary descriptor/evaluator code and fallback. The limits stay at 8 KiB for ordinary and entry frames, 33 KiB for the fallback and 56 KiB for the direct cleanup chain, with the existing separate workspace and stack obligations.
The proposed nested execution boundaries are
execute_active_functions_aboveandexecute_active_evals_above. Failed function, eval or trap preparation remains in the direct path. A nested call changes only its callee subtree; returning resumes the caller’s context. Shared helpers and callbacks retain every context in which they execute, and nested stack use still needs its own complete accounting.The checker must bind all selected source definitions, generated bodies and emitted copies to the actual compiler inputs and linked code. Section names, debug locations and
#[inline(never)]alone cannot establish that relation. Unknown targets, missing bodies and unaccounted inlining remain failures. The gate will stay failing until source coverage, call paths and machine-level checks are complete; the current small frame sizes satisfy only part of that work.The boundary needs to be narrower than the two proposed
*_abovewrappers: they also validate depth and can unwind before a command executes. I’ll keep that work in the direct path and add a shared nested evaluator entry at the two calls that execute already-expanded commands in the function and eval loops. Trap execution reaches the same eval loop after its preparation.The top-level evaluator continues through the ordinary entry. Preparation failures and cleanup after a nested call returns remain counted in their caller’s context. This refines the boundary placement; it does not change any frame limit or waive compiler/source coverage.
090ede2fprints every original unresolved route observation in the CI log, including its function, instruction site, reason and object identity where present. Diagnostic writes stay under the original active deadline; incomplete results and the failing exit status are unchanged.This exposes the actual sites needed to continue the frame proof. Complete compiler-input ownership, source-to-machine-code relationships and all reachable frame paths remain open.
0849638adds full-register immediate AND bounds to the frame analyzer. It preserves sign extension, checks every selected table arm, and keeps numeric values separate from call authority. All 761 Python controls pass.The full frame proof remains open. The current CI sites still need their original instruction and table inputs before we can assign a cause to them.
dff37e2 adds instruction bytes, refused jump-table alternatives and original producer sites to the first frame-analysis refusal. The remaining failure is tracked in #4; the existing frame and call-target rules still apply.
The latest run on
dff37e2estill fails the cleanup-frame proof after all Rust and Python tests pass. Across four profiles, it reports 300 unresolved indirect calls, 52 unresolved indirect branches and 80 refused jump-table target sets. The new diagnostics captured the instruction bytes and original table inputs; those now provide the starting point for the fix. The proof requirements remain unchanged.64f7b7d adds checked MOVZX/double-shift handling and shares immutable grammar within each proof invocation. The 787-control suite passes. Fixture effect decodes fall from 96 to 36 and memory decodes from 20 to 10 with equal complete reports.
All six native attempts now finish and retain reports within the original deadlines. Unresolved indirect calls and branch tables still prevent acceptance. The selected Kernel return and memory-writer boundary needs evidence; a syscall number, enum name or ABI assumption cannot supply it.
CI run 524 passed all 1,017 Rust tests and 787 Python checks with Rust 1.93.1, without warnings.
The four frame checks remain incomplete: 123 unresolved observations in each runtime profile and 139 in each realm-binding profile, 524 in total. The 6,624-byte entry frame fits the 8,192-byte limit; the fallback and workspace mapping checks pass. Direct early-drop and source-membership proofs are still incomplete.
Run 526 on
6fc7334fstill fails the native frame proof: 123 unresolved observations in each runtime profile and 139 in each realm-binding profile. The Rust and capture tests pass. Work is continuing on the unresolved instruction and call routes.CI 528 still fails on
584985ca: all 1,017 Rust and 816 Python tests pass, but native frame proofs remain incomplete. Three of the six configured profiles emitted incomplete results; the other three emitted no result.The retained parser example still has four table indices whose valid values cannot be derived from local instruction checks. Closing those paths requires following initialized fields and their writers through the source/compiler contract. Kernel return and writer proofs remain separate work in #19.
Published
a97f2368to report the first failed phase and exit status when expiry prevents the usual frame report from reaching the console. The short notice runs only after confirmed cleanup and does not publish proof or extend the analysis clock. All 824 Python tests pass. The native frame obligations remain open; this change does not establish why three profiles in the previous CI run emitted no result.66c2c5b5 preserves exact byte values through matching zero-extension instructions, including low and high register aliases. Conflicting joins and unknown writes still discard the fact.
On a retained native ELF, this narrows two indices to 1 and 6. Both jumps remain unresolved because their table base is unknown; the complete frame proof remains open.
CI 532 passes all 1,017 Rust and 839 Python tests at
66c2c5b5. Each of the six packaged frame checks then reaches the original 60-second deadline during frame analysis. The log emits no per-site report, so the older unresolved counts do not describe this run.The next investigation follows the production preservation analysis on retained bytes. The complete frame gate stays open; the cause of these timeouts is not yet established.
CI534 confirms Rust 1.93.1/LLVM 21.1.8, Python 3.13.5 and objdump 2.44, with all 13 ELF digests now recorded. All 1,017 Rust and 839 Python tests pass. The frame gate still fails: five profiles hit the original 60-second deadline; runtime-release completes with 127 unresolved observations across 275 reached functions. Those counts apply only to the completed profile. The complete original failure log is retained for the next analysis.
Published bf9b909e: the frame checker now follows exact CLD/REP MOVS operations when it can prove the direction, full count and both live stack ranges. It transports complete existing saved-value facts, discards overlapping destinations and drops direction knowledge across calls. Shared byte/operand checks cover malformed copy and direction encodings.
The 19 focused controls and complete 858-test Python suite pass. Actual caller contents and the remaining full-frame proof in #4 remain open.
Exsh
bf9b909estill fails CI536: all six packaged profiles reach the original 60-second frame-analysis deadline. The 1,017 Rust and 858 Python tests pass without warnings. This run emits no unresolved-site counts.The bounded profiler is under review so the next producing job can show where analysis spends its allowance. The frame gate and its deadline remain unchanged.
Published
bd9b9173. The existing six CI frame checks now enable live function counts and inclusive timing samples within their original 60-second allowance. Temporary graph bindings retire before native cleanup, and expired runs emit no new statistics.CI538 is running. Its samples will guide the next optimization; frame acceptance remains open.
CI538 still reaches all six original 60-second frame-analysis deadlines. The new profiler retained 52 valid prefixes: register-preservation derivation completes after roughly 31–33 seconds of graph analysis, while repeated function-body interpretation accounts for roughly 32–37 seconds in the last samples. Context resolution is still active there. These inclusive wall times overlap and include the profiler’s overhead.
The next change will reuse immutable instruction preparation across interpretations while preserving path facts, proof checks and the deadline. Exact input capture is being added separately so future runner cleanup cannot remove the failing ELF bytes.
Published bounded input capture for the failing frame checks. The six CI invocations are configured to export their selected ELF bytes and raw disassemblies through the existing output, within the original deadline and a fixed byte budget. The next step is to use a complete capture for a comparison on the same inputs. Frame acceptance remains open.
4149f3c9adds a conservative negative filter to the shared copy decoder. All outcomes match across 188,869 captured instruction rows; the local decoder loop drops from about 0.16s to 0.09s in both run orders. This is not a whole-checker speedup, and the frame deadlines remain unresolved.893dd9c8speeds up the shared operand splitter for text without parentheses; malformed and parenthesized forms keep the existing scanner. All 188,869 retained instruction operands and 55,987 delimiter cases give the same results. The local operand passes improve from about 0.44 to 0.28 seconds in both orders.All 919 checker tests and source checks pass. CI 546 is running; the six frame checks and the remaining incomplete graph results keep this issue open.
CI 546 on
893dd9c8passes 1017 Rust and 919 checker tests, then all six frame analyses reach their original 60-second deadline. The complete original logs are retained. The returned-cell analysis remains unpublished while byte/text consistency checks are added to its instruction forms.688de047 adds returned stack-byte contents to scalar analysis and reuses immutable body preparation. A later load can now obtain a numeric bound when every ordinary callee return proves the bytes were written. Raw instruction checks and the separate target, register, writer, stack-lifetime and Kernel obligations remain in force.
The captured graph still reaches the original 60-second deadline. Dependency batching also reaches that limit; I’m extending the profiler to measure contents-domain work before choosing the next optimization. This issue remains open.
Pushed 97b47b0a. The checker now finishes discovered child contexts before restarting their parent, reuses complete equal contents states, and reports six fixed content-operation profiler rows. The original writer, origin, stack-lifetime and deadline checks remain.
The full 983-test suite passes, but the retained-input graph still expires at 60 seconds. Complete frame acceptance and a measured speedup remain unproved. CI 550 passes Markdown; Rust is running.
CI550 on
97b47b0apasses all 1,017 Rust and 983 Python tests without warning diagnostics. All six mandatory frame checks still exceed the original 60-second limit, so this issue remains open.The new profiler rows expose saved-register and scalar-content work. Its 44 partial samples overlap and include observer overhead; they do not establish a completed analysis or a speedup. The Markdown job passes.
a65f1264 reuses saved-register state after a checked instruction with no relevant effects. Each visit still retires values against current memory knowledge, including changes learned on another control-flow path. Special decoding and error order are preserved.
The nine focused controls and full 992-test suite pass. The original 60-second graph diagnostic still expires, so frame acceptance remains open. Current CI552 is running.
CI552 on
a65f1264still hits the 60-second deadline on all six mandatory frame targets. The 1,017 Rust tests and 992 Python tests pass. The profiler emits partial samples, but no frame analysis completes.The next change prepares immutable instruction syntax once while keeping path values, stack ownership and deadline checks fresh. Its new tests compare complete reports with preparation enabled and disabled, including refusal cases.
c0763ff4shares lazily decoded instruction syntax across frame analyses. Current register values, memory effects, stack ownership and error order are still checked on every visit.The 16 new controls and full 1,008-test suite pass. The original captured graph still reaches the 60-second deadline, so this issue remains open. CI554 is running; the next change reduces profiler helper dispatch while preserving every check and failure boundary.
Published ac8c1ac3 to reduce helper dispatch in the optional frame profiler. Callback order, first-error handling and observation limits stay unchanged.
The original 60-second graph still expires. The frame issue remains open; I’m adding a bounded way to identify the active function before choosing the next optimization.
e83f5effadds--profile-body-progressalongside--profile-analysis. Existing live checkpoints can now identify the current standalone function and solver root; default profiling is unchanged.The captured graph still exceeds its original 60-second deadline. The partial records identify recurring lexer functions under several callers, without establishing their exclusive cost. Next I’m measuring a phase-level profile with fewer observer calls; the analyzer’s checks and deadlines will stay intact.
Signed commit
7168ee34adds an explicit eight-phase profiler mode; full profiling remains the default. The captured graph still reaches its original 60-second deadline, with context solving and lexer bodies active. This is a diagnostic improvement, not a demonstrated speedup or completed frame check.A separate cleanup defect is tracked in #21.
835dcea2 reuses shared scalar components at joins and immutable native instruction grammar. A controlled 22-case workload completed 135168 joins per variant with identical outputs: 0.818479s before, 0.608491s with identity reuse, across six rotated rounds. That is a 25.7% reduction for this workload.
The complete captured graph still reaches its original 60-second deadline. This change does not resolve the issue or establish a whole-frame speedup. The next profile will distinguish completed context passes discarded while discovering dependencies from passes ready for finishing.
The optional context-pass profiler is published in
b121b5c4. On the retained historical input, completed passes discarded for missing dependencies account for 209557 of 556606 direct grammar visits in completed contextual passes (37.65%). Open passes and nested candidates are counted separately. This measures work, not CPU time or a speedup; the full analysis still reaches its original 60-second deadline.The next optimization targets report dictionaries that those discarded passes never consume, while preserving every original check and the actual missing-dependency decision.
997673f6defers report assembly for passes waiting on callees, after the existing body and report checks. These passes release their local data before child work; ready passes still produce the full report.The fixed comparison kept outputs and guard sequences identical, but timings varied between rounds. The captured graph still reaches its original 60-second limit, so this issue remains open.
CI568 still hits the 60-second frame-analysis deadline for all six targets at
997673f6. The 1,029 Rust tests and 1,084 Python tests pass first.Deferring discarded reports has not resolved this issue. I am narrowing the existing profiler to report transfer, merge and dependency checks to find where the remaining time goes.
The local-first retirement experiment preserved complete outputs and checks, but exposed a performance tradeoff. Across six alternating rounds, 864 complete walks per version took 3.239s with the original predicate and 3.125s with the candidate; two rounds regressed and the ranges overlapped. Separate caller-only cases slowed by about 10–22%, despite substantial local-only gains.
I am narrowing the fast path to inputs without caller intervals and preserving the original caller path. The complete frame deadline remains unresolved.
Published fba2402 replaces the per-cell generators in stack retirement with an ordered region scan. Caller expansion, comparison order and truth conversion stay the same. All twelve direct cases improved in every paired round; complete body walks were mixed, with total time 0.8% higher and overlapping ranges. This supports the local optimization; native frame completion remains open.
The current Exsh run reaches the frame checks again. CI 572 passes all 1,098 Python tests, both Rust unit configurations and the doctests, then each of the six packaged frame checks reaches its 60-second analysis deadline.
The run retains a complete input capture for the runtime development case and partial profiles for all six cases. Those profiles still show work in body analysis, preservation and context solving; none is a completed frame proof. The timeout error reporting fix is working in the unit suite, while this frame-analysis bottleneck remains open.
Profiling the captured runtime/dev input ruled out the proposed shared-register shortcut: none of the joins in the observed prefix used it. That candidate will stay unpublished. The next target is the repeated state construction in
Saved.step; the original 60-second frame-analysis deadline still expires.The Saved.step allocation prototype is also dropped. In a fixed comparison of 864 complete walks per variant, it was 2.55% slower overall and slower in five of six rounds. Its common eligible direct cases were 28–34% slower despite taking the reuse branch. Complete outputs and check order agreed.
The published source is unchanged. Profiling now turns to preservation and graph construction, which account for a larger measured part of the real captured workload. The original 60-second frame limits remain unchanged.
I set aside the tuple-binding shortcut. It is exercised on the retained CI input, but the graph still reaches its original 60-second limit, and the fixed-work comparison shows only a small, mixed overall gain. No change from that prototype was published. The next target is repeated register-state allocation in
ContentAnalysis.step.CI580 on
6cbf7cfcstill expires in all six packaged frame analyses: runtime, realm-bindings and combined features, each in dev and release. Each reports the unchanged 60-second frame-analysis deadline. The complete terminal log shows no import or source-policy failure; Rust tests and all 1,104 Python cleanup tests pass first.The count-one shift mismatch is fixed and tracked separately in closed #23. The deadline remains open; a candidate refactor has passed its focused semantic checks, but its small synthetic timing difference does not establish a whole-work improvement.
A parser-cache prototype did not improve the full-input workload: across three matched local pairs using the current CI inputs, total wall time was 1.5% higher. I’m leaving it out. The baseline takes 73–79 seconds and still reports incomplete analysis, so both runtime and the remaining proof failures need work; these diagnostic runs do not establish a pass under the existing CI deadline.
CI 584 reaches frame analysis after strict Clippy and all 1,035 host tests pass. Six analyses still exceed the unchanged 60-second bound: runtime, realm bindings and all features, each in the packaged development and release selections. The complete log and its new input capture are retained for profiling.
Analysis of the runtime/dev input captured by CI 584 completed in 75.79 seconds. Its frame evidence is still incomplete. A candidate using slots for three immutable records produced the same complete result but took 78.92 seconds, 4.14% longer, so it remains unapplied. The six production checks still have their original 60-second limit.
A sparse index of known join facts did not improve the captured workload: 80.10 seconds versus 78.13 seconds for the current implementation. The complete graph and resolved proof dependencies were identical. The current join implementation stays in place.
The complete profile of the unchanged analyzer matches its original graph, counters, ordering and proof dependencies. Contextual evaluation accounts for 131 of the 177 instrumented seconds. The next candidate targets interpreter work repeated while child summaries are pending, with a full restart whenever its original premises change.
These are attribution results, not a speedup measurement. The earlier candidate was 2.52% slower and remains rejected. The production 60-second gate is unchanged.
The prefix-reuse candidate passes all 447 focused controls, including 21 new cases for changed premises, nested calls, loops, cleanup and custom traversal. It reuses analysis only while the original input rows, context and earlier results still match; otherwise it restarts.
The full Python/IO suite and a fair whole-graph comparison are still pending. The production 60-second limits remain unchanged, and no speedup is claimed yet.
The prefix-reuse candidate passes all 1,125 discovered Python tests, including the native IO/CLI fixtures and 21 new controls. The earlier sparse-join candidate remains rejected after its slower whole-graph result.
Next is the complete graph/proof comparison with the original six inputs. No speedup or success at the production 60-second deadlines is claimed yet.
The prefix-reuse candidate does not establish a useful speedup. With the same six captured inputs, the full graph run took 76.09 seconds for the baseline and 75.90 seconds for the candidate (0.26% difference). Both produced identical graphs, counters and complete dependency proofs.
I am keeping the candidate private and the maintained implementation unchanged. The six CI frame deadlines remain open; the next optimization needs to target a larger measured cost.
CI 590 still reaches the cleanup checker’s frame-analysis deadline at
3ce8164e. The next profile will use this revision and the same retained binary inputs to identify the remaining cost. The production 60-second limit and complete proof checks stay unchanged.ac9b2b2 adds fixed-tuple joins and avoids an unused decoder import. Replaying the recovered CI input preserves the complete graph and work counts, but shows no speedup in this pair: 96.364s before, 97.667s after, with full work counters enabled. This is not a production timing result.
CI 592 still hits all six 60-second analysis deadlines. The checker also needs proofs for several indirect calls and jump-table bounds, so reducing analysis time alone will not complete frame acceptance. I am reassessing the special cases and implementing the missing byte-bound proof.
89e91b74 handles the parser's
cmp AL; branch; MOVZXorder. A checked branch bounds the low byte; only matching zero-extension establishes the complete integer. Upper bits, unknown calls and invalid table targets remain conservative.The new controls and full 1,171-test suite pass. Complete frame acceptance and the original deadlines remain open. Kernel #56 tracks the explicit producer/return contract needed before carrying facts across syscalls.
fb01ad98 selects the published runtime Kernel producer for the runtime/release check. Unknown operations keep opaque memory effects, and the other five analysis routes retain their existing behavior. The actual selected Kernel build succeeds in 30.987s, then the unchanged complete check reaches its 60-second deadline. The retained profile identifies interprocedural context solving as the next bottleneck; exact scalar propagation is in progress.
Published 3964e913 with exact scalar callsite inputs and object-qualified origins across native calls. All 1,209 controls pass, including same-address literals from different objects, conflicting joins and foreign returned-cell ownership. The original complete frame timeout remains unresolved. Context solving is the measured bottleneck; conservative input-dependency analysis is the next change. No speedup is claimed from this feature alone.
CI 600 passes its unit groups, then reaches the same six 60-second frame deadlines. Kernel #56 is closed after publishing the manual and exercising the producer/consumer in CI. The complete frame proof stays open here; the next change reduces scalar context inputs according to what the analyzer actually consumes.
52cd5fb adds opt-in context-key profiling and byte-checked numeric read summaries, including direct calls. Unknown, recursive and unsupported cases stay conservative; memory and origin checks remain intact.
All 1,266 tests pass. The native runtime check still reaches its original 60-second deadline, so the full frame proof remains open. The new profile records solver and body contexts to guide the next change.
c5bb3c7 keeps numeric read summaries conservative when a memory operation has no proved complete GP source set. All 1,272 tests pass. The original frame gate remains open; this correction does not establish a speedup.
04a191e narrows byte/word input dependencies while preserving incoming high bits and origins. All 1,284 tests pass. The original 60-second frame gate remains open; a separate longer diagnostic is running to obtain a complete report.
The separate 300-second local diagnostic on c5bb3c7 finished graph analysis in 194.8 seconds and wrote a complete report. The proof remains incomplete with 140 unresolved observations. Those gaps are now being classified; this diagnostic does not satisfy or change the original 60-second CI gate.
The checker change is published at
5d6239c6. All 1,339 checker tests pass, including 13 new controls for preparation reuse and failure ordering. On the retained CI 612 runtime/dev input, the changed checker completes its graph diagnostic in 59.876 seconds and retains the complete 10.36 MB report. That report still has 31 incomplete frames and 135 unresolved routes. This establishes one completed local observation; the six current CI cases and the full source/native proof remain open.The original CI 616 run for
5d6239c6still reaches the unchanged frame-analysis deadline in all six cases: runtime, realm bindings and all features, each with dev and release packaging. The complete first log is retained. The completed local graph observation does not establish a CI repair. The next work targets the missing Kernel-return premise and an owned handoff of each original linked ELF and optimized IR; source/type and indirect-route obligations remain open.b0d37e66 retains all three PIC builds and the root-crate LLVM emitted by each same rustc invocation. Both packaged variants stay paired with the original build, and each Cargo cohort has a separate native retirement check. The caller now selects input allowances explicitly. Complete compiler/runtime consumption, source and type proof, and all six original frame gates remain open. CI 618 is running.
Pushed
d35289ad. The interpreter now retains an already proven indirect target across an exact local stack spill and reload, which caused the compiled wrapper’s first semantic refusal. Unknown or overlapping writes and released storage still discard it. All 1,381 controls pass, including eighteen new cases. The six native frame cases remain open.CI 620, at
d35289ad, passes all 1,381 Python tests, 1,059 Rust tests and 41 Markdown files, then reaches all six original frame-analysis deadlines without completing their proofs. The separate Kernel evidence-parent failure is fixed in Integration #171. The next change makes matrix continuation depend on the actual analysis outcome and confirmed output retirement, while preserving incomplete-proof status and the existing deadlines.Published
bb3b6ac0with an optional tracing route for identity syscalls and process exit. Other syscalls are refused before execution. The selected child keeps its original process ownership through cancellation and retirement; complete compiler tracing still needs support for input, memory, exec and descendant operations.All 1,480 checker tests pass, including the native cancellation and late-exit controls. This does not resolve the six existing frame-analysis timeouts. Work on the solver bottleneck continues under the original deadlines.