Skip to content

feat(lifecycle): stop the current verdict's identities before proving completion - #100

Merged
alphastorm merged 43 commits into
mainfrom
feat/lifecycle-stop-census
Nov 15, 2026
Merged

alphastorm merged 43 commits into
mainfrom
feat/lifecycle-stop-census

Conversation

@alphastorm

@alphastorm alphastorm commented Nov 14, 2026 •

Copy link
Copy Markdown
Owner

Stop owned lifecycle identities before proving completion

Invariant

Where structural custody permits it, lifecycle stop attempts only recorded identities and their verified descendants in at most two passes, and reports stopped or records an empty-tree proof only after a readable unfiltered empty final census, observed absence or replacement of every runtime-only identity it left, and no record, census or job failure.

Mechanism

  • Selection starts from the shared verdict: only recorded identities and their verified descendants are cleanup targets. A process is not signalled while attributed only by its executable's location; if a verdict used for a termination pass verifies it as a recorded identity's descendant, it receives the same attempt as any descendant. Stop remembers a location-only observation until it attempts that identity; an observation after the attempt is remembered anew. Status and admission retain the verdict's existing attribution; an absent record is not an empty process world.
  • A readable existing run is fenced as stop_incomplete and its prior empty-tree proof revoked before native effects. An absent or unreadable run is never created or overwritten.
  • Missing jobs do not hide available cleanup. Open, generation, termination, close and scan failures remain named failures while other available cleanup is attempted. Helper launch, timeout, exit, decoding and JSON errors become lifecycle errors at the job snapshot boundary, including candidate admission.
  • A fresh verdict follows the job phase, so termination never uses the pre-job selection. A false result, permission denial or ProcessLookupError is followed by an accounted recheck and cleanup continues; only proved absence or reuse dismisses failure, never individual no-match or cannot-say.
  • At most two termination passes use full identities, not PID-only bookkeeping. Executable keys reuse the reader's comparison: case-insensitive on Windows and ignoring the procfs unlinked-image suffix on POSIX. Children precede ancestors represented by the verdict's own live set and ancestry map. The preference is identities outside the base's selection in stable verdict order, recorded engine/tree members outside the server/wrapper subtrees in reverse record order, server descendants deepest first and server, then wrapper descendants deepest first and wrapper. The ancestry map retains the breadth-first walk needed to recover that subtree order; child precedence overrides the preference.
  • Available identified candidates survive uncertainty; individually verified, shape-valid recorded identities supplement unavailable-census cleanup. For these fallback identities, a raw parent number becomes an ordering edge only when comparable counter stamps prove the parent was created earlier; equal, mixed-clock or calendar stamps provide no such edge. Earlier record/census/job failure stays a failure even if a later observation recovers.
  • A final verdict follows the last termination pass and token scan. Its counted identities are not filtered through the already-attempted set. Final-live identities are reported using that verdict's own roles and observations: an unattempted location-only identity is named once with manual-cleanup advice; every other role is listed among the survivors under that role, without manual instruction. Multiple recorded roles of one identity retain separate survivor entries; the identity-once claim applies only to manual-cleanup and earlier-observation lines. A verified descendant first identified only by the final verdict was not attempted in this call; it remains a survivor and a repeated stop attempts it. Memory of earlier observations is used only for identities absent from the final live set. Every observation still remembered requires proved departure, regardless of an earlier attempt: if the reader cannot prove departure, the message names an earlier observation and warns to check identity before ending anything. Both current survivors and unproved departures refuse completion, including on the absent-record path and for indistinguishable one-second replacements.
  • Result labels prefer a recorded server or wrapper role over descendant attribution. A recorded wrapper beneath the recorded server is therefore labelled wrapper where the base reported server-descendant; the identity sequence follows the base preference, subject to child-before-ancestor precedence.

What changes for an operator

Before After
Stop selected recorded server/wrapper trees and individual engine/tree records, and could leave census-only runtime survivors or children of engine/tree members behind while returning stopped. Stop attempts only recorded identities and verified descendants, with a bounded further pass. Processes attributed only by executable location are not signalled, just as on the base, but stop now names current survivors and refuses unproved departures. A verified descendant seen by a termination pass receives the normal attempt; a final-only descendant remains a survivor for a repeated stop. Empty final evidence and observed departure of every identity left are required.
A stale creation stamp or executable could be dropped by individual comparison and yield stopped. A disagreement that cannot prove absence or reuse refuses with incomplete evidence. The original no-signal safety remains; messages identify the PID/evidence and manual reconciliation. There is no automatic stale-record override.
Advice directed census-only, engine/tree-child and deleted-image cases to manual process cleanup because stop did not select them. Structurally admitted advice offers stop; launching advice first explains delayed-wrapper fencing and says stop also attempts counted processes. It never promises native termination will succeed.
A missing job or helper failure could bypass available census cleanup or escape as a helper exception. Available cleanup proceeds; named failures revoke completion proof. Candidate admission also receives the normalized helper error.

Lifecycle stop and start's generation-guarded failure cleanup use the same loop. Identical diagnostic texts are reported once, in first-seen order. If start and cleanup both fail with errors, the lifecycle error names the start failure first and cleanup failure second. If start was interrupted and cleanup fails with an error, that lifecycle error still names both in the same order. An interrupt during cleanup remains an interrupt, as before this change; successful cleanup re-raises the original start exception. CLI restart cannot proceed through a refused stop. G16 and G20 in scripts/realhost_gates.py inherit the lifecycle result; their other evidence rules are unchanged, as are the indirect restart/cleanup calls in scripts/requalify.py.

Finite models

These are overlapping bounded domains, not a sum of independent native situations. Product counts describe only their enumerated inputs; qualification scope and reproduction commands are below.

Model Domain and size What is exhaustive here / what is sampled
State/consumer 3,956 cells across current run forms and role liveness, four install relations, extra-process forms, census and port states, with the existing pruning. Every included cell retains shared admission/status attribution; runtime-only members refuse stop rather than authorizing signals. All thirteen rows reached; recorded signals match the base set and stable order subject to child precedence in exactly 320 asserted worlds. Arbitrary graphs, metadata and interleavings are sampled.
Evidence 16,128 = six run forms × seven install forms × three job proofs × two platforms × missing/present job × survivor × port × eight availability schedules. Completion requires readable empty final evidence throughout this product. Three-observation schedules sample longer histories.
Custody/advice 192 platform/job/token/state/unpublished/survivor cells. Every included advice/action pair preserves structural custody; later external failures are not promises of success.
Closed rows 52 = thirteen rows × two platform flags × two job-presence flags. Every row has a concrete witness on both platforms; other witnesses are sampled.
Job boundary 300 = fifteen job outcomes × five current-identity states × four availability schedules. The 240-cell same/exited/foreign/owned core retains sixty enumerated-unidentified cells. Every included boundary checks available cleanup, stale/foreign safety and proof revocation. Four named availability schedules sample, rather than exhaust, all possible observation histories.
Helper consumers 15 = five helper failures × closed-job stop/lifecycle stop/candidate admission. Every representative fault crosses the actual snapshot error boundary; not native Windows execution.
Replacement 24 = three replacement events × two table orders × two reused PIDs × one/two replacements. Runtime-only replacements are driven by census observations rather than by forbidden signals and always remain named refusals. Two additional verified-descendant schedules exercise full-identity deduplication and the two-pass bound. Arbitrary timing and native signal races are outside the product.
Failure recheck 10 = false/PermissionError × SAME/OTHER/ABSENT/UNKNOWN/unavailable. Only positive absence or reuse dismisses failure in the whole domain.
Uncertainty cleanup 35 role/state cells; five unknown-role/runtime-only cases and five new unknown-role/verified-descendant cases; four malformed-role/unavailable-table cases; runtime-only and recorded-owner launcher transitions. Unknown never proves completion; identified cleanup remains available; malformed roles never reach fallback. The malformed forms and transitions are representative.
Order Eight full-tree cases across world order, retained/uncertain parent edge and record order; one outside-intermediary case. Every selected ancestor pair is checked, not just one parent/child. Runtime-only or outside intermediaries are never adopted; runtime-only survivors refuse completion. Other graph shapes are sampled.
Base-order differential 40 = five topologies × two table orders × two engine/tree record orders × ready/stopped. Complete base selection, with a reference copy of the base ordering rule; compares the entire signalled identity sequence. Includes both forests, a chain, a single server and branching recorded descendants. Independent native enumeration can differ from the census.
Additional boundaries Two lookup-error outcomes; four absent no-op and four absent-record refusal/port-error cases; one initially-present record removed at job close; one recorded wrapper beneath a server; two opposite first-seen diagnostic orders; four start/cleanup error-or-interrupt combinations, successful/refused cleanup controls and two CLI cleanup outcomes; two executable-case platform flags and two deleted-image cells; exact-text promotion and unproved-departure cases; four final-role transition/platform cells; repeated stop from the first call's files, two supplied-job absent-record profile cells and a final-port interrupt after proof publication. Available/unavailable GPU observations and failing port probes, retained original start error, reader-equivalent executable keys, final-role survivor reporting, nested-wrapper label precedence, and the active job-close return without record recreation. These are witnesses, not all native races or failure histories.
Runtime-location boundaries Twelve parent/platform cells, an aliased runtime and a runtime subtree beside recorded cleanup; eight unidentified/absent-parent × platform × record cells. Only the two verified-owned-parent cells signal; all runtime-only cells stay live and are named.
New refusal/departure boundary Eight platform × runtime-kind cells; three changing-parent worlds; 45 record-kind × observation × appearance cells. Runtime-only orphans, foreign-parent children, aliases and reader-unvouched children never signal. All recorded roles and verified descendants still receive attempts. Every completion path requires observed departure; unknown or unavailable evidence refuses.
Temporal memory 270 proposed observation/return worlds; 236 reachable = 20 absent-record + 54 ordinary + 162 token-proof; 34 unreachable cells. All three-verdict ordinary sequences and all four-verdict job sequences vary not-shown/location-only/owned independently, with four individual outcomes when final-not-shown. Nineteen owned sequences are impossible with no record throughout (34 cells). A plain temporal rule determines every refusal and return; manual/historical lines name the identity once and survivors retain the final role list. Two coarse-stamp descendant-reissue worlds pin the native-effect transition.
Fallback edges Five reciprocal-parent worlds: Windows counters, procfs counters, equal counters, mixed clocks and calendar stamps. Both recorded identities receive attempts; only provably earlier counter-clock parents order them. Unavailable census still prevents completion.
Actual gates 32 structural stop actions; six candidate fresh-scan outcomes with/without generation fence. Executed refusal boundaries, not merely advice text. Native permission/timing behavior remains unqualified.
Local interruptions Nine P0–P8 interruption points, plus child-before-parent/idempotence and delayed-wrapper fixtures. Real repository-owned local process, lock, writer and start-failure transitions; selected interruption points, not physical-host qualification.

The state/evidence products include 216 of 3,956 state cells and 5,712 of 16,128 evidence cells with runtime-only signal refusal; their status/admission attribution is unchanged. The state model pins exactly 320 base-order exceptions: recorded children precede recorded ancestors; all other recorded order is the base order. The forty complete-base-selection worlds retain their full sequence comparison; the state model permits additional signals over the base only to verified descendants. Fixture-driven replacement observations and separate verified-descendant controls keep the same boundaries observable without assuming a forbidden runtime-only signal.

Limits

  • #91: native termination still has an identity-check-then-signal window. False returns, permission denial and ProcessLookupError now use the accounted recheck and allow remaining cleanup. Other native errors propagate and may interrupt cleanup before a final census; there is no atomic signal claim.
  • #92: ordinary POSIX process stamps can conflate same-PID/same-executable lifetimes within one second. Still-counted identities refuse completion rather than disappearing.
  • Ordering is limited to relations represented by the verdict. An uncertain edge, or a chain through an outside-ownership intermediary, imposes no ancestor ordering; the intermediary is not signalled. Stable verdict order is not a global deepest-first or original-census-order promise.
  • While identifiable, a location-only process remains in the verdict's live set and keeps the root from being idle. Stop remembers a location-only observation until it attempts that identity; an observation after the attempt is remembered anew. An observation still remembered outside the final live set refuses if departure cannot be proved. Once it becomes unidentifiable, status, admission and a repeated stop cannot recover that observation and may see an idle root. #102 tracks ownership made at launch and persistent attribution. Two roots sharing a runtime directory count each other's identifiable processes, and neither's stop completes while the other's remain identifiable; executable location alone never authorizes signalling.
  • If no run record is read during the call, there are no recorded targets or token for native-job cleanup; a supplied job alone is not authority. Successful absent-record calls return an empty stopped list without the final port wait; multi-GPU results use idle observations and owned_gpus_released: null. A record read earlier can disappear during cleanup: retained identities or a job token can still drive cleanup, while a later verdict observing absence disables further writes. Active calls take the normal return and final port wait, with attempted PIDs plus retained engine/server-tree PIDs for GPU ownership and a boolean release result. The host-free test removes an initially present record in the fake job-close callback after job cleanup and checks that active return without recreation; it does not claim active cleanup with the record absent throughout or that native close removes the file.
  • A stopped result says nothing about the configured port; status and start do. Except for that successful absent-record no-op, the bounded port wait follows cleanup and any permitted record write, including absent-record failure paths. Errors from that final post-cleanup port wait propagate; where publication is permitted, the final record write precedes the wait. Absent or unreadable records are not published.
  • A damaged install record prevents completion even after available cleanup, with or without a run record. Repeating stop fences and proves a stopped root again. After the fence and before the final result is published, interruption leaves an existing, writable run record stop_incomplete and running stop again is the recovery. An interruption during the port wait after publication leaves the published result.
  • #101: HostAdapter.stop in the experiment loop remains separate: it writes the same tree_verified_empty token after retained native-job termination and token/observed-identity enumeration, without this loop's final runtime census. This is a narrower proof denominator, not a claim that every writer of that field was migrated.
  • #94: G20's separate individual-comparison leftovers remain unchanged. #95: no new stale-record acknowledgement mechanism is added.
  • The reader's same-host/PID/time-namespace precondition, counter-only reuse proof, uncertain ancestry, executable fidelity and ownership boundary remain unchanged. Unidentified unrecorded processes and outside-runtime processes without owned ancestry are not automatically adopted.
  • Evidence is not an atomic transaction across records, process reads, helpers and native effects. Models and owned local fixtures do not qualify a GPU, serving engine, native Windows host or physical deployment.

Base dependency and reproducible qualification

The base is ccad158d6b7204f91e221ac48d6d4c2a2933da58. Its verdict reader refuses a repeated JSON key at any depth. Stop consumes that unreadable-record verdict; this patch does not implement a second parser rule.

Author-run qualification at e6b92e2ccb82e8b7e2a1aece770a99dbd336cf62:

  • Focused selection: 319 tests pass, 48.168 seconds; 334 owned subprocesses, none unreaped or left.
  • Whole suite: 1,414 discovered; 1,407 run, OK (skipped=10, expected failures=4), 503.790 seconds; 4,028 owned subprocesses, none unreaped or left. Skip and expected-failure policies are unchanged.
  • Repository checks: hygiene, compatibility rendering and documented-route inspection pass; 11 documentation-reader tests, 166 profiles/routes and 164 manifests pass. Releases/profiles/routes are unchanged against the full base commit.
  • Mutation controls: 45-method baseline passes; 56/56 killed. Omitting the attempt-time drop, restoring attempted-membership filtering, and dropping after the following verdict produce 28, 18 and 18 assertion failures, respectively, with zero errors. The checked-in temporal model kills all three; both reissued-child regressions also kill the latter two.

These measurements are author-run host-free evidence, not native-host qualification. The repository commands below reproduce the focused/model selections, whole suite and checks; eight selected observation/identity controls are self-contained below.

Run from the repository root with Python 3.13 and the repository's development dependencies. The focused selection is:

PYTHONDONTWRITEBYTECODE=1 python3 -m unittest \
  tests.unit.test_lifecycle tests.unit.test_lifecycle_states \
  tests.unit.test_lifecycle_stop tests.unit.test_lifecycle_evidence \
  tests.unit.test_lifecycle_records tests.unit.test_process_jobs \
  tests.unit.test_process_table tests.unit.test_experiment_loop

For the ownership/ordering products and their individual counts:

PYTHONDONTWRITEBYTECODE=1 python3 -m unittest \
  tests.unit.test_lifecycle_states.StateTableWalk \
  tests.unit.test_lifecycle_states.EvidenceAndCustodyWalk \
  tests.unit.test_lifecycle_states.StopIdentityWalk \
  tests.unit.test_lifecycle_states.InterruptionWalk \
  tests.unit.test_lifecycle_stop tests.unit.test_lifecycle_evidence

The eight controls below exercise final-role reporting, diagnostic classes, executable equivalence and all three temporal-memory mistakes. Their baseline contains seven checked-in methods; they do not reproduce the whole campaign:

PYTHONDONTWRITEBYTECODE=1 python3 - <<'PY'
import contextlib
import io
from pathlib import Path
import unittest
from omp_strata import lifecycle

source = Path(lifecycle.__file__).read_text()
saved = dict(lifecycle.__dict__)
def run(names):
    output = io.StringIO()
    with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
        return unittest.TextTestRunner(stream=output).run(unittest.defaultTestLoader.loadTestsFromNames(names))

selection = ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_promoted_and_attempted_identity_is_not_reported_as_left', 'tests.unit.test_lifecycle_stop.StopObservationTextTests.test_final_role_owns_survivor_reporting', 'tests.unit.test_lifecycle_stop.StopObservationTextTests.test_deleted_image_is_one_left_or_attempted_identity', 'tests.unit.test_lifecycle_stop.StopObservationTextTests.test_unavailable_departure_check_does_not_claim_current_liveness', 'tests.unit.test_lifecycle_stop.StopTemporalMemoryWalk', 'tests.unit.test_lifecycle_stop.StopReissuedIdentityTests']
baseline = run(selection)
assert baseline.wasSuccessful() and baseline.testsRun == 7
print("baseline", baseline.testsRun, "passed")
controls = [('attempted-kept-as-left', [['if role.startswith("unrecorded[") and identity(proc) not in done}', 'if role.startswith("unrecorded[")}']], ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_promoted_and_attempted_identity_is_not_reported_as_left', 'tests.unit.test_lifecycle_stop.StopObservationTextTests.test_final_role_owns_survivor_reporting']), ('current-survivor-gets-historical-text', [['            refused.append(f"unrecorded process running from this root\'s runtime which stop does not signal: "\n                           f"{Path(proc.exe).name} pid {proc.pid}; end it by hand")', '            refused.append(f"process seen earlier from this root\'s runtime could not be observed gone: "\n                           f"{Path(proc.exe).name} pid {proc.pid}; this PID may now belong to another process; "\n                           "check its identity before ending anything")']], ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_deleted_image_is_one_left_or_attempted_identity']), ('uncertain-departure-gets-current-text', [['                refused.append(f"process seen earlier from this root\'s runtime could not be observed gone: "\n                               f"{Path(proc.exe).name} pid {proc.pid}; this PID may now belong to another process; "\n                               "check its identity before ending anything")', '                refused.append(f"unrecorded process running from this root\'s runtime which stop does not signal: "\n                               f"{Path(proc.exe).name} pid {proc.pid}; end it by hand")']], ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_unavailable_departure_check_does_not_claim_current_liveness']), ('reader-executable-equivalence-removed', [['return proc.pid, proc.created, procs._comparison_executable(proc.exe)', 'return proc.pid, proc.created, proc.exe']], ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_deleted_image_is_one_left_or_attempted_identity']), ('final-role-ignored-for-remembered-identity', [['if role.startswith("unrecorded[") and identity(proc) not in done}', 'if identity(proc) in left and identity(proc) not in done}']], ['tests.unit.test_lifecycle_stop.StopObservationTextTests.test_final_role_owns_survivor_reporting']), ('attempt-memory-drop-omitted', [['                    left.pop(key, None)\n', '']], ['tests.unit.test_lifecycle_stop.StopTemporalMemoryWalk', 'tests.unit.test_lifecycle_stop.StopReissuedIdentityTests']), ('attempt-membership-restored-at-final-memory', [['if key not in final_identities and not gone(proc):', 'if key not in done and key not in final_identities and not gone(proc):']], ['tests.unit.test_lifecycle_stop.StopTemporalMemoryWalk', 'tests.unit.test_lifecycle_stop.StopReissuedIdentityTests']), ('memory-drop-after-following-verdict', [['                    left.pop(key, None)\n', ''], ['            if attempt == 0:\n                root = verdict(layout)\n                evidence(root)', '            if attempt == 0:\n                root = verdict(layout)\n                evidence(root)\n                for key in done:\n                    left.pop(key, None)'], ['        final = verdict(layout)\n        evidence(final)', '        final = verdict(layout)\n        evidence(final)\n        for key in done:\n            left.pop(key, None)']], ['tests.unit.test_lifecycle_stop.StopTemporalMemoryWalk', 'tests.unit.test_lifecycle_stop.StopReissuedIdentityTests'])]
for name, replacements, tests in controls:
    changed = source
    for before, after in replacements:
        assert changed.count(before) == 1
        changed = changed.replace(before, after)
    try:
        exec(compile(changed, lifecycle.__file__, "exec"), lifecycle.__dict__)
        result = run(tests)
        print(name, result.testsRun, "tests", len(result.failures), "failures", len(result.errors), "errors")
        assert result.failures and not result.errors, name
    finally:
        lifecycle.__dict__.clear()
        lifecycle.__dict__.update(saved)
PY

CLI cleanup routing is tested without sending an OS signal: cleanup interruption escapes as KeyboardInterrupt instead of returning ordinary-error status 4; no numeric signal-termination status is claimed by that test.

The full suite uses an existing materialized development environment, without fetching or installing dependencies.
Set OMP_STRATA_OMP_BINARY, OMP_STRATA_STRATA_SRC, OMP_STRATA_STRATA_PYTHON and OMP_STRATA_PROFILE to that
environment's executable, runtime source, Python and profile paths, respectively:

PYTHONDONTWRITEBYTECODE=1 python3 -m unittest discover -s tests -t .

Repository and documentation checks, including every checked-in profile, route and manifest:

python3 scripts/check_public_hygiene.py
python3 scripts/render_compatibility.py --check
python3 scripts/documented_route.py --check
python3 -m unittest \
  tests.unit.test_site.SiteTests.test_readme_header_and_pin_badges_name_the_current_candidate \
  tests.unit.test_render_compatibility.TroubleshootingDriftTests.test_every_quoted_symptom_exists_in_its_referenced_source \
  tests.unit.test_documented_route -v
for profile in profiles/*.json routes/*.json; do
  python3 scripts/omp_strata.py validate --profile "$profile" || exit
done
for manifest in releases/*/manifest.json; do
  python3 scripts/verify_release.py --manifest "$manifest" || exit
done
git diff --exit-code ccad158d6b7204f91e221ac48d6d4c2a2933da58 -- releases profiles routes

- Exercise counted cleanup, bounded replacement passes and preserved uncertain evidence.
- Keep native no-signal and wrapper-custody assertions while requiring final completion evidence.
- Cross job failures, current identities and evidence availability without native host effects.
- Replace interim manual-cleanup expectations while preserving custody and no-signal safeguards.
…tion

- Preserve available cleanup through evidence and job failures, with fresh post-job and final verdicts.
- Order represented children before ancestors and bound full-identity cleanup to two passes.
- Normalize job-helper failures and keep completion proof separate from port admission.
- Describe bounded current-verdict cleanup, wrapper fencing and uncertainty refusals.
- State ordering, native signaling, port and controller-adapter limits.
Keep all 630 reader-outcome cells and every cannot-say/manual refusal assertion.
Use an explicit recovery assertion only when an irrelevant launcher leaves a counted runtime orphan.
Update only the counted-survivor detail expected from shared lifecycle admission.
Keep both lock modes, the exact public refusal, one private error file and all cannot-say/census controls.
Compare forty complete-selection worlds with the pinned base ordering rule.
Cover native lookup races, absent-run GPU and port results, unique refusals, failed-start context and platform-specific executable identity.
Recover the base server and wrapper subtree order from the verdict ancestry walk while retaining child precedence.
Recheck ProcessLookupError, preserve absent no-op results, deduplicate refusals and report start failure before cleanup failure.
Correct source ownership comments without changing the verdict or record parser.
State subtree ordering, interrupted-stop recovery and unique start/cleanup failures.
Distinguish absent-record no-op results from attempted cleanup, including port waits and GPU fields.
Describe accounted lookup-race handling without widening the native signaling guarantee.
Pin all four start-error/interrupt and cleanup-error/interrupt combinations by exact exception type and text.
Exercise actual CLI routing without an OS signal and distinguish first-seen diagnostics from sorted uniqueness.
Catch ordinary cleanup exceptions only; preserve KeyboardInterrupt propagation through start and CLI.
Keep combined start-first diagnostics when cleanup raises an error.
- Limit interrupted-stop persistence to a fenced writable record before final publication; retain the published result during the port wait.
- Distinguish cleanup errors from interruption and preserve the original start exception after successful cleanup.
- Pin runtime-alias, live-foreign-parent, owned-parent, orphan, system-ancestor and runtime-subtree ownership boundaries.
- Require both individually verified identities with reciprocal raw parent numbers to receive cleanup attempts without publishing completion.
- Leave aliased runtime processes and live outsiders' unrecorded subtrees untouched, visible to the final census and named for manual cleanup.
- Preserve recorded cleanup while requiring a comparable earlier parent creation stamp for individually verified fallback edges.
- Account explicitly for the signal-eligibility census without allowing another status or admission classifier.
- Bound the existing 3956-cell model assertion to its recorded, descendant and orphan worlds; its cells and expectations are unchanged.
- Describe eligible unrecorded leftovers, manual refusal for aliases and live outsiders' subtrees, and unchanged status/admission.
- State the shared-runtime residual and the earlier-counter requirement for fallback ordering edges.
- Keep the real start admission refusal assertion while substituting only the native lock in the host-free Windows ownership cell.
- Fix the revealed msvcrt fixture error; retain all twelve parent/platform cells.
- Cover both platforms and absent/readable run records with an unidentified outside parent and a runtime child subtree.
- Keep the same absent-parent worlds as successful cleanup controls; pin live-set retention, manual refusal and proof revocation.
- Withhold unrecorded runtime candidates when the current outside parent number is enumerated, whether identified or unidentified.
- Preserve the accounted reader's cleared-parent and platform-system exceptions.
- Say that an enumerated outside parent withholds runtime cleanup whether identified or not.
- Disclose subreaper adoption and Windows unidentified parent-PID reuse as manual-cleanup limits.
- Cover runtime-only boundaries and changing parent evidence without native effects.
- Require observed absence or replacement across all three completion paths; 49 red assertions at ef389f0.
- Remove executable-location eligibility and its cross-census ownership inference.
- Retain every unrecorded identity observed by this stop and require reader-confirmed departure before any completion.
- Keep recorded and verified-descendant ordering, two passes and the empty final census requirement.
- Replace runtime-only signal expectations with named refusal without changing status or admission.
- Retain state/evidence product cardinalities and compare recorded signal order with the base in every state world.
- Keep identity replacement and two-pass controls on verified descendants; preserve runtime-only counterworlds.
- Runtime-only processes are named and left for manual cleanup, as on the base, but cannot hide behind success.
- Require observed departure on all completion paths and document shared-runtime interference.
- Defer any wider signal authority to ownership established at launch.
- Pin exactly 320 state worlds where reviewed child precedence overrides the base recorded order.
- Compare recorded and verified-descendant signals to the frozen reviewed order in every admitted state world.
- Keep same-counter image changes as unknown identities and retain the P8 runtime-only survivor for manual cleanup.
- Add exact promotion and unavailable-departure diagnostics; one deleted-image identity is named or attempted once.
- Pin nested recorded-wrapper labels and active return after a job-close callback removes the run record.
- Red receipt has four intended failures and one corrected fixture accounting mismatch; no source change.
- Exclude attempted identities from the final left set, including later verified descendants.
- Separate a final live observation from an unproved historical departure in operator advice.
- Reuse the process reader executable equivalence for attempted and remembered identity keys.
- Keep all 45 departure cells and completion assertions; twelve uncertain-history cells require cautious identity advice.
- Current final-live cells keep the manual-cleanup text.
- State current-role selection and stop-local uncertainty without promising persistent verdict memory; link #102.
- Separate current-live manual cleanup from cautious unproved-departure advice.
- Describe the tested job-close record-loss return, not active cleanup with a record absent throughout.
- Keep all 300 job/identity/availability cells and proof assertions.
- Seven final-unavailable location-only cells require historical observation advice, not a claim of current liveness.
- Cover final-only promotion and attempted-descendant demotion on both platform flags, with exact text and retained refusal/proof assertions.
- Red at 71b93e7: two promotion assertion failures, zero errors; both reverse controls pass.
- Partition final-live survivors by current role and attempted identity; historical memory is consulted only outside the final live set.
- Keep unattempted location-only manual advice distinct from generic survivors and uncertain departures.
- Keep one identity and one attempt across deleted-image observations; show the final image spelling for the surviving unrecorded process.
- Windows reports the final case spelling once; POSIX retains the earlier distinct-case identity only as uncertain history.
…ntities

- Describe final-only promotion as a survivor under its descendant role, eligible for a repeated stop.
- Reserve earlier-observation memory for identities absent from the final live set.
- Do not promise an attempt for a role first established by the final verdict after both passes are over.
- Append independent coarse-stamp reissue worlds with and without a token; both reproduce stopped while the replacement is alive.
- Token red receipt shows tree_verified_empty published; token fixture explicitly enters Windows lifecycle custody.
- Drop earlier location-only memory at the attempt, not by membership at completion.
- Later observations of an indistinguishable key are remembered anew and require proved departure.
- Append all three-verdict observation sequences with applicable departure outcomes across absent, ordinary and proof-bearing returns.
- Pin 128 reachable worlds and 34 explicitly unreachable cells; use a plain event-order oracle independent of stop memory sets.
- Append repeated stop from the exact first-call state, supplied-job absent-record authority, and final-port interrupt publication tests.
- All three ties passed against the predecessor; the token interrupt fixture explicitly uses Windows lifecycle custody.
- An attempt supersedes earlier memory; an observation after the attempt is remembered anew.
- Final departure checks cannot be bypassed by membership in the attempted set.
- Cover all four job observations and all three ordinary observations; pin 236 reachable worlds and 34 impossible absent-record cells.
- Keep identity-once assertions on manual and historical lines; survivor expectations remain role-by-role.
- The independent reader oracle has not yet been opened.
- Restrict identity-once wording to manual and historical refusal lines; final survivors retain every recorded role.
@alphastorm
alphastorm merged commit 75d01fa into main Nov 15, 2026
11 checks passed
@alphastorm
alphastorm deleted the feat/lifecycle-stop-census branch November 15, 2026 07:45
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant