[BUG] Exsh stack proof assumes incidental optimized symbol names #4

Open
opened 2026-09-12 13:31:29 +02:00 by erikinkinen · 69 comments
Owner

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 development
and 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 5249114a634ead34a32ccd44cba613021df1647f
with 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 or
stripping, and linker.ld. Both runtime and all-feature builds succeeded; their
checker invocations failed on the missing
::evaluate_simple_command_resolved_inner symbol. Renaming a required closure
cannot establish the missing path bound.

Expected and actual behavior

Prove the actual optimized paths within the existing limits:

Domain Limit
Ordinary descriptor/evaluator and entry frames 8 KiB
Fallback frame 33 KiB
Direct early-drop chain 56 KiB
Separate user stack 64 KiB

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:

  • Bind the exact signed source and transitive Cargo selections, approved tools,
    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.
  • Carry the live producer's evidence into analysis, or use an explicitly
    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.
  • Establish provider/callback/SSA closure, aliases, memory effects and native
    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.
  • Keep sealed inputs, retained pins, current-interpreter selection and every
    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.
  • Preserve mapping checks, original resource accounting and adversarial controls
    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:

Owner Capture/input Other byte allowances Total Quiet
Producer 2 GiB 512 MiB aggregate transport, including both copies; 64 MiB retained output 1,800 s 240 s
Checker 1 GiB 64 MiB output 300 s 15 s

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, targeting
x86_64-unknown-none. The original runtime ELF digest was
1e63b3930c3fb440e29461d96e19d7b63fb0977961d76ce3491ae739771ceecd;
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 118ef9caef0c67d9f9382fee544589d92f2c1dc6 passes the Rust
and 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

  • Complete native compiler/runtime/input ownership and source delivery.
  • Establish ordinary-source and direct-versus-nested path membership.
  • Complete callback/provider/SSA and independent register/write/Kernel effects.
  • Prove all required stack and mapping domains under their declared limits.
  • Pass the complete native gate with its positive, malformed and cleanup controls.

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.

## 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][workflow], including the native `exsh-runtime`, realm-binding and all-feature builds and their paired development and 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 `5249114a634ead34a32ccd44cba613021df1647f` with 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 or stripping, and `linker.ld`. Both runtime and all-feature builds succeeded; their checker invocations failed on the missing `::evaluate_simple_command_resolved_inner` symbol. Renaming a required closure cannot establish the missing path bound. ## Expected and actual behavior Prove the actual optimized paths within the existing limits: | Domain | Limit | | --- | ---: | | Ordinary descriptor/evaluator and entry frames | 8 KiB | | Fallback frame | 33 KiB | | Direct early-drop chain | 56 KiB | | Separate user stack | 64 KiB | 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][contract]: - Bind the exact signed source and transitive Cargo selections, approved tools, 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. - Carry the live producer's evidence into analysis, or use an explicitly 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. - Establish provider/callback/SSA closure, aliases, memory effects and native 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. - Keep sealed inputs, retained pins, current-interpreter selection and every 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. - Preserve mapping checks, original resource accounting and adversarial controls 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: | Owner | Capture/input | Other byte allowances | Total | Quiet | | --- | ---: | --- | ---: | ---: | | Producer | 2 GiB | 512 MiB aggregate transport, including both copies; 64 MiB retained output | 1,800 s | 240 s | | Checker | 1 GiB | 64 MiB output | 300 s | 15 s | 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, targeting `x86_64-unknown-none`. The original runtime ELF digest was `1e63b3930c3fb440e29461d96e19d7b63fb0977961d76ce3491ae739771ceecd`; 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][ci] at `118ef9caef0c67d9f9382fee544589d92f2c1dc6` passes the Rust and 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][contract] and [architecture][architecture]. New status belongs in comments. The separate [tool-selection defect][tool-selection] and [compiler-performance issue][compiler] have their own evidence and scope. ## Tracking - [ ] Complete native compiler/runtime/input ownership and source delivery. - [ ] Establish ordinary-source and direct-versus-nested path membership. - [ ] Complete callback/provider/SSA and independent register/write/Kernel effects. - [ ] Prove all required stack and mapping domains under their declared limits. - [ ] Pass the complete native gate with its positive, malformed and cleanup controls. Implementation: [Exsh PR #3][pr]. Related work: [native deployment][native], [library audit][dynlink] and [manual documentation][manual]. Both full EriX guest build generations, Rust/LLVM rebuilding inside EriX and the service/profiler VM requirements remain tracked by [Phase 6 completion][phase]. 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. [workflow]: https://git.erikinkinen.fi/erix/exsh/src/branch/feature/posix-compat/.github/workflows/ci.yml [contract]: https://git.erikinkinen.fi/erix/exsh/src/commit/118ef9caef0c67d9f9382fee544589d92f2c1dc6/docs/descriptor-cleanup-frames.md [architecture]: https://git.erikinkinen.fi/erix/exsh/src/branch/feature/posix-compat/ARCHITECTURE.md [ci]: https://git.erikinkinen.fi/erix/exsh/actions/runs/502 [tool-selection]: https://git.erikinkinen.fi/erix/exsh/issues/5 [compiler]: https://git.erikinkinen.fi/erix/exsh/issues/9 [pr]: https://git.erikinkinen.fi/erix/exsh/pulls/3 [native]: https://git.erikinkinen.fi/erix/exsh/issues/8 [dynlink]: https://git.erikinkinen.fi/erix/lib-dynlink/issues/2 [manual]: https://git.erikinkinen.fi/erix/docs/issues/8 [phase]: https://git.erikinkinen.fi/erix/integration/issues/65
Author
Owner

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.

Added a direct-child wait owner in [13d15fb8](https://git.erikinkinen.fi/erix/exsh/commit/13d15fb8f7e45d7ed409241f2ad663a5910ab14a). 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.
Author
Owner

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.

[34c91497](https://git.erikinkinen.fi/erix/exsh/commit/34c91497a4c02806a5cfbcc001dc75bf06e135e7) 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.
Author
Owner

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.

The full cleanup proof still fails in [run 512](https://git.erikinkinen.fi/erix/exsh/actions/runs/512) at [6ffb6994](https://git.erikinkinen.fi/erix/exsh/commit/6ffb6994731abdd737f635a6413b94356062c11c). 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.
Author
Owner

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_above and execute_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.

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_above` and `execute_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.
Author
Owner

The boundary needs to be narrower than the two proposed *_above wrappers: 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.

The boundary needs to be narrower than the two proposed `*_above` wrappers: 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.
Author
Owner

090ede2f prints 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.

[`090ede2f`](https://git.erikinkinen.fi/erix/exsh/commit/090ede2f30ba0520f4e28db86171cf06e329fc06) prints 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](https://git.erikinkinen.fi/erix/exsh/issues/4). Complete compiler-input ownership, source-to-machine-code relationships and all reachable frame paths remain open.
Author
Owner

0849638 adds 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.

`0849638` adds 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.
Author
Owner

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.

[dff37e2](https://git.erikinkinen.fi/erix/exsh/commit/dff37e2e5e2350de980a99478d6c2c41addf4f78) adds instruction bytes, refused jump-table alternatives and original producer sites to the first frame-analysis refusal. The remaining failure is tracked in [#4](https://git.erikinkinen.fi/erix/exsh/issues/4); the existing frame and call-target rules still apply.
Author
Owner

The latest run on dff37e2e still 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.

The [latest run on `dff37e2e`](https://git.erikinkinen.fi/erix/exsh/actions/runs/522) still 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.
Author
Owner

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.

[64f7b7d](https://git.erikinkinen.fi/erix/exsh/commit/64f7b7d0427ea2ce78b6f82f42838a56f8161913) 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.
Author
Owner

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.

[CI run 524](https://git.erikinkinen.fi/erix/exsh/actions/runs/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.
Author
Owner

Run 526 on 6fc7334f still 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.

[Run 526](https://git.erikinkinen.fi/erix/exsh/actions/runs/526) on `6fc7334f` still 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.
Author
Owner

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.

[CI 528](https://git.erikinkinen.fi/erix/exsh/actions/runs/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](https://git.erikinkinen.fi/erix/exsh/issues/19).
Author
Owner

Published a97f2368 to 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.

Published `a97f2368` to 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.
Author
Owner

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.

[66c2c5b5](https://git.erikinkinen.fi/erix/exsh/commit/66c2c5b5f1d50ba4d34c504a0986e93da383af90) 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.
Author
Owner

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.

[CI 532](https://git.erikinkinen.fi/erix/exsh/actions/runs/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.
Author
Owner

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.

[CI534](https://git.erikinkinen.fi/erix/exsh/actions/runs/534) 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.
Author
Owner

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.

Published [bf9b909e](https://git.erikinkinen.fi/erix/exsh/commit/bf9b909e630c3c8c59e0144f8b361b741933b450): 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](https://git.erikinkinen.fi/erix/exsh/issues/4) remain open.
Author
Owner

Exsh bf9b909e still 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.

Exsh `bf9b909e` still fails [CI536](https://git.erikinkinen.fi/erix/exsh/actions/runs/536): 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.
Author
Owner

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.

Published [`bd9b9173`](https://git.erikinkinen.fi/erix/exsh/commit/bd9b9173bb8e1c565c1ca92e2a66a3751df6269d). 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](https://git.erikinkinen.fi/erix/exsh/actions/runs/538) is running. Its samples will guide the next optimization; frame acceptance remains open.
Author
Owner

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.

[CI538](https://git.erikinkinen.fi/erix/exsh/actions/runs/538) 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.
Author
Owner

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.

Published [bounded input capture](https://git.erikinkinen.fi/erix/exsh/commit/fe35259d57cf82fdb8838b26c8f099ff3bcd4dcf) 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.
Author
Owner

4149f3c9 adds 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.

`4149f3c9` adds 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.
Author
Owner

893dd9c8 speeds 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.

`893dd9c8` speeds 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.
Author
Owner

CI 546 on 893dd9c8 passes 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.

CI 546 on `893dd9c8` passes 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.
Author
Owner

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.

[688de047](https://git.erikinkinen.fi/erix/exsh/commit/688de0477d297222521072a766ef40d344da3d6c) 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.
Author
Owner

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.

Pushed [97b47b0a](https://git.erikinkinen.fi/erix/exsh/commit/97b47b0af60d1c60662dc6b05169eb7b6699672a). 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](https://git.erikinkinen.fi/erix/exsh/actions/runs/550) passes Markdown; Rust is running.
Author
Owner

CI550 on 97b47b0a passes 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.

[CI550](https://git.erikinkinen.fi/erix/exsh/actions/runs/550) on `97b47b0a` passes 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.
Author
Owner

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.

[a65f1264](https://git.erikinkinen.fi/erix/exsh/commit/a65f1264b88eed4f67097e14e8737fe93390d795) 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.
Author
Owner

CI552 on a65f1264 still 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.

CI552 on `a65f1264` still 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.
Author
Owner

c0763ff4 shares 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.

`c0763ff4` shares 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.
Author
Owner

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.

Published [ac8c1ac3](https://git.erikinkinen.fi/erix/exsh/commit/ac8c1ac36437f3d45566bc975ca9f20e065082bc) 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.
Author
Owner

e83f5eff adds --profile-body-progress alongside --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.

`e83f5eff` adds `--profile-body-progress` alongside `--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.
Author
Owner

Signed commit 7168ee34 adds 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.

Signed commit `7168ee34` adds 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](https://git.erikinkinen.fi/erix/exsh/issues/21).
Author
Owner

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.

[835dcea2](https://git.erikinkinen.fi/erix/exsh/commit/835dcea2d6b55ce75599f1947c07378a2da9487c) 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.
Author
Owner

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.

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.
Author
Owner

997673f6 defers 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.

`997673f6` defers 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.
Author
Owner

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.

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.
Author
Owner

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.

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.
Author
Owner

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.

Published [fba2402](https://git.erikinkinen.fi/erix/exsh/commit/fba240218d70f0738beccc7c9dfbb7cac6330d4b) 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.
Author
Owner

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.

The current Exsh run reaches the frame checks again. [CI 572](https://git.erikinkinen.fi/erix/exsh/actions/runs/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.
Author
Owner

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.

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.
Author
Owner

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.

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.
Author
Owner

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.

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`.
Author
Owner

CI580 on 6cbf7cfc still 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.

[CI580](https://git.erikinkinen.fi/erix/exsh/actions/runs/580) on `6cbf7cfc` still 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.
Author
Owner

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.

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.
Author
Owner

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.

[CI 584](https://git.erikinkinen.fi/erix/exsh/actions/runs/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.
Author
Owner

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.

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.
Author
Owner

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.

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.
Author
Owner

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 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.
Author
Owner

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 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.
Author
Owner

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 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.
Author
Owner

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.

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.
Author
Owner

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.

[CI 590](https://git.erikinkinen.fi/erix/exsh/actions/runs/590/jobs/0/attempt/1) 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.
Author
Owner

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.

[ac9b2b2](https://git.erikinkinen.fi/erix/exsh/commit/ac9b2b273c330a023b1eb621f191676244f5a1b3) 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](https://git.erikinkinen.fi/erix/exsh/actions/runs/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.
Author
Owner

89e91b74 handles the parser's cmp AL; branch; MOVZX order. 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.

[89e91b74](https://git.erikinkinen.fi/erix/exsh/commit/89e91b74bebd95b44c99a61b50fb931a78387c32) handles the parser's `cmp AL; branch; MOVZX` order. 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](https://git.erikinkinen.fi/erix/kernel/issues/56) tracks the explicit producer/return contract needed before carrying facts across syscalls.
Author
Owner

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.

[fb01ad98](https://git.erikinkinen.fi/erix/exsh/commit/fb01ad98b5133da904290440613ee5532d5fd435) 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.
Author
Owner

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.

Published [3964e913](https://git.erikinkinen.fi/erix/exsh/commit/3964e913354136f265b73e84455ae451d8b03f2a) 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.
Author
Owner

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.

[CI 600](https://git.erikinkinen.fi/erix/exsh/actions/runs/600) passes its unit groups, then reaches the same six 60-second frame deadlines. [Kernel #56](https://git.erikinkinen.fi/erix/kernel/issues/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.
Author
Owner

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.

[52cd5fb](https://git.erikinkinen.fi/erix/exsh/commit/52cd5fb0ac938193436ca99d8a18e537c19bfcee) 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.
Author
Owner

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.

[c5bb3c7](https://git.erikinkinen.fi/erix/exsh/commit/c5bb3c7b6fa03a14f300625bcad74a74c9d10a74) 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.
Author
Owner

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.

[04a191e](https://git.erikinkinen.fi/erix/exsh/commit/04a191e1af5eddf8f376dabf6747479a730c81e2) 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.
Author
Owner

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 separate 300-second local diagnostic on [c5bb3c7](https://git.erikinkinen.fi/erix/exsh/commit/c5bb3c7b6fa03a14f300625bcad74a74c9d10a74) 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.
Author
Owner

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 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.
Author
Owner

The original CI 616 run for 5d6239c6 still 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.

The original CI 616 run for `5d6239c6` still 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.
Author
Owner

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.

[b0d37e66](https://git.erikinkinen.fi/erix/exsh/commit/b0d37e66769f0c595859a97436f7f7e8b9186a53) 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](https://git.erikinkinen.fi/erix/exsh/actions/runs/618) is running.
Author
Owner

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.

Pushed [`d35289ad`](https://git.erikinkinen.fi/erix/exsh/commit/d35289ad56c12fb636292696beb30717921fe97a). 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.
Author
Owner

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.

[CI 620](https://git.erikinkinen.fi/erix/exsh/actions/runs/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](https://git.erikinkinen.fi/erix/integration/issues/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.
Author
Owner

Published bb3b6ac0 with 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.

Published bb3b6ac0 with 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.
erikinkinen added this to the Alpha 1 milestone 2026-10-30 09:33:48 +01:00
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
erix/exsh#4
No description provided.