Skip to content

Latest commit

 

History

History
3092 lines (2898 loc) · 188 KB

2026-10-e.md

File metadata and controls

3092 lines (2898 loc) · 188 KB

October 2026 updates — continuation e

U-20261027-16 · 2026-10-27 · Reject changed destination output before import acceptance · #done #agent #handoff #integrity #verification

  • Problem / behavior: A real owned HTTP import could accept published after its independently verified destination file was modified, removed, or joined by an unexpected file. Reproduce at both the publication return and final source-response boundaries:6failed/2control cases passed. Reread the exact durable publication under the same delivery claim, then independently inspect its current generation layout/hashes after the final source reply and before accepting the receipt. Changed output requires review; user edits and the original publication remain. No publication replay.
  • Canonical proof: Applied source77cases pass202.06s, including8new timing/integrity cases; independent destination-process/GUI lifetime24pass26.65s. Actual fresh installed HTTP-worker execution8pass19.63s with unchanged copied tests/helpers and every application module origin checked before/after each case against the installed target. No candidate injection/source overlay. Metadata/document/count/structure/development-parity50pass15.13s. All runs0skip/0error/0warning.
  • Quality: Whole Ruff/three-platform typing/Bandit/Radon pass. Whole Pylint raw30 in613.58s; original58 ordinary findings6146->6141,0added;3190declaration diagnostics/822canonical declarations retained,3unchanged-pair similarity variants/0unresolved. Only transfer_import.py changed among application sources; its exact import AST is unchanged, so no added cyclic edge. Runtime746lines; changed source342lines/max function33/parameters6/CC10; test73lines/max function40/parameters4/CC9. Source/document hashes remained fixed throughout the corresponding checks. Strict bilingual Sphinx passes187.63s; measured architecture counts and three READMEs/reference docs are synchronized.
  • Artifacts / install comparison: Source/wheel/sdist/fresh isolated install1,405payload files match, including closed wheel payload, sdist pyproject/README and installed README metadata. Record actual source/shared versions, requirements, artifact hashes and absent owned target before offline no-dependency installation. Both isolated versions are0.0.228 but the new source differs in transfer_import.py; all1,405prior installed payloads were independently compared before install. Installed facade remains Qt-free and optional-SQLite-safe;4actual localhost resources and pip check pass. No shared environment/dependency/version/schema/browser or production-service change.
  • Scope / evidence: stage119 canonical/peer-GUI/installed integrity, whole static/Pylint, source-budgets-import-proof01, strict docs and exact artifact/before-install records; stage118 preserved actual RED/private candidate evidence. This closes the late-import implementation gap, not the corrected source's complete configured coverage or cross-host Tasks2-5 formal delivery. Prior source52cfa38b's16,511pass/80skip/88.01% and historical409/storage/symlink causes are retained. All40original P0-P9 items and deferred native/browser/device/24hour acceptance remain in Progress.md.

U-20261028-01 · 2026-10-28 · Verify corrected import source and audit finite cross-host delivery · #done #agent #handoff #verification

  • Fixed-source result: Actual source26c1626e,3,359fixed code/test/config/document inputs: 16,519passed/80skipped/0failed/0errors in4056.90s; coverage88.01% exceeds81%. Actual original native session85257 and pytest/report/JSON controller all retire successfully. All16,599exact case signatures match; all80skip signatures match the prior inventory, with no extra skip, warning, traceback, unraisable/atexit error, input drift or added canonical file. All717transfer cases pass, including8new late-publication integrity cases; every required presence/context/reader case and all4previously failing names actually execute and pass.
  • Finite handoff audit: Map all22Tasks2-5 plan steps to their hashed implementation/test sources and exact current module results. Source/peer/import/evidence/GUI historical REDs remain; they do not claim every parameter failed historically. Exact16management/3peer/portable fields match the spec;209added import edges add no cycle against original58, including old components. 21steps are recorded; literal Windows file and directory symlink creation still returnsWinError1314, so Task2's variant stays unchecked. Neither junction coverage nor actual localhost HTTP runtimes claim physical-host acceptance.
  • Quality / artifacts: Revalidate stage119's fixed1,405payload against current source and its verified wheel/sdist/isolated install. Whole Ruff/three-platform typing/Bandit/Radon, normalized full Pylint6141ordinary findings/0added and strict bilingual Sphinx187.63s apply to the unchanged application source. No new installation/dependency/version/schema change. This record changes only Progress/plan/monthly index;61scoped record/count/budget cases pass.
  • Scope / evidence: stage120 original full logs/JUnit/coverage, completed-full-suite-audit01, cross-host-plan-behavior-audit01 and before/after record preserve the exact proof. The live DAG diagnostic captures no refusal; historical409cause, storage/bootstrap/shared-pytest concerns are not claimed fixed. Preserve the user's2026-10-28 model-unconfigured confirmation before Agent-only mirroring. All40original items and deferred native/browser/device/24hour acceptance remain in Progress.md; no production/shared environment/browser or desktop input is changed.

U-20261028-02 · 2026-10-28 · Retain Linux connected peer evidence without desktop authority · #snapshot #agent #presence #linux #verification

  • Internal behavior: Add presence_peer_linux as a query-only primitive. Retain the actual original connector with SO_PEERPIDFD, checking account, birth and user/PID namespaces while that process object remains live. Use a noninheritable owned descriptor; no PID-open fallback, process signalling, desktop observation or input. Unknown ABI/kernel/metadata refuses evidence.
  • Race / failure proof: Canonical missing-module RED precedes promotion. A further barrier case reproduces close completing during an unfinished identity query:1failed/5passed/15native skips. Serialize query/close with an owned lock; the corrected case passes. Preserve both pre-fix source/artifacts and final records. Actual owned Linux IPC includes exit-mid-query, a descendant retaining a usable socket after the original connector exits, stale credentials, namespace mismatch, handle ownership, unsupported option and descriptor cleanup.
  • Verification: Final Linux component21tests pass on6.18.33.2-microsoft-standard-WSL2; the stdlib-only harness loads exact canonical module/error/test bytes with the package facade intentionally bypassed. This proves the component, not full Linux application integration. Related Windows regression148pass/15explicit Linux skips; actual fresh installed Windows execution6pass/15native skips with all application origins checked before/after every case. No source overlay or candidate replacement in installed execution. Older unsupported kernels have an explicit native-test capability check rather than a claim of supported desktop activity.
  • Quality / artifacts: Whole Ruff/three-platform typing/Bandit/Radon pass; direct module typing passes on all3platforms. Whole Pylint retains6141ordinary findings,0added and0unresolved similarity variants; original58 graph adds no cyclic edge or expanded component. Source204lines, max function24/parameters4/CC7; tests366lines/max function46/parameters3/CC7. Strict bilingual Sphinx passes220.42s. README3, Sphinx2, references and measured map are synchronized. Source/wheel/sdist/fresh offline no-dependency install1,406payloads match. Actual prior/new versions and payload/hash/dependency differences are recorded before each isolated install; the same version0.0.228 has a new module, then a one-file race fix. Qt-free optional-SQLite-safe imports,4localhost resources and pip check pass. Shared version0.0.178/dependencies are unchanged.
  • Scope / evidence: stage121 canonical RED/race RED-GREEN, canonical-linux04, installed-peer03, related-current02, applied-peer-details02, static/doc/Pylint02 and both installation comparisons. Supported platform flags, public exports/commands and input authority are unchanged; the current socket writer, login/seat/lock and trusted physical activity remain separate requirements in Progress.md. All40original items, historical causes and deferred acceptance remain open. Prior source26c1626e's complete16,519pass/80skip/88.01% does not cover this newly added component.

U-20261028-03 · 2026-10-28 · Verify Linux peer evidence in the complete fixed-source suite · #snapshot #agent #presence #linux #verification

  • Source 7e0cd292 passes the complete configured suite with 16,525 passed, 95 skipped, no failures or errors, and seven successful unittest subtests. The 16,620 testcase elements and suite counter 16,627 differ because successful subtests have no separate testcase elements. Coverage is 87.91%, above the 81% floor. The original native session 47463 exits successfully after pytest, coverage report, and coverage JSON all finish.
  • All 3,361 frozen inputs remain unchanged. Exact case and skip inventories match, with no additional skip or unexpected warning, traceback, unraisable, resource, or atexit error. All 717 handoff cases pass. Required presence, context, reader, and import-integrity cases execute and pass. The Linux peer module contributes six Windows cases and 15 explicit native Linux skips. Actual Linux component coverage remains the separate stage121 21-case IPC proof.
  • Current source still matches all 1,406 previously verified wheel, sdist, and isolated-install payload files. Stage121 whole quality checks and strict bilingual documentation apply to the unchanged application. This checkpoint adds records only and installs no packages.
  • Stage122 retains the original logs, JUnit, coverage, and completed-full-suite-audit01. Stage124 verifies those hashes and synchronizes the newer pending receiver requirements from the main Agent-only record before mirroring. Per-message sender identity, socket protection, bounded cancellation, and receive-close ownership remain pending in Progress.md. The private stage123 receiver is unpromoted and is not covered by this full-run result.
  • Historical HTTP409 and storage concerns remain unresolved. The successful DAG diagnostic does not prove the historical refusal's cause. All 40 original items and deferred desktop, actual-browser, device, and 24-hour acceptance remain open. No deployment, merge, shared environment replacement, model download, browser operation, or desktop input occurs.

U-20261028-04 · 2026-10-28 · Keep completed Linux peer regression out of pending work · #decision #agent #verification

  • Remove the completed Linux peer full-suite substep from Progress.md and update the current skip inventory to 95. U-20261028-03 already records the accepted stage122 result.
  • Keep final fixed-source regression after future platform and recovery changes pending. All 40 major items and deferred acceptance remain open. Application payload is unchanged.
  • Evidence is stage124/reconciled-full-pending01.json and the stage122 full audit.

U-20261028-05 · 2026-10-28 · Own Linux packet lifetime and preserve uncertain cleanup · #snapshot #agent #presence #linux #verification

  • Internal LinuxListener and LinuxChannel factories bind one owned Unix sequenced-packet socket to its retained original peer. Each finite JSON packet validates kernel credentials and pidfd identity. Reject inherited writers, extra or negative descriptors, malformed or truncated controls, stale peers and ambiguous payloads. Retire received descriptors before delivery. Stream peer evidence remains available; there is no stream fallback for the packet channel.
  • One ownership state controls admission, cancellation, absolute deadlines and close. Active metadata work keeps its borrowed resources; bounded close reports uncertainty and late results are discarded. Unknown paths remain untouched. Created-but-unverified paths and all directory and socket retirement errors stay typed as unconfirmed through successful remaining cleanup. Six pre-owner socket close paths now share the same policy. Never retry a descriptor number.
  • Verification preserves first-candidate and corrected REDs. Root reproduces directory identity capture and directory-close failures, then the pre-owner socket classification failure. All four root probes pass after correction, with descriptor inventories restored. Owner canonical REDs cover six socket transfer paths and unavailable filesystem capabilities. Final exact-byte canonical Linux component run passes 67 cases; its package facade is explicitly bypassed. Related Windows regression passes 153, skips 59 named native cases, and passes 16 subtests. Fresh installed execution passes 11, skips the same 59 and passes 16 subtests, with 140 before and after origin observations. Initial QA relative-import collection failure is retained; correcting test-package scaffolding changes no canonical test or application bytes.
  • Whole Ruff, three-platform typing, Bandit and Radon pass. Whole Pylint retains 6,141 ordinary findings, adds none, and leaves no unresolved similarity variant. Original58 import graph verifies 1,345 to 1,397 modules and 220 added edges without a new cycle or merged old component. All 12 owned files meet size, function, parameter and complexity budgets. New nesting is at most four; the one existing depth-five peer method is AST-identical to its parent. Cognitive complexity is reviewed, not separately tool-measured. Strict bilingual Sphinx passes 291.07s.
  • Source, wheel, sdist and fresh offline isolated install match all 1,409 payloads. Record actual prior and new versions, dependencies, file differences and artifact hashes before installation. Version 0.0.228 adds three modules and changes peer evidence; shared 0.0.178 remains unchanged. Qt-free imports, optional-SQLite refusal, four localhost resources and pip check pass. No new dependency, public export, command, platform flag, schema, deployment or shared environment change.
  • Evidence is stage124 synthesis and review trail, stage125 root RED/GREEN, canonical-linux01, related-current audit, installed-channel02, graph and budget details, whole quality reports, document build and both pre-install comparisons. The previous source7e0cd292 full result of 16,525 passed, 95 skipped and 87.91% coverage does not cover this new transport. Progress.md retains its fixed-source full regression, trusted helper launch and endpoint transfer, challenge and lease integration, physical activity sources, all 40 major items and deferred acceptance.

U-20261028-06 · 2026-10-28 · Verify Linux transport in the corrected full suite · #snapshot #agent #presence #linux #verification

  • Frozen source e854dc53 passes the configured Windows full suite with 16,538 passed, 131 skipped, no failures or errors, and 16 successful unittest subtests. The JUnit suite counter is 16,685 for 16,669 testcase elements. Coverage is 87.52%, above the 81% floor. Original native session 48535 exits 0 after pytest, coverage report, and coverage JSON.
  • All 3,371 frozen inputs remained unchanged through the full run. The 1,409 package source payload hashes remain unchanged after this documentation edit. Exact case inventory matches; 8 former skip signatures now pass, with no new skips. Stage125's source, wheel, sdist, and isolated install matched these payloads. No new install or source change is part of this record. Required modules, critical functions, 717 transfer cases, and prior failed cases pass. No unexpected warning, traceback, unraisable, resource, or atexit marker appears. The same-target DAG diagnostic records no new refusal; the historical HTTP409 cause remains unresolved.
  • The new Linux transport contributes 70 Windows full-suite cases with 11 passed and 59 explicit native skips. Separate exact-byte Linux component proof passes 67 cases with its package facade intentionally bypassed. This is not a whole Linux application, actual desktop, browser, or device acceptance result.
  • Stage127's isolated autoreaping probe shows SIGCHLD auto-reaping can leave Popen.returncode unset after the child PID is no longer reserved. Its separate original-group probe exits 0: the leader is reaped, a retained pidfd addresses the original group, the member reports CLD_KILLED/SIGKILL, and both fixtures are reaped. Atomic spawn binding, generic group or escaped-descendant retirement, and product integration remain unproven. Keep the new POSIX-RETIREMENT-01 pending paragraph from main Progress.md.
  • Evidence is stage126/completed-full-suite-audit02.json, the original raw log, JUnit, coverage JSON and terminal controller record, stage125 package comparison, and stage127 probes. The exact eight skip-to-pass changes were independently reviewed in skip-transition-review01.json. symlink-capability-probe01.json confirms literal file and directory links; the reason earlier privilege failures no longer occur is unknown. Remove the obsolete permission-only pending lines. Cross-host Task2 scope still requires its own reconciliation. The rejected initial audit is preserved. Remove only this source's completed Linux transport full-run substep. The final fixed-source regression after future changes, all 40 major items, native acceptance deferrals, and historical storage and HTTP409 investigations remain open. No whole-goal claim is made.

U-20261028-07 · 2026-10-28 · Verify literal source links and missing export chunks · #done #agent #transfer #verification

  • Added five regression cases in test_agent_transfer_source_links.py. Literal Windows file symlinks are confirmed with lstat and reparse tag 0xA000000C. Replacements inside or outside the source root reject export creation without activating a grant or changing foreign bytes. After commit, outside-root replacement refuses access. Inside-root replacement returns only the approved historical blob, even when the redirected file has different contents. The guard observes no foreign descriptor open through the transfer source path.
  • Deleting the selected account's actual chunk makes peer retrieval fail. The same digest remains readable in another account, the original source bytes remain unchanged, and the committed manifest remains historical metadata. This distinguishes missing bytes from existing corrupt-byte and off-manifest tests.
  • Related source, registered-peer, transport and structure checks pass 232 cases without skips. After splitting the new test by create versus committed-export behavior, all five final cases pass again without skips. Ruff passes and maximum Radon complexity is 8. Application payloads remain identical to the prior 1,409-file package comparison. No installation occurred.
  • Task2's compound source verification checkbox is complete against its existing coverage map and these new cases. Evidence is stage130/task2-existing-coverage01.json, verification01.json, final-links01.json and the actual test assertions. Earlier stage129 probe02's overbroad postcommit refusal assumption is preserved; the immutable snapshot contract governs the tests.
  • Removed only the corresponding source-link verification substeps from Progress.md. Broader cross-host delivery and final fixed-source regression remain under Progress.md P8 and P0–P9. This test-only checkpoint does not claim a new full-suite run, real remote-host acceptance, literal directory-symlink execution, or completion of the forty-item program.

U-20261028-08 · 2026-10-28 · Verify atomic Linux spawn attributes and private pipes · #snapshot #agent #presence #linux #verification

  • Stage131's actual null-attribute pidfd_spawn probe exits 0. Four child cases cover early exit and pidfd-only cancellation under default and ignored SIGCHLD. Thirty-two missing-executable attempts return ENOENT with unchanged descriptor inventories and no supervisor children. Default wait status identifies the exit cause; ignored disposition records unavailable status.
  • Stage132 compares installed glibc-2.43-9.fc44 with the same-version, same-source glibc-devel RPM. The downloaded artifact passes RPM signature verification; installed libc passes rpm -V. Only selected headers are extracted beneath an owned temporary directory. No package is installed, no shared interpreter changes, and no application code changes.
  • The exact-header attributes/actions prototype exits 0 on Linux x86_64, Python 3.14.8 and glibc 2.43. Both SIGCHLD modes establish a fresh session and private stdin/stdout pipes. Child PID, session, process group and retained pidfd metadata agree before the gated echo. Native calls return 0, canaries remain intact, descriptor inventories match, and cleanup records no errors. Default status is exit 37; ignored disposition reports ECHILD separately from observed exit readiness.
  • Independent execution reviews accepted only the exact prototype hashes. Evidence is stage131/ atomic-null-execution01.json and stage132/attrs-execution01.json, matching-package records, extracted headers and attrs-execution-review01.json. These are isolated feasibility results, not production binding, cancellation-safe ownership or descendant-retirement acceptance.
  • Read-only startup inspection identifies eager X11 Display construction in the real facade import chain and Windows source/pipe defaults in presence_worker. Actual Linux metadata reports the product and Xlib/PIL/cv2/numpy absent, while inherited DISPLAY and WAYLAND_DISPLAY are present. No product import or display connection was attempted. Progress.md now names the concrete real-package startup prerequisites; earlier namespace-bypassed component results remain separate. Original forty-item scope, POSIX retirement repair and native acceptance remain in Progress.md.

U-20261028-09 · 2026-10-28 · Defer X11 resources until explicit desktop use · #snapshot #agent #linux #startup #verification

  • Plain package import no longer opens an X11 display, resolves the server keymap, starts the RECORD listener or probes a uinput device. Operations acquire their resources on demand. The listener owns a separate connection and rejects recording admission during retirement.
  • Public key-table access still returns an ordinary mutable dictionary. Exact-source comparison preserves all 183 legacy constant names and 181 public key names. Legacy wildcard imports and discovery remain available. Windows, BSD and Wayland dispatch retain their existing policy.
  • Actual installed-wheel verification on isolated Linux passes with default and uinput settings. Before import, the probe removes desktop session variables and refuses socket connections, thread starts and input-device opens. Both cases import the facade, presence_worker and presence_channel_linux from the real installed package with zero refused attempts. The probe does not run the worker, acquire physical presence or prove helper retirement.
  • Before installation, all 1,409 application payload files match the wheel and current source. Installation changes only the owned Linux virtual environment. Dependency requirements are unchanged and pip check passes. Final wheel SHA256 is 55ecf56e628e589a4f7c90c32018d38bf60e9d8bf2d6d2bd3aed74e61c8bd3c5.
  • Canonical targeted verification passes 273 tests with ten cases skipped on Windows. The separate actual Linux probe executes both settings. Independent review found and resolved wildcard-import compatibility and recording admission during cleanup. Final source restores public docstrings; Linux, Windows and macOS type checks and Ruff pass.
  • Evidence is stage134/symbol-preservation03.json, polish-checks01.json, final-installed-import02.json and the exact install comparison records. Full Pylint comparison records 10,212 raw diagnostics versus 10,219 at the verified baseline. Nine import-message variants and six similarity reports in unchanged files are reconciled; no new finding remains unexplained. Existing warnings remain. Evidence is stage134/pylint-final-audit03.json. Stage133 retains the pre-fix real-package X11 attempt and dependency comparisons. Broader fixed-source regression, worker execution and native acceptance remain in Progress.md.

U-20261029-01 · 2026-10-29 · Verify native owner fixtures and retain full-suite failures · #snapshot #agent #linux #verification

  • Fixed-source regression at 06dad944 completes with 16,562 passed, 133 skipped, 16 subtests passed and two failures. Coverage is 87.84456182732697 percent. All 3,373 frozen input hashes match after the run, with no added inputs. Coverage report and JSON generation succeed. The full test gate remains failed.
  • Both failures are the replacement variants of test_webrtc_file_registry's cyclic binding collection subprocess test. Its ten-second stdout wait times out. Subsequent instrumented children record their last marker before package import and dump stacks in import loading and NumPy initialization before reaching GC. This localizes the diagnostic runs; it does not prove the historical timeout was a registry deadlock or identify a fix. No deadline or skip policy was relaxed.
  • The real installed Linux presence_worker executes from the compared wheel. All 1,409 installed payload hashes match. Bootstrap returns the sanitized unsupported error and exits zero; owner EOF exits zero without output. No initializer or source factory is replaced. This proves startup and refusal, not physical presence or descendant retirement.
  • An isolated C toolchain is assembled from compared, signature-verified packages and verified existing runtime files. No system package or shared interpreter is changed. Actual clone3 probes distinguish retained pidfds from failed-call scratch. Failed cgroup admission leaves a stale positive scratch value; descriptor reuse experiments demonstrate why that value must never be closed as an owned fd.
  • The staged per-record owner engine passes 22 direct-child acceptance cases. They cover failed allocation and thread creation, autoreap status, exec errors, closed stdin, revoke before handle adoption, concurrent joins and reused descriptors. Independent review resolves the failed-create report lock race and strengthens late-result and lease cancellation tests. Exact source hashes match compiler inputs. Deliberately disabling ordinary or lease revocation makes the corresponding test fail while emergency cleanup remains intact. These are scoped fixture results.
  • No production tree-retirement receipt is emitted. The C service is not packaged, deployed or connected to application callers. The original forty-item scope and deferred native, device and twenty-four-hour acceptance remain in Progress.md.
  • Evidence is stage135/full-evidence-ownership-live01.json, the full pytest and coverage artifacts, registry-timeout-diagnostic01.json, installed-worker-refusal02.json, native-core-checkpoint03-audit.json and both cancellation mutation audits. Native checkpoint03 matches execution05; execution06 records lease mutation rejection.

U-20261029-02 · 2026-10-29 · Verify lazy exports and refine source and documentation gates · #snapshot #agent #startup #verification

  • Root and remote-desktop facades resolve original source objects on first access. Concrete type declarations generate the runtime maps and CI checks their exact output. Optional groups retain ImportError-to-None outcomes; other exceptions remain retryable. Cached namespace and optional outcomes are not refreshed by facade reload.
  • The first fixed-input full run reports 16,583 passed, 3 failed, 133 skipped and 16 subtests passed. Coverage is 87.43695056924629 percent. All 3,386 input hashes match at completion with no added inputs. The three failures are stale architecture line counts, an unlisted generated flat table and a codec-panel size overrun. This is pre-refinement evidence, not the final revised-source result.
  • After that terminal audit, five guarded source refinements remove 1,490 redundant aliases, tighten loader AST validation, simplify codec status publication and remove two unused test suppressions. The codec panel shrinks to 2,487 lines beneath its unchanged 2,488 ceiling. The generated lookup is recorded under the existing flat-data rule; no lint configuration, test deadline or skip policy is relaxed.
  • Regenerated architecture figures and updated compatibility descriptions pass the existing documentation and size guards. The combined targeted run passes 63 tests, including optional-codec GUI behavior, lazy exports and the original registry tests. Actual-package mypy reports zero failing modules on win32, linux and darwin. The strict representative consumer also passes with no implicit re-exports.
  • Revised-source identity checks confirm 1,442 root and 57 remote required objects, all 1,445 wildcard names and the original owner/order/group contract. Two concurrency scenarios and four required installed-optional scenarios pass without missing-dependency skips or source drift. Explicit assignments win a concurrent lazy-publication race.
  • Main Progress synchronization preserves all unrelated bytes, except the specifically recorded generated-map addition to the existing flat-data paragraph. Its revised non-Agent hash is 5aea4d9de270cffbf4b45bd41b0e4d68e0ad1b9df1ce38c95890b3650449f800.
  • Evidence: stage136/full-evidence-ownership-live01.json, its pytest and coverage files, post-freeze-applied01.json, post-freeze-targeted01.json, typing-contract03.txt, all-export-identities02.json, concurrency-results02.json, installed-optional-results02.json and main-progress-mirror01.json. Remaining delivery and verification: Progress.md groups3/8.

U-20261029-03 · 2026-10-29 · Verify lazy facade delivery against the complete suite · #done #agent #startup #verification

  • The revised fixed-source suite passes 16,586 tests and 16 subtests, with 133 skips. coverage run -m pytest finishes successfully. Coverage is 87.43154633232454 percent; both coverage report commands exit zero. All 3,386 source, test, configuration and documentation hashes match the starting snapshot, with no added inputs.
  • Skip reasons retain platform restrictions, optional dependency gaps and documented exclusions. They do not prove native desktop, device or real-browser acceptance. The original registry tests pass under their unchanged ten-second deadline.
  • Ruff, Bandit and Radon exit zero. Pylint exits 30 with 10,174 raw findings. The 36 normalized additions were reviewed against relocation and unchanged-source evidence. The generated-table size and single-callable Protocol findings stay visible. This is an accepted quality-difference review, not a claim that Pylint passes.
  • The wheel matches 1,419 payload source hashes. Comparison before isolated installation records unchanged requirements, ten added modules, five changed files and no removals. Installation in the owned Linux environment matches all 1,419 hashes and passes pip check. Installed default and uinput-selected imports pass without audited external contact or thread startup. Shared environments remain unchanged.
  • The export checker rejects seven contract mutations and four invalid expression bodies without importing the application. Three-platform typing, object identity, concurrent publication and optional-group checks are recorded in U-20261029-02.
  • Evidence is under .worktrees/agent-tools/stage136: full-refined-live01.json, full-refined-pytest01.txt, full-refined-coverage01.json, refined-quality-review.md, installed-candidate-comparison01.json, installed-import01.json, design-a/source-control-results02.json and checker-expression-control02.json. Wheel SHA256 is a667246a748e309d29e079d6d6bf5f08a778387d83068bde65b6de00c8dd1a56. Remaining program scope and deferred acceptance are in Progress.md groups 3 and 8.

U-20261029-04 · 2026-10-29 · Review isolated native ownership without enabling production · #snapshot #agent #linux #verification

  • The isolated stage137 owner checkpoint passed an independent source review. All seven normalized C/header hashes match both final execution manifests. All 18 saved artifact hashes match. The review ran no implementation or tests.
  • The recorded direct lifecycle run exits zero and emits 22 distinct cases. The local contract run passes 96 assertions. Both production objects compile with strict warnings. These checks do not execute the protected profile.
  • The public submit path remains unconditionally unavailable. The contained acceptance command exits 77 with an explicit unavailable result. Real protected authority, authentication, guardian and caller integration remain incomplete in Progress.md group 3. No service was provisioned.
  • Local evidence is in .worktrees/agent-tools/stage137/ under the feature worktree. It includes implementation-contract-review01.md, root-final-input-audit01.json, and implementation/handoff-final/ with execution07.json, contracts06.json and artifact-hashes.json. These ignored artifacts are local evidence, not distributed package contents.

U-20261029-05 · 2026-10-29 · Implement the isolated native service issuer with peer and lease evidence · #snapshot #agent #linux #verification

  • Three independent bootstrap/issuer designs were scored and one selected: guardian-granted epoch over an inherited socketpair, per-packet sender authentication, one single-owner issuer, fixed 32-lease ledger mirroring the core arrays. Selection and grafts are in stage138/cross-judge.md.
  • native_service.c and two companions now implement bootstrap, connection retention, OPEN_TOP / OPEN_CHILD / START / CLOSE, lease issuance and closure, expiry, connector death, maintenance, owner scan and drain. The core gained the sole production lease registration and a by-value parent payload snapshot.
  • The isolated acceptance passes 492 checks on real Unix connections and processes, stable across four runs. Removing the per-packet sender check, the core revocation on close, or lease registration each makes it fail. The stage137 contracts (96) and lifecycle suite still pass on the changed core; the contained suite still exits 77.
  • Two kernel facts changed the protocol: a frame queued before the receiver enables SO_PASSCRED/SO_PASSPIDFD arrives with pid 0 and no SCM_PIDFD, so the service now requests the grant only after enabling them; and a socketpair's peer credentials name its creator, so the guardian must create the pair.
  • This is peer/lease evidence only. The production gate stays closed, the positive bootstrap is compiled but unexecuted for lack of a delegated cgroup2 epoch, and no protected tree ran. Remaining work is in Progress.md group 3.
  • Local evidence: .worktrees/agent-tools/stage138/implementation/ with implementation-report.md, run_service_checks.py and service-checks*.json. These ignored artifacts are local evidence, not distributed package contents.

U-20261029-06 · 2026-10-29 · Answer the independent review of the native service issuer · #snapshot #agent #linux #verification

  • An independent review of the stage138 issuer found no blocker, five major and nine minor findings. Its five own mutations (membership, parent eligibility, capability, connection binding, truncated control data) all survived the 492-check suite. The findings are in stage138/review.md.
  • Nested admission is now exercised with a real helper process under a parent whose payload is the test's own cgroup, published by hand below the closed gate. START rechecks parent eligibility and membership on every call.
  • Payload children get /dev/null on fds 1 and 2, default signal dispositions, an empty mask, nothing above fd 3, and for protected payloads a dropped bounding and ambient set. The guardian channel is close-on-exec.
  • Top-level clients are bound to manifest namespaces through pidfd ioctls. A non-root process gets EPERM reading another user's namespaces, so the check fails closed and needs a provisioning decision, recorded in Progress.md.
  • Other changes: replay keys are bound to one connection; identity is the pidfs inode plus PID; manifests must keep guardian, client and payload accounts disjoint; client arguments follow a per-policy alphabet. Core admission closure, guardian death and a spent lease ledger all end admission. Bootstrap re-entry is refused without touching the given descriptor.
  • service_main.c is the installed entry. It takes the guardian endpoint on fd 3 and a compiled manifest, and acceptance builds and execs it.
  • Three clean runs pass 495 peer/lease checks and 221 authority checks. The stage137 contracts (96) and lifecycle suite still pass, and the contained suite still exits 77. Each of eighteen mutations fails at least one suite.
  • Still peer/lease evidence only. The protected child setup has never executed here, and the production gate stays closed.
  • Local evidence: .worktrees/agent-tools/stage138/ with review.md, todo.md and implementation/implementation-report.md. Runs are service-checks26.json to service-checks48.json. These ignored artifacts are local evidence, not distributed package contents.

U-20261029-07 · 2026-10-29 · Deliver the nested capability through the worker bootstrap pipe · #snapshot #agent #linux #verification

  • At START, a policy that permits child policies now gets 32 random bytes in its validated spec. The core moves them into the admitted record and wipes the arena copy. Replay compares only whether a capability exists, so a retried START keeps the first record and its bytes. The service records the grant only for ACCEPTED, with exactly the bytes the core will deliver.
  • A nested-capable record gets one more pipe. Its child receives the read end on fd 4, and nothing else above fd 3. The worker writes one frame (magic, version, parent ticket, capability) only after the payload identity is published, then closes the pipe. Every other path closes it empty, and the record's copy is wiped in every path.
  • The capability still authorizes nothing by itself: OPEN_CHILD also requires the payload principal, live membership in the published payload and an eligible parent.
  • Two clean runs pass; production objects compile with strict warnings.
    • The fixture child reads exactly the frame and then EOF.
    • A prelaunch revoke delivers nothing and leaves no descriptor.
    • Spec replay and conflict behave as specified.
    • Peer/lease checks (215) and authority checks (139) now count assertions only; loop iterations no longer count.
    • Stage137 contracts and lifecycle pass; contained exits 77.
    • All 22 mutations are caught. One equivalent mutation was recorded and removed from the runner.
  • Not executed here: delivery after real publication in the protected worker, the helper reading fd 4, and an end-to-end grant behind the closed gate.
  • Local evidence: .worktrees/agent-tools/stage139/ with todo.md, implementation/implementation-report.md and service-checks*.json. These ignored artifacts are local evidence, not distributed package contents.

U-20261029-08 · 2026-10-29 · Let a channel close stop a waiting request and fence late replies · #snapshot #agent #reliability

  • OwnedChannel held one re-entrant lock through a whole request, and close took the same lock. Another thread therefore could not stop a request waiting for its reply until the reply arrived or the request deadline passed.
  • Request admission and retirement now use separate locks, and the stop intent is monotone. close sets it before taking the retirement lock, then stops and reaps the helper as before.
  • A waiting request checks the intent before and after every queue read, after an input event callback, and immediately before delivering a result. A reply that was already queued when close began is not delivered; the request fails and the helper is reaped.
  • New tests cover these cases:
    • a close from another thread ends a 20-second waiting request in well under 5 seconds;
    • a reply dequeued just before close is refused;
    • a closed channel refuses new requests. The first two fail against the previous implementation. All tests touching the channel and its five consumers pass.
  • This covers the existing pipe transport only. Start-acknowledgment loss, connection loss and per-channel leases over the owner service remain open in Progress.md.

U-20261029-09 · 2026-10-29 · Relay helper application traffic through worker-owned pipes · #snapshot #agent #linux #verification

  • Under the owner service, fd 0 was only the lifetime pipe and fd 1 a sink, so a helper's JSON-lines traffic had no path. Following the stage135 selected design, each record worker now owns a request pipe (fd 0, blocking in the child) and a reply pipe (fd 1, blocking in the child). Each direction has a bounded 64 KiB buffer whose lock covers memory copies only.
  • Both worker loops pump on every turn without blocking. After the child exits they drain what it wrote, and on cleanup they close the relay before the pipes.
  • Two opcodes reach the relay:
    • OP_WRITE returns how many bytes were accepted.
    • OP_READ returns up to 8 KiB, plus an EOF flag once the child has closed fd 1 and nothing remains.
  • The core accepts a ticket only for the lease its record was admitted under, and only while that lease is open. Writes also need open admission. A reply that cannot be sent closes the lease, because its bytes are gone.
  • To stay under 750 lines, the lease ledger and relay entry points moved into native_owner_lease.c, and the worker pump into native_relay_linux.c.
  • Two clean runs pass.
    • Fixture relay: echo through a real child; the bound on a partial write; EOF after exit; refusal for a foreign lease, after the worker finished, and after lease close.
    • Service relay: request bytes reach the buffer; injected replies come back with EOF; oversized, unknown, fenced and closed cases are refused; a lost read reply closes the lease.
    • 27 of 28 mutations ran, and each was caught. Two had faulty mutation text and were re-run after correction. no-output-sink did not run, because this stage rewrote the line it patches. It is replaced in the next stage.
  • Local evidence: .worktrees/agent-tools/stage141/ with design.md and implementation/implementation-report.md. These ignored artifacts are local evidence, not distributed package contents.

U-20261029-10 · 2026-10-29 · Add the Linux owner-service client and observe it end to end · #snapshot #agent #linux #verification

  • owner_service_wire.py mirrors the service's exact-size frames. native_service.h now pins both layouts with _Static_asserts on their sizes and field offsets, so the two sides cannot drift silently.

  • helper_owner_linux.py gives the owner service the OwnedChannel surface:

    • Lease and start: one connection and lease per channel. OPEN and START are retried with a fixed nonce and request ID, so a lost acknowledgment never launches twice.
    • Replies: a reply to an earlier timed-out call is skipped by nonce. A relay reply that is lost fails the request, because the stream position is unknown.
    • Close: close waits for at most one in-flight call and fences any reply after it begins. It closes the lease and reports retired only once the service observes the helper settled.
  • The service gained OP_OBSERVE: read-only, for the lease the record was admitted under, open or closed. service_main now ignores SIGPIPE, because workers write to pipes whose reader may have died.

  • native_channel.py and the new client share one reply classifier and event-owner check.

  • 13 tests of the client run against an in-process fake service. Inside WSL, the same client also drives the real C service, end to end:

    • two requests round-trip through a real child;
    • close kills that child, and the client correctly refuses to claim retirement of an unprotected fixture;
    • a close from another thread fences a waiting request;
    • a helper exit is seen as the end of the reply stream;
    • the service drains with nothing owned.

    This uses an acceptance-only stand-in for the gated protected launch.

  • Mutation evidence: all 32 modes are caught. no-output-sink had silently not run in stage141, because its anchor text was gone. It was rewritten as two modes, and U-20261029-09 is corrected.

  • Local evidence: .worktrees/agent-tools/stage142/.

U-20261029-11 · 2026-10-29 · Route the five helper consumers through one channel factory · #snapshot #agent #linux

  • helper_environment, native_target, remote_target, presence_pool and presence_worker used to construct OwnedChannel directly. They now call owned_channel(argv, on_control=...) and type their channel as the HelperChannel protocol (request, close, retired).
  • Windows and macOS keep the local channel. Linux keeps it too when the host has installed no owner-service binding.
  • With a binding, Linux launches only through the owner service, and only for an argv that the binding lists exactly. Any other argv is refused and never falls back to a local process.
  • The binding is a root-owned file at /etc/je_auto_control/owner_service.json that nobody else can write, at most 64 KiB. It holds exactly an absolute endpoint and unique argv to policy rows. Anything else refuses. It never comes from a task, a model, a request or the environment.
  • Linux without a binding still runs uncontained helpers. Making that a refusal is recorded in Progress.md as a deployment decision.
  • 17 factory tests and the consumer test files that patch the channel pass.

U-20261029-12 · 2026-10-29 · Add the guardian's durable epoch journal · #snapshot #agent #linux #verification

  • The guardian needs durable state before it may create, grant or reclaim an epoch: the installation identity, a monotone counter, the exact names the counter derives, the manifest version and the recovery phase.
  • The state directory and both slots open without following links and must be owned by the administrator with no group or other write.
  • A second guardian is refused by a non-blocking exclusive lock.
  • Each write goes to the slot not holding the current record, and is synced with its directory before it becomes current.
  • When reading the slots:
    • The newer valid sequence wins.
    • Equal sequences must agree byte for byte.
    • A newer slot may not lower the counter.
    • Another installation, or an invalid slot with nothing valid beside it, refuses.
    • A torn newer write falls back to the older record. That is safe, because nothing is created before a record is durable.
  • Phases run CLEAN → PLANNED → ACTIVE/RECOVERING → CLEAN, and the counter refuses at its maximum.
  • 107 checks pass, unprivileged, in a temporary directory. All ten mutations are caught. The CRC case was strengthened after its first mutation survived.
  • Local evidence: .worktrees/agent-tools/stage144/.

U-20261029-13 · 2026-10-29 · Add the guardian process with refusal and recovery evidence · #snapshot #agent #linux #verification

  • guardian_prepare:
    1. Opens the journal.
    2. Checks the cgroup2 mount.
    3. Resolves the subtree beneath it with no symlinks or other mounts, and requires the hierarchy owner.
    4. Cold-recovers any unfinished epoch.
    5. Plans durably, then creates the root-owned service branch and the epoch branch delegated to the service account.
    6. If creation fails, it reclaims what exists and stays CLEAN with the counter consumed.
  • Recovery kills the service branch before the epoch branch with cgroup.kill, waits for populated 0, and removes child cgroups bottom-up.
  • guardian_main:
    • binds the listener;
    • clones the service into its branch with a pidfd, and the child drops to the service account and execs with only fd 3;
    • exchanges the grant, authenticating each frame against the cloned pidfd;
    • marks the journal ACTIVE and supervises;
    • always recovers before exiting.
  • Evidence covers refusals and nothing-created recovery only, as an unprivileged account. All objects compile with strict warnings. The guardian acceptance passes 42 checks:
    • foreign-owned, writable or missing state directory, and a held lock;
    • a non-cgroup2 mount, an escaping subtree, and the wrong subtree owner;
    • creation refused with recovery to CLEAN;
    • a crash left PLANNED, ACTIVE or RECOVERING, recovered to CLEAN.
  • Mutations: four of five guardian modes are caught, plus all ten journal modes. Skipping the service branch during recovery is unobservable without a populated hierarchy, and stays with the deferred protected acceptance.
  • Never executed: delegation, the service launch as its account, the grant, supervision and recovery of a populated epoch. All need root and a provisioned hierarchy.
  • Local evidence: .worktrees/agent-tools/stage145/.

U-20261029-14 · 2026-10-29 · Let nested helpers open child leases with their delivered grant · #snapshot #agent #linux

  • owner_service_nested.read_nested_bootstrap reads the 72-byte frame the worker wrote on fd 4, requires EOF after it, checks magic, version and a parent record, and always closes the descriptor. Its NestedGrant repr never shows the capability.
  • OwnerServiceChannel(parent=grant) opens its lease with OP_OPEN_CHILD, sending the parent ticket and capability. The fixed nonce keeps a retried open to one lease. owned_channel(..., nested=grant) passes the grant through on Linux, and refuses it anywhere the owner service is absent.
  • The capability still authorizes nothing by itself; the service checks membership and parent eligibility.
  • Tests: 9 frame cases, 2 nested client cases and 1 factory case. Against the real service in WSL, a nested open is refused (no grant exists behind the closed gate) and the channel retires with no helper.
  • Not done: a granted nested lease under a protected parent, and calling the reader from the presence broker's entry point.
  • Local evidence: .worktrees/agent-tools/stage146/.

U-20261029-15 · 2026-10-29 · Signal a POSIX helper group only while its leader still holds the ID · #snapshot #agent #reliability

  • The local OwnedChannel stops a POSIX helper with killpg(pid, SIGKILL). That is safe only while the helper's PID, which is also its group ID, cannot have been reused. Two cases broke this:

    • with SIGCHLD ignored, the kernel reaps the leader at once;
    • anything else in the process can reap it with waitpid.

    Either way the number may belong to an unrelated group by the time close runs.

  • Construction now refuses on POSIX while SIGCHLD is ignored, before any helper starts.

  • Close first asks, without reaping, whether the leader is still unreaped (waitid with WNOHANG | WNOWAIT). Alive or a zombie, it still holds the number, so the group is signalled and then reaped as before. If something else already reaped it, close refuses to signal and the channel stays unretired. That follows the rule that unknown cleanup never clears ownership.

  • Windows keeps its job-object path unchanged.

  • The WSL check passes all five cases against the package in place:

    • ignored SIGCHLD is refused;
    • normal, hung and crashed helpers still retire;
    • a leader reaped elsewhere is never signalled.
  • Two POSIX tests join the suite for Linux CI; Windows skips them. The 232 tests touching the channel pass.

  • Descendants that leave the group are still beyond the local channel. That containment remains the owner service's cgroup kill.

  • Local evidence: .worktrees/agent-tools/stage147/.

U-20261029-16 · 2026-10-29 · Report helper containment in runtime status · #snapshot #agent #diagnostics

  • Runtime status (agent_runtime_status, AC_agent_runtime_status, agent-task status) now includes helper_containment. It reports how this host owns helpers without launching one: the mode, the intended containment, and one of these statuses:
    • not_probed on Windows;
    • not_supported on macOS and other POSIX systems;
    • not_configured on Linux without a binding;
    • binding_refused, with the reason;
    • unreachable;
    • reachable_unverified.
  • native_evidence is always not_recorded, because reaching the service proves no containment. Existing status keys are unchanged.
  • 6 new factory tests cover each status. Inside WSL, the reachability probe finds a real SOCK_SEQPACKET listener and reports a closed one as unreachable.
  • 182 agent CLI, status and export tests pass, and the documentation gates pass.
  • Documented in docs/AGENT_TASKS.md and CHANGELOG.md.
  • Desktop permission, device connection and source/target readiness diagnostics remain open in Progress.md.

U-20261029-17 · 2026-10-29 · Let the guardian verify client namespaces and hand over connections · #snapshot #agent #linux #verification

  • The maintainer decided that client namespace verification belongs to the root guardian, because a non-root service gets EPERM reading other accounts' namespaces.
  • The guardian now owns the client listener. It accepts each client and checks that its UID and GID are listed and that its user, pid, mount and cgroup namespaces match the manifest (read through the client's pidfd). Only then does it send the service a GRANT_CONNECTION frame carrying the connection; refused clients are dropped.
  • The service never listens in production. It accepts handoff frames only from the guardian process and only for the current epoch and generation. Anything else, EOF included, ends admission. Its principal check is now UID/GID only.
  • The guardian enables credential passing on its listener. A client frame queued before the service adopts the connection would otherwise arrive without credentials; the first handoff test failed exactly that way before the fix.
  • All checks pass in isolated staging:
    • service: 215 peer/lease and 200 authority checks, plus the end-to-end run;
    • guardian: 107 journal, 42 refusal and 53 forwarding checks;
    • all 33 service mutations and both new forwarding mutations are caught.
  • Local evidence: .worktrees/agent-tools/stage149/.

U-20261029-18 · 2026-10-29 · Run the protected owner-service acceptance in WSL · #snapshot #agent #linux #verification

  • The maintainer authorized provisioning inside the WSL distro podman-webrunner-validation only, with everything removed afterwards.
  • A root probe showed that cgroup v2 lets a delegatee move a process only with write access to the common ancestor's cgroup.procs. The earlier layout therefore could never launch a payload. Each epoch is now a delegated root holding a root-owned service leaf and the delegated records anchor, and recovery is one cgroup.kill of the epoch.
  • The guardian starts the service with exactly CAP_SETUID, CAP_SETGID and CAP_SETPCAP as ambient capabilities. The production gate opens only in the protected acceptance build.
  • protected_run.py runs as root. It provisions three system accounts, the cgroup subtree and the state, runtime and binary directories. It then runs the guardian, the gate-open service and a real client (UID 1000, through the package's OwnerServiceChannel), and finally removes everything.
  • Three consecutive runs each meet all 13 expectations:
    • the payload answers through the full protected chain, as its own account, with no capabilities, an empty bounding set and no_new_privs;
    • the payload cannot migrate itself;
    • an unlisted account that reaches the socket is dropped by the guardian;
    • a descendant that escaped with setsid and a double fork stays in the payload cgroup and dies at retirement;
    • close reports retired: true, the first protected RETIRED report;
    • SIGTERM reclaims the epoch;
    • after the guardian and the service are SIGKILLed, cold recovery kills the surviving payload and descendant;
    • nothing is left behind.
  • Protected mutations: dropping the bounding-set drop, skipping epoch reclamation and removing cgroup.kill are each caught. Two others are equivalent here, as defence in depth that the report explains.
  • Limits: one distro, one kernel, no concurrent sessions or nested protected parents, and no 24-hour run. Installed builds keep the gate closed until the independent review.
  • Local evidence: .worktrees/agent-tools/stage150/.

U-20261029-19 · 2026-10-29 · Verify sibling sessions and a nested helper under a protected parent · #snapshot #agent #linux #verification

  • The WSL protected acceptance now also covers two cases.
    • Siblings: two clients hold separate leases and payloads, each with an escaped descendant. Closing one retires it and kills only its own descendant; the other keeps answering until its own close.
    • Nesting: a top-level Python parent payload reads its grant from fd 4 and connects to the guardian as the payload account. It opens an OPEN_CHILD lease and starts a child, which runs in a record container inside the parent's container and answers. Closing the child retires it and kills its descendant; then the parent retires.
  • Three consecutive runs each meet all 17 expectations, and cleanup leaves nothing behind. With no grant written to fd 4, the parent cannot nest; this protected mutation is caught.
  • Still open: launch cancellation during clone, more than one nesting level, other kernels and distributions, and the 24-hour run.
  • Local evidence: .worktrees/agent-tools/stage150/.

U-20261029-20 · 2026-10-29 · Stress revocation racing protected launches · #snapshot #agent #linux #verification

  • The WSL protected acceptance adds seven cycles of lease, START and an immediate CLOSE, so revocation races the worker's cgroup preparation and clone.
  • In three consecutive runs, all 18 expectations hold:
    • every cycle retires;
    • no payload or record container remains;
    • the guardian stops cleanly.
  • Timing cannot prove that a revoke landed at the clone instant itself, so deterministic cancellation there stays open in Progress.md.
  • Local evidence: .worktrees/agent-tools/stage150/.

U-20261029-21 · 2026-10-29 · Cap each client's share of an epoch's lease positions · #snapshot #agent #linux

  • Following the maintainer's decision, each client account may now use at most the manifest's client_lease_quota of an epoch's 32 lease positions, counting open and spent leases alike. Excess opens get CAPACITY.
  • A quota of 0 or above 32 is a malformed manifest.
  • The authority acceptance covers the cap, and the no-quota mutation is caught. The protected acceptance in WSL passes with a quota of 8.
  • Local evidence: .worktrees/agent-tools/stage151/.

U-20261029-22 · 2026-10-29 · Move the Linux owner service sources into the repository · #snapshot #agent #linux #packaging

  • Following the maintainer's decision, native/owner_service/ now holds the C sources (guardian, service, owner core), a manifest template, build.sh, and the unprivileged (tests/run_checks.py) and root (tests/protected_run.py) acceptance.
  • None of it is in the wheel. The package never builds, installs or starts it, and its builds keep the protected launch gate closed until a reviewed release.
  • From the committed layout, inside WSL:
    • every unprivileged suite passes;
    • the root protected acceptance meets all 18 expectations and leaves nothing behind;
    • build.sh builds both binaries from the example manifest.
  • test_owner_service_native.py checks on every platform that the Python frames, opcodes, statuses and nested bootstrap constants match the committed C headers. Where the toolchain allows, it also runs the native suites.
  • Documented in the three READMEs, docs/AGENT_TASKS.md, architecture.md and CHANGELOG.md.
  • Still open: other architectures, libc versions and kernels, installed-host acceptance, and the independent review before the gate opens.

U-20261029-23 · 2026-10-29 · Fix the owner service blockers from independent review · #snapshot #agent #linux #security

  • An independent review of the owner service found no client or payload privilege escalation, but three blockers to opening the gate. All three are now fixed.
  • Leases renew. OP_RENEW extends a held, open lease by one lifetime, up to the manifest's new lease_max_age_ns. OwnerServiceChannel renews in a background thread while the channel lives, idle or not. A channel whose lease expired now says so instead of reporting a generic refusal.
  • Epochs roll over. Once the client's quota or an epoch's record slots are spent and no lease or connection is open, the service drains. The guardian then reclaims the epoch and grants the next one in the same process. It exits 0 only when asked to stop, and non-zero on any failure.
  • Payloads are isolated by account and group:
    • The listener belongs to a dedicated socket group.
    • Payload accounts need their own primary group, distinct from the guardian, the service, the client and the socket group.
    • The payload UID may not be the service's.
    • Only nested-capable payloads receive the socket group.
    • A service accepts exactly one client account, because payload accounts are shared by policy.
  • Hardening:
    • The service now runs with a bounding set of CAP_SETUID, CAP_SETGID and CAP_SETPCAP only, SECBIT_NOROOT locked, no_new_privs, and an empty signal mask.
    • The guardian binds its listener under a umask in a directory only root can write, chowns it without following links, and hands connections over without blocking.
    • A close that cannot know whether START launched a helper no longer claims the channel retired.
  • Evidence:
    • Unprivileged suites pass; the authority suite grew from 211 to 238 checks.
    • Seven mutations of the fixes are all caught.
    • The root protected acceptance in WSL meets 22 of 22 expectations and leaves nothing behind. New expectations cover a channel idle for three lifetimes, ten sequential sessions crossing an epoch boundary under one guardian, a private payload group, and the service's bounding set and no_new_privs.
  • The remaining review findings are listed in Progress.md. The gate stays closed until they are addressed and reviewed again.
  • Local evidence: .worktrees/agent-tools/stage153-protected.json and mutate153.py.

U-20261030-01 · 2026-10-30 · Bound each owner-service helper's processes and memory · #snapshot #agent #linux #security

  • Closes a review finding: payloads had no resource limits, so one fork bomb or leak could take down the host and make the service's own thread and clone calls fail for everyone.
  • The guardian enables the pids and memory controllers on the subtree, the epoch and the delegated records anchor before delegating them. None of these cgroups holds a process.
  • Before the payload exists, the service writes the manifest's new record_pids_max and record_memory_max to each record's container, closes swap where the host accounts it, and enables both controllers inside the container. Only the service can write those files. The limits therefore bound the payload and every nested child below it.
  • Values below 8 processes or 16 MiB make the manifest invalid. The template uses 256 processes and 2 GiB.
  • The administrator must enable both controllers down to the subtree's parent; otherwise the guardian refuses with prepare operation 4 errno 2.
  • Evidence:
    • Unprivileged suites pass, with two new manifest-validation faults.
    • The root protected acceptance in WSL meets 24 of 24 expectations. The container showed pids.max 32 and memory.max 128 MiB, and a payload trying to fork 64 children got 30: with itself and its escaped descendant, exactly the limit.
    • The runner enabled the controllers this distro lacked at the root and restored them afterwards.
  • Local evidence: .worktrees/agent-tools/stage154-protected.json.

U-20261030-02 · 2026-10-30 · Cap each account's share of owner-service connections · #snapshot #agent #linux #security

  • Closes a review finding: the service's 16 connections were shared host-wide, so one account could hold every slot. That includes a nested-capable payload, which reaches the guardian too, and could lock out the client.
  • After authenticating a connection, the service now counts the open connections of the same account. It closes the new one, unanswered, once the manifest's connections_per_account is reached.
  • The value must be 1 to 8, half the table, so the client and the payload account each keep at least half. The template uses 8.
  • The authority suite adds a case: three connections serve, the fourth is closed, and closing one makes room again. It also adds two manifest-validation faults.
  • Mutations that drop the check or the bound are both caught.
  • The root protected acceptance still meets 24 of 24 expectations with nothing left behind.
  • Local evidence: .worktrees/agent-tools/stage155-protected.json and mutate155.py.

U-20261030-03 · 2026-10-30 · Trust the owner-service binding and endpoint only from root · #snapshot #agent #linux #security

  • Closes a review finding. The binding loader stat-ed /etc/je_auto_control/owner_service.json and then opened it by path again, never checked the directories above it, and the client never checked who listened on the endpoint.
  • The loader now opens the file once with O_NOFOLLOW, O_NONBLOCK and O_CLOEXEC, and judges ownership, mode and size on that descriptor with fstat. It also requires every ancestor to be a real root-owned directory that nobody else may write; a sticky world-writable directory counts as writable.
  • SeqpacketTransport reads SO_PEERCRED after connecting and refuses a listener that is not UID 0, the guardian. Only the unprivileged e2e harness passes its own UID.
  • Tests:
    • Windows and CI cover the ancestor rules (group-writable, sticky, account-owned, symlinked or unreadable parent) and a refusal from an untrusted directory.
    • The Linux-only cases (symlinked binding, FIFO binding, wrong listener UID) ran in WSL.
    • The native suites, e2e included, pass, and the root protected acceptance still meets 24 of 24 expectations.
  • Local evidence: .worktrees/agent-tools/linux_only_checks156.py and stage156-protected.json.

U-20261030-04 · 2026-10-30 · Replay a lost START's ticket and pin nested children to the parent's account · #snapshot #agent #linux #security

  • Closes two review findings.
  • Lost START reply. When the service failed to send an admitted START's reply, it closed the lease as REPLY_LOST. The client's replay then got CLOSED and never learned the ticket, so it could not observe the record settle.
    • A lease now keeps the request ID and ticket of its admitted START.
    • A replay of that START on the holder's connection gets EXISTING and the same ticket even after the lease closed.
    • The e2e run checks this on a lease closed after its helper exited.
  • Nested child accounts. A policy's child_policies could name a child that did not exist, was top-level, or ran as another payload account. All three now make the manifest invalid.
  • The other half of that finding, policies not bound to a principal, needs no change: a service now serves exactly one client account.
  • Evidence:
    • Unprivileged suites and e2e pass, with three new validation faults.
    • Mutations that drop the replay, the child check or the account comparison are all caught.
    • The root protected acceptance, whose manifest has a parent and a nested child policy, meets 24 of 24 expectations.
  • Local evidence: .worktrees/agent-tools/mutate157.py and stage157-protected.json.

U-20261030-05 · 2026-10-30 · Check every ancestor of the guardian's state and cgroup paths · #snapshot #agent #linux #security

  • Closes a review finding. The guardian opened its state directory and the cgroup mount by path and checked only the last directory, so a writable ancestor could have let another account swap a parent in.
  • gj_open_trusted_directory now walks from / one component at a time with O_NOFOLLOW. It judges each opened descriptor with fstat and uses the descriptor it ends on. Every directory must be root's, or the administrator's for the state directory and the hierarchy owner's for the mount. A directory others may write must be sticky.
  • gj_open and the guardian's open_hierarchy use it. The subtree below the mount was already opened with RESOLVE_BENEATH | RESOLVE_NO_SYMLINKS and its leaf checked.
  • Evidence:
    • The journal acceptance grew from 107 to 116 checks. It now covers a world-writable non-sticky ancestor, the same ancestor made sticky, a symlinked ancestor, and a relative path.
    • Mutations that trust a writable ancestor, follow links or accept a relative path are all caught.
    • The root protected acceptance meets 24 of 24 expectations.
  • Local evidence: .worktrees/agent-tools/mutate159.py and stage159-protected.json.

U-20261030-06 · 2026-10-30 · Bound the owner service's drain and prove the guardian reclaims a dead service · #snapshot #agent #linux

  • Closes a review finding. A record stuck in cleanup kept the service draining forever, so the guardian never reclaimed the epoch and every new open got CAPACITY or UNAVAILABLE. Together with the non-blocking handoff of U-20261029-23, this closes the stuck-drain finding.
  • The drain now stops after 30 seconds and exits with EXIT_STICKY. It does not free state a worker may still use; the kernel drops the descriptors. The guardian, seeing the service gone, kills and removes the whole epoch, stuck helpers included, and grants the next.
  • The stuck cleanup itself cannot be provoked in the acceptance. What the deadline relies on was proven instead. A new protected scenario SIGKILLs only the service while a helper and its escaped descendant are alive:
    • the live guardian removes the old epoch;
    • both processes are gone;
    • the guardian stays up;
    • the next session succeeds in a fresh epoch on its first attempt.
  • The root protected acceptance meets 25 of 25 expectations with nothing left behind, and the unprivileged suites pass.
  • Local evidence: .worktrees/agent-tools/stage160-protected.json.

U-20261030-07 · 2026-10-30 · Confine the owner service's identity calls with seccomp · #snapshot #agent #linux #security

  • A second independent review found that the first review's M2 fix was not real. The bounding set, SECBIT_NOROOT and no_new_privs guard only exec, and the service keeps CAP_SETUID and CAP_SETGID in its effective set. A code-execution bug could therefore call setresuid(0,0,0) and own every root file. A second route, found while fixing it: write a uid_map in a new user namespace. The README's claim was false and has been corrected.
  • The guardian now installs a seccomp filter (guardian_seccomp_linux.c) before dropping to the service account. Every payload inherits it.
    • setresuid and setresgid accept only the service's and the manifest's payload IDs, or -1.
    • setgroups accepts only an empty list.
    • setuid, setreuid, setfsuid and their group variants fail.
    • unshare and clone with CLONE_NEWUSER fail.
    • clone3, whose flags a filter cannot read, answers ENOSYS, which glibc meets by falling back to clone.
    • A foreign architecture or an x32 syscall kills the process.
  • Because of that, protected payloads are no longer created with clone3(CLONE_INTO_CGROUP).
    • The service clones them, moves them into their payload cgroup, checks revocation, and only then releases them through a pipe. A child never released exits ECANCELED through the existing exec-error path.
    • Payloads hold no supplementary group. A nested-capable payload reaches the guardian through a POSIX ACL on the listener that names every client in the guardian's manifest.
    • The listener's whole ancestry is now checked like the state directory's.
  • Evidence:
    • The unprivileged suites pass, and the template builds.
    • The root protected acceptance meets 27 of 27 expectations. Among them:
      • a probe running the same filter as root gets EPERM for setresuid(0), setresgid(0), setuid(0), setgroups({0}), unshare(CLONE_NEWUSER) and clone(CLONE_NEWUSER), gets ENOSYS for clone3, and can still switch to the payload account;
      • the running service and payloads report Seccomp: 2;
      • the payload's own Gid and an empty Groups are read from /proc;
      • every session, the nested child, rollover and crash scenarios work through the new clone-and-move launch.
  • Local evidence: .worktrees/agent-tools/stage161-protected.json.

U-20261030-08 · 2026-10-30 · Keep idle connections from holding the owner service's epoch · #snapshot #agent #linux

  • Closes the second review's other major finding and MINOR-3, 4, 8 and 9.
  • Rollover. A spent epoch drained only when no lease and no connection was open. The Python channel connected at construction and kept the connection of any channel it could not retire, so one idle or broken channel could stall every new helper on the host for as long as its process lived.
    • A connection without an open lease now holds a spent epoch for at most a 5-second grace after its last packet. That is long enough to observe its helper settle.
    • SeqpacketTransport connects on its first frame.
    • A connection that is unreachable, refused or dropped before the channel has a lease raises AgentControlBusy, through the new ServiceConnectionLost. That covers an account at its connection share and a service between epochs.
  • START replay. The service now answers a replay of an admitted START with its ticket before expiry or nested eligibility can refuse it, in any lease phase. close() replays a START whose reply never came, so it learns the ticket and can observe the helper retire. Any other answer proves no helper started; no answer still claims nothing.
  • Guardian. It reaps its service with waitid(P_PIDFD), killing it first if still alive, and logs how it ended. When a service ends within a second, it waits a second before the next epoch, still answering a stop request at once.
  • Renewer. A failed connection now ends the renewer quietly and marks the lease lost. close() joins the renewer before closing the transport.
  • Docs. The service README now says to recreate the listener directory and the cgroup subtree at every boot.
  • Evidence:
    • The authority suite adds the idle-connection case: within the grace the service still admits, past it it drains. Mutations that keep connections forever or drop the grace are caught.
    • The channel tests add a refused connection reported as busy, a renewer surviving a failed connection without a thread error, and close() learning a lost START's ticket by replay. The Linux-only transport checks (lazy connect, wrong listener UID, symlink and FIFO bindings) ran in WSL.
    • The callers' tests pass: 498 passed, 69 skipped.
    • The native suites and e2e pass.
    • The root protected acceptance meets 27 of 27 expectations. After rollover the guardian's only child is the current service, and the earlier ones are reaped and logged.
  • Local evidence: .worktrees/agent-tools/mutate162.py and stage163-protected.json.

U-20261030-09 · 2026-10-30 · Give each owner-service helper its own account and bound child leases and connection floods · #snapshot #agent #linux #security

  • Closes the second review's MINOR-5, 6 and 7.
  • Separate accounts (MINOR-5). All helpers of a policy ran as one payload account, so any helper could ptrace, signal or take descriptors from another.
    • payload_uid/payload_gid are now the base of a 32-ID range. Each record runs as base plus its lease position, which is unique within an epoch, and every earlier epoch's processes are killed before the next one starts. No accounts are needed, as with systemd's DynamicUser.
    • Ranges must avoid the guardian's, the service's, the client's and the socket group's IDs, must be equal or disjoint across policies, and a nested child must draw from its parent's range.
    • The identity filter allows ranges.
    • A guardian client entry can list a range (id_count); listener ACL entries cover each ID in it.
  • Child leases and connection floods (MINOR-6).
    • Child leases are bounded per parent record by the new nested_lease_quota, instead of counting against an account's share a nested-capable payload could spend.
    • The guardian hands over at most 32 connections per account per second.
    • The service takes every pending handoff in one turn, so a burst never fills the channel and loses the connections behind it.
  • Subtree walk (MINOR-7). The guardian walks the cgroup subtree from the mount one component at a time without following links. It refuses (operation 14) any cgroup whose directory or control files belong to another account or are writable by others.
  • Evidence:
    • Unprivileged suites pass. Authority faults cover a range over a client and unequal overlapping ranges, and the nested case shows a parent's quota of 1 refusing a second child while another parent opens its first. The forward suite grew from 53 to 216 checks with the per-account burst.
    • Mutations that drop the child quota, count children against the account, drop the accept rate, allow overlapping ranges or check only the client's exact UID are all caught.
    • The root protected acceptance meets 29 of 29 expectations. Among them:
      • sibling helpers ran as 62000 and 62001;
      • the filter probe switches to the range's last ID and is refused one past it;
      • a second guardian refused a subtree below a delegated cgroup and started once root owned it again;
      • nothing was left behind.
    • The full headless suite on efe0ed1a passed before this change: 16,588 passed, 138 skipped, coverage 87.36%.
  • Local evidence: .worktrees/agent-tools/mutate165.py, mutate166.py, stage164-protected.json and stage166-protected.json.

U-20261030-10 · 2026-10-30 · Cap the owner service's whole epoch and keep helper files private · #snapshot #agent #linux #security

  • Closes the rest of MINOR-5 that can be closed without new machinery. Per-helper memory limits did not cover tmpfs pages a killed helper left behind: those are recharged to the parent cgroup. Helper files were created with the inherited umask, readable by other helper IDs.
  • The guardian now writes pids.max, memory.max and memory.swap.max on the epoch's records cgroup before delegating it. It uses the per-helper limits times the record capacity, taken from the service policy the new guardian_manifest.service points at, so the service cannot raise them.
  • Protected payloads start with umask 077.
  • Evidence:
    • The root protected acceptance meets 31 of 31 expectations. records read 256 processes and 1 GiB (eight records at 32 and 128 MiB), and a payload reported umask 077.
    • The unprivileged suites pass, and the template builds.
  • Still open in Progress.md: payload IDs repeat across epochs, so a later helper can read what an earlier helper with the same ID left in /tmp. Pages orphaned across epochs land on the subtree, which has no limit.
  • Local evidence: .worktrees/agent-tools/stage168-protected.json.

U-20261030-11 · 2026-10-30 · Remove what payload IDs left behind before reusing them · #snapshot #agent #linux #security

  • Closes the last part of MINOR-5. Payload IDs come back in every epoch (base plus lease position), so a later helper could read what an earlier one with the same ID left in a shared temporary directory. tmpfs pages a killed helper left charged moved up to the subtree, which has no limit.

  • After killing an epoch, when nothing runs as a payload ID, guardian_purge_payloads (guardian_purge_linux.c) removes:

    • files and directories owned by a payload ID under /tmp, /var/tmp, /dev/shm and /dev/mqueue;
    • SysV shared memory, message queues and semaphores whose owner or creator is a payload ID.

    It does so before the journal is marked clean, both on rollover and on cold recovery.

  • The walk opens every directory by descriptor with O_NOFOLLOW. It checks the opened inode is the one it saw, never crosses into another filesystem, stops at depth 32, and removes entries with unlinkat relative to the directory it opened. A rename or symlink swap on the way cannot redirect a removal.

  • Evidence:

    • In the root protected acceptance, a payload made a file in /tmp and a SysV segment. Both existed while it ran and were gone after its epoch was reclaimed.
    • The acceptance meets 32 of 32 expectations, the unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage169-protected.json.

U-20261030-12 · 2026-10-30 · Run the package's native worker under the owner service · #snapshot #agent #linux

  • Closes the testable half of NOTE-11. The template's helper program, the package's native_worker, had never run under the service; acceptance used only the C fixture payload.
  • The protected manifest now has policy 4: python3 -I -B -c putting the repository on the path and calling native_worker.main(). An installed package would use -m.
  • A new scenario starts it through the service and sends bootstrap. The worker answers {"protocol": 1}. It runs as range ID 62000 with Seccomp: 2 and two threads, so its parent-watch thread was created even though clone3 is refused. Closing the channel reports it retired.
  • Before that, the worker was measured standalone in an empty environment in its own session: 39 MB peak RSS, within the 128 MiB per-helper limit.
  • A first attempt failed because the manifest gave fixed_argc 4 for a five-element argv. The service cannot detect that mismatch; a manifest author must count.
  • The root protected acceptance meets 33 of 33 expectations.
  • Recorded as DECIDE in Progress.md: a protected helper runs as its own ID with an empty environment, so it cannot reach the user's X or Wayland socket. Desktop operations need a decision, either keep desktop helpers local or hand display descriptors to the helper.
  • Local evidence: .worktrees/agent-tools/stage170-protected.json and worker_peak.py.

U-20261030-13 · 2026-10-30 · Let a spent owner-service epoch retire beside the next one · #snapshot #agent #linux

  • Closes the remaining availability finding. Lease and record slots are never reused within an epoch, so once its quota was spent a single long-lived helper made every new open get CAPACITY until it closed, possibly a day.
  • Reusing slots would have rewritten the owner core's append-only records, child bitmaps and revocation ledger. Instead, epochs now overlap.
    • Spent with leases still open, the service sends GRANT_RETIRING once. It keeps renewing, relaying and observing those leases, and drains when they end.
    • The guardian stops handing it connections, moves the journal through RECOVERING to CLEAN, and starts the next epoch beside it. The retiring service keeps its channel, since a closed one reads as guardian loss.
    • When the retiring service ends, the guardian reaps it, reclaims its branch, and purges only that epoch's half of the payload IDs.
    • At most one epoch retires at a time.
    • Payload ranges grow to 64 IDs, and an epoch uses the half its counter's parity picks, so a retiring epoch and its successor never share an ID.
    • The listener now lives across epochs.
    • After a crash, the guardian reclaims every epoch-* branch under the subtree, journaled or not, then purges both halves.
  • native_service.c (888 lines) and native_launch_linux.c (802) were back over the 750-line limit. Whole functions moved unchanged into service_policy.c (manifest validation and the argument grammar), service_fixture_linux.c (acceptance-only seams) and native_child_linux.c (the cloned child's side of a launch). The largest file is now 742 lines.
  • Evidence:
    • The authority suite (288 checks) adds a case: spent with a held lease, the service sends one RETIRING frame for its epoch and keeps serving. Mutations that never retire or retire repeatedly are caught.
    • In the root protected acceptance, a long-lived helper ran as 62032 while ten later sessions all succeeded first time, the later ones in the next epoch as 62000 to 62002. The long-lived helper still answered and retired on close, its epoch was then reclaimed, and the guardian kept one child.
    • The acceptance meets 34 of 34 expectations with nothing left behind, and the template builds.
  • Local evidence: .worktrees/agent-tools/mutate172.py, stage171-protected.json and stage172-protected.json.

U-20261030-14 · 2026-10-30 · Keep display helpers local and route only display-free helpers to the owner service · #snapshot #agent #linux

  • Closes the second half of NOTE-11. A protected helper runs as its own payload ID with an empty environment, so it cannot reach the user's X or Wayland session. A desktop or browser helper routed to the service could not have worked.
  • Of the two options recorded, this takes the conservative one. Handing display descriptors to protected helpers would need its own design and review.
    • owned_channel gains display=. A display helper is always a local process, even on a host with a binding. This is a fixed routing rule, not a fallback after the service failed, and a display helper can never be a nested owner-service helper.
    • native_target, which drives the desktop or a browser, passes display=True.
    • Browser dependency probes and remote device helpers still go through the service.
    • helper_containment() reports display_helpers: local_process_group on a bound host.
  • Evidence:
    • Factory tests: a display helper on a bound Linux host never reaches the owner-service transport, and a nested display helper is refused.
    • The presence IPC test asserts native_target passes display=True.
    • The callers' tests pass: 528 passed, 69 skipped.
    • Documented in the three READMEs, docs/AGENT_TASKS.md, the service README and CHANGELOG.md.

U-20261030-15 · 2026-10-30 · Fix the third review's owner-service findings · #snapshot #agent #linux #security

  • A third independent review verified MAJOR-1, MINOR-3, 4, 7, 8, NOTE-10 and 11 fixed. It found a new major and several minors; the major and those minors are fixed here.
  • A (major): halves collided at a second overlap. Payload halves came from counter parity, so with epoch N still retiring, N+2 (after N+1 drained) reused N's IDs and their purge removed each other's files.
    • The guardian now picks each epoch's half itself, never the retiring one's, and sends it in guardian_grant.payload_half.
    • Every purge uses the recorded half; startup purges both.
  • B: a second RETIRING was lost. A RETIRING frame that arrives while another epoch retires is now kept pending and acted on once that epoch is reclaimed.
  • C: payload IDs could fill the connection table. For the per-account connection share, every ID of a payload range counts as one account.
  • D: a child that was never released hung.
    • The cloned child closes its own copy of the release pipe's write end before waiting, and a failed release kills it through its pidfd.
    • Found while testing: early launch returns, such as a revoke before clone, leaked the release pipe, so the record never settled and reported STICKY_UNKNOWN. Both worker cleanups now close it. Before the fix, 4 of 12 race-only runs had an unretired cycle; after it, 105 of 105 cycles retired.
  • E: purge gaps.
    • Files are judged by user ID only.
    • The walk keeps directories on a heap stack with no depth limit, raising the descriptor limit to the hard maximum.
    • /run/lock is purged too.
    • An unclean purge taints its half until restart.
    • The filter refuses keyctl, add_key and request_key, since per-user keyrings outlive an ID's processes.
  • F: privileged IDs as payload ranges.
    • The guardian validates the manifest before building the filter.
    • Ranges must start at 1000 or above, and no ID in them may resolve through the host's user or group databases.
  • H, J, K and the probe:
    • Only a frame on an open lease of its own keeps a connection active.
    • The accept rate is counted per user ID, and more than 16 clients refuses startup.
    • The stray-epoch sweep loops until none remain.
    • The crash backoff doubles to 30 s.
    • An unreachable endpoint raises AgentTaskError, not busy.
    • Browser dependency probes run locally, as the helpers they vet do.
  • Evidence:
    • The root protected acceptance meets 37 of 37 expectations. It adds a second overlap in which E3 took the half H1 did not use and left H1's files alone, and E3's handover waited for E1 and then happened in a fresh epoch on H1's freed half.
    • It also checks that a 40-level tree is purged, that a manifest whose range holds a real account is refused, and that the filter refuses keyctl.
    • Unprivileged suites pass, the template builds, and the Python tests pass.
  • Still open in Progress.md: the purge runs synchronously in the guardian's loop; remote helpers are unverified under the service; at most one epoch retires at a time.
  • Local evidence: .worktrees/agent-tools/race_repeat.py, stage177-protected.json and stage178-protected.json.

U-20261030-16 · 2026-10-30 · Purge off the guardian's loop, four payload slices, and a remote helper under the owner service · #snapshot #agent #linux

  • Closes the three items left open after the third review.
  • Purges move off the guardian's loop. While serving, each epoch's purge runs in a forked child, and the guardian goes on accepting and supervising. (As first committed, choosing a slice could still wait for a purge, and shutdown waited for every purge; U-20261030-17 removes both waits.)
    • That slice is not handed out until the child is reaped.
    • A failed purge taints the slice.
    • Startup and shutdown purge synchronously.
  • Up to three epochs retire at once.
    • Payload ranges hold four 32-ID slices (128 IDs).
    • The guardian picks a slice no running epoch uses, nor a tainted or purging one. When only a purge stands in the way, it waits for that purge.
    • Retiring epochs live in an array of three. A further retirement waits for a free slot, as the single-slot version did.
    • guardian_grant.payload_half becomes payload_slice.
  • Remote helpers verified under the service. A host-written remote helper around serve_remote_worker, with an adapter that reaches no device, ran as policy 5. It completed the negotiation RemoteTarget performs (bootstrap, remote_capabilities) as range ID 62000 under the identity filter, and retired on close. Talking to a real device stays in the deferred real-device acceptance.
  • Evidence:
    • The root protected acceptance meets 39 of 39 expectations. A new triple overlap held two spent epochs retiring around H1 (62000) and H2 (62032) while a third served (62064): three epochs at once, all reclaimed after both closed.
    • The second-overlap scenario now runs against a guardian built with a retiring limit of 1, so the handover that has to wait stays tested.
    • Guardian children are counted by name, since purge children are short-lived forks.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage181-protected.json and stage182-protected.json.

U-20261030-17 · 2026-10-30 · Keep a stubborn leftover from stopping the owner service, and never wait on a purge · #snapshot #agent #linux #security

  • A fourth independent review verified MAJOR-A and the other third-review items fixed. It found one major problem, caused by the purge taint added in U-20261030-15: a single helper could make the guardian fail on every start. It could leave a payload-owned directory deeper than the descriptor limit, or one another ID wrote into. That tainted the slice, and the next start's purge tainted every slice. This is fixed here, with the review's minors and notes.
  • Purge.
    • A removal that finds the object already gone counts as done.
    • A payload-owned object that cannot be removed is closed off (root, mode 0), opened without following links and checked by inode before fchown/fchmod.
    • The walk is bounded to 64 open levels; an owned directory deeper than that is closed off whole.
    • Only an object that can be neither removed nor closed off taints, and only its slice.
    • A root that is a link is resolved once and used only if root owns the target and others may write it only when sticky.
    • The manifest may add roots (purge_roots).
  • Startup, waiting and shutdown.
    • Startup kills the previous run's epochs first, then purges each slice once.
    • Choosing a slice never waits: with none free, there is no current epoch and clients wait in the listener's backlog until a purge or a retiring epoch ends.
    • A stop kills every epoch, then abandons running purges; the next start purges.
    • The purge child closes every inherited descriptor (journal lock, listener, channels), dies with the guardian and unblocks signals.
  • Limits and accounts.
    • The manifest may cap every running epoch together (subtree_pids_max, subtree_memory_max), and records gets cgroup.max.depth 32.
    • Every payload ID of every range is one account for the connection share.
    • The guardian's accept rate is per listed client entry.
    • A connection is kept active only after its frame authenticated.
  • Manifest validation. An NSS error now fails validation instead of passing. Ranged client entries must equal a payload range. The listener group must be the service's socket group. The service's IDs must lie outside every payload range. The example payload range moves to 50000.
  • Corrections.
    • U-20261030-16's "the purge no longer blocks the guardian" was overstated as committed; that entry now says so.
    • The guardian-children check counted only service_main children, hiding purge children. It now waits for purges to end and counts every child.
  • Evidence:
    • The root protected acceptance meets 40 of 40 expectations in three of four full runs. Among them:
      • a helper directory another ID wrote into, and an 80-level chain, both closed off;
      • the next scenario's guardian starting on a clean purge;
      • four epochs at once on slices 62000, 62032, 62065 and 62096.
    • The fourth run had one race cycle report STICKY_UNKNOWN; U-20261030-18 finds and fixes the cause. 154 race cycles alone and 70 under load all retired.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage187-protected.json, full-run-1.json and full-run-2.json.

U-20261030-18 · 2026-10-30 · Treat a revoke during a protected launch as cancellation, not an error · #snapshot #agent #linux

  • Root cause of the rare race cycle that U-20261030-17 left open. A revoke can land after the child was moved into its cgroup but before it was released. release_protected then recorded the ordinary ECANCELED as an error. Any recorded error makes publish_joined report STICKY_UNKNOWN, so the channel correctly refused to claim the helper retired.
  • The window is a few instructions wide, which is why the cycle appeared about once in five full runs and never in 224 isolated or loaded cycles. The logic dates from the clone-then-move launch (U-20261030-07).
  • A revoke at that point now only kills the unreleased child, which then settles like any killed child. A failure of the move or of the release itself is still reported as an error.
  • Evidence: three consecutive full root protected acceptance runs each met 40 of 40 expectations with nothing left behind. The unprivileged suites pass.
  • Local evidence: .worktrees/agent-tools/fix-run-1.json to fix-run-3.json.

U-20261030-19 · 2026-10-30 · Quarantine stubborn leftovers, bound epoch-N, and route helpers to their own epoch · #snapshot #agent #linux #security

  • A fifth independent review verified the fourth review's MAJOR-1 and most of its items fixed, and the race fix of U-20261030-18 correct. It found one major regression and a minor:
    • MAJOR-A. The depth bound stopped the purge for good at the first closed-off level, so files below 64 levels, tmpfs pages included, were never freed.
    • MINOR-B. epoch-N had no limits of its own.
    • NOTE-11 not fixed. U-20261030-17 left it open, while Progress.md said it was handled.
  • Quarantine.
    • A payload-owned directory that cannot be removed where it is gets inode-checked, then moved with RENAME_NOREPLACE into a root-only quarantine on the same filesystem. A wrong move is moved back. Quarantine names carry the PID, the clock and a serial, and a taken name is skipped: a later guardian with a reused PID once collided with an earlier guardian's name and fell back to closing the leftover off in place.
    • The quarantine is taken apart 64 levels per pass until a pass moves nothing.
    • Another ID's directory at the depth bound stays where it is and is walked from its own top.
    • A name that vanished or changed meanwhile is never an error and never taints.
    • An object already in the quarantine is never moved again.
  • epoch-N bounds. Before delegation it gets cgroup.max.depth 40, cgroup.max.descendants 4096, and pids.max/memory.max set to the records' limits plus room for the service, with no swap.
  • NOTE-11.
    • The guardian routes a helper's own connection to the epoch running its slice, so a nested parent in a retiring epoch can still open children.
    • A failed handover or epoch start is retried with backoff while the retiring epochs keep running, instead of ending the guardian.
  • Notes.
    • The purge child checks its parent after arming PDEATHSIG.
    • Abandoning a purge waits at most five seconds.
    • purge_roots is validated, and the listener group may not be 0.
    • NSS "not found" codes no longer count as lookup errors.
  • Evidence. The root protected acceptance meets 42 of 42 expectations.
    • An 80-level chain in /dev/shm with 8 MiB at its bottom, and a directory another ID wrote into, both leave their names free and nothing a payload ID owns anywhere under the purge roots. That run also cleaned chains old code had left in this WSL /tmp.
    • The epoch and subtree limits read back as written.
    • A nested parent whose epoch had retired opened a child, which ran as 62008 in the parent's slice.
    • The protected manifest's record capacity is now 16, above the client quota of 8, which a nested-capable policy needs; the template says so.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage192-protected.json and stage193-protected.json.

U-20261030-20 · 2026-10-30 · Recognise the quarantine by inode, rerun short purges, and retry starts from the main loop · #snapshot #agent #linux #security

  • A sixth independent review confirmed MINOR-B, NOTE-D…H and the routing half of NOTE-11 fixed, and MINOR-C's residual risk acceptable. It found two major problems:
    • M1. The quarantine used a fixed name. Any local user who took that name first turned the U-20261030-19 fix back into close-off in place. The walk also skipped that name whoever owned it, so a payload could hide files in a directory with that name.
    • M2. A refused epoch creation looped straight back into a retry without polling. Once the crash backoff aged out, the guardian spun at full CPU and never read SIGTERM.
  • Quarantine.
    • It is made when first needed, under a random name.
    • It is recognised by inode, never by name; a name someone else took first is just another directory to walk.
    • An emptied quarantine is removed, and so is an emptied directory inside one. Earlier quarantines are walked and removed once empty.
    • Closing off sets mode 0 before changing the owner (N1). Identity checks compare the owner too, and a failed move back is logged (N2).
  • Short purges.
    • One root's purge reads at most 4,194,304 entries (m2). A purge stops short when it hits that budget, runs out of quarantine passes, or has no quarantine when it needs one; that purge reports itself incomplete (m4).
    • An incomplete purge runs again, after a one-second pause, before its slice is handed out; startup purges that stopped short continue in a child.
    • Directories deferred during quarantine passes are walked in the same pass (m3).
    • Payload files a payload put inside another ID's directory, beyond that budget or past 256 deep directories, are logged, not tainted. Leaving them needs that ID's cooperation.
  • Retries.
    • A next epoch that cannot be planned (m1) or started, and a service ending within a second, are retried after 1, 2, 4 … up to 30 seconds.
    • The wait is the main poll's timeout, so a stop request, retiring epochs and purges are answered meanwhile.
    • The new epoch-N is delegated only after records and the service leaf exist.
  • Clients while no current epoch runs (N5). A helper's own connection reaches its retiring epoch. Up to 32 other clients are held until an epoch starts; the rest wait in the backlog.
  • Policy bounds (N6). Per-record pids are capped at 2^22 and memory at 64 TiB, so the limit products cannot wrap.
  • Not fixed, recorded as known limits:
    • N3: quarantines keep what other IDs own;
    • N4: an NSS outage that reports ENOENT counts as "not found";
    • N7: a bind mount on the same filesystem;
    • N6: the nested-capacity rule is documented, not enforced.
  • Evidence. The root protected acceptance meets 43 of 43 expectations in three consecutive runs.
    • Payload files inside another user's 1777 directories named like the quarantine, in /var/tmp and /dev/shm, are removed.
    • With every new cgroup refused, the guardian used 0 CPU ticks in three seconds, started a fresh epoch once creation worked, served a session, and stopped at once on SIGTERM during the backoff.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage197-protected.json and sixth-run-1.json to sixth-run-3.json.

U-20261030-21 · 2026-10-30 · Read every quarantine pass from the start, stop purges only on churn, and refuse set-ID bits · #snapshot #agent #linux #security

  • A seventh independent review confirmed M2, m1, m3, N1, N2 and the overflow half of N6 fixed. It found two major problems:
    • MAJOR-1. Every quarantine pass duped the same descriptor, which shares its offset. Only the first pass read anything, so chains deeper than about two walks stayed in the quarantine, with their tmpfs pages, while the purge reported clean. This was already in U-20261030-19.
    • MAJOR-2. The entry budget of U-20261030-20 let any local user stop every slice for good with a large static tree (for example 4.2M hard links in /var/tmp).
  • Quarantine passes. Each pass opens the quarantine afresh, so it reads from the first entry.
  • When a purge stops short.
    • The budget is gone; the size of what others keep only makes a purge slower.
    • A purge now stops short only on churn a live user causes: a directory entered twice in one walk (a table of up to 2^22 directories), or a listing yielding far more entries than its size when opened.
    • What is walked is the directory actually opened, and its owner is read from it.
    • A payload directory that could not be moved into the quarantine, for any reason, makes the purge incomplete.
  • Concurrent purges (m-A). Each quarantine is locked with flock while its purge runs, and a locked one at a root's top is left alone. Purges of two slices no longer remove each other's quarantine.
  • Deferral. Another ID's directories at the depth bound are deferred up to 4096, or what the raised descriptor limit leaves room for. Beyond that the purge logs once and is not made incomplete.
  • Set-ID bits (m-B). The service filter, which every payload inherits, refuses set-user- and set-group-ID bits from the chmod family, a creating open or mknod; openat2 answers ENOSYS. A file that escapes a purge is data, not an identity.
  • Clients and loop (m-C, N-a).
    • While no current epoch runs, the listener stays read for retiring epochs' helpers, and clients beyond the 32 held ones are dropped.
    • A slice waiting to be purged again with no purge child running wakes the loop every second.
  • Smaller fixes.
    • N-b: pids.max above the kernel's 2^22 is written as max.
    • N-c: directories deferred inside a quarantine count as quarantined.
  • Known limits. A live local user who renames another ID's directory behind the walk, or a payload file inside another ID's directories past the deferral limit, can escape one purge. Both need a directory that ID let the payload write into.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.
    • A 300-level chain in /dev/shm with 8 MiB at its bottom leaves its name free and nothing payload-owned anywhere.
    • Another user's static tree with 5000 directories at the depth bound is logged once per purge, and every slice is still handed out.
    • The filter probe refuses setuid and setgid through fchmod, fchmodat, a creating openat and mknodat, and allows ordinary modes.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage200-protected.json and seventh-run-1.json, seventh-run-2.json.

U-20261030-22 · 2026-10-30 · Know directories by file handle, skip ones met again, and refuse io_uring · #snapshot #agent #linux #security

  • An eighth independent review confirmed MAJOR-1, m-A, m-C, N-a and N-b fixed. It found:
    • M1 (major). A directory was known by device and inode number only. tmpfs mounted without inode64 reuses inode numbers after 2^32 allocations, so a local user could leave two live directories with the same number. Every purge would then report churn and never hand its slice out.
    • m1. A purge counted its own moves into the quarantine as churn, so a deep chain took many purges instead of many passes.
    • m2. Benign renames and inode reuse could stop purges with no guarantee of progress.
    • m3. io_uring opens files without passing the set-ID filter.
  • Directory identity (M1). The key is a 64-bit digest of the device, the inode number and, where the filesystem has one, the file handle from name_to_handle_at. The handle carries the inode generation, so a reused inode number is never taken for an earlier directory.
  • Directories met again (m1, m2).
    • A directory met again in one walk is skipped, not counted as churn. That covers one renamed behind the walk, a bind mount, and one this purge just moved into the quarantine (walked in the next pass).
    • Churn is now only a listing growing far past its size while it is read.
  • io_uring (m3). io_uring_setup answers ENOSYS, beside openat2.
  • Notes.
    • The seen table holds at most 2^21 slots of 16 bytes (N1).
    • The descriptor limit is raised for the purge only and restored afterwards, so processes the guardian launches keep the usual limit (N2).
  • Known limits. The following are recorded in the service README:
    • m4: payload files inside another ID's directories can escape a purge. That needs a live rename behind the walk, the deferral limit, or a mount another user placed on a payload directory; it stays as long as the directories do, and it needs a directory that ID let the payload write into.
    • N3: the purge needs Linux 6.6 or later, below the README's 6.13 floor.
    • N4: a bind mount is walked once and then skipped.
    • N5: an earlier quarantine locked by another slice's purge is left for a later purge.
    • N6: copying a set-group-ID directory's mode fails in a payload.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.
    • The 300-level chain goes in the startup purge with no churn logged.
    • A directory bind-mounted onto its own child neither loops nor stops a purge.
    • The filter probe also refuses fchmodat2 set-ID and an O_TMPFILE set-ID open, and answers ENOSYS to openat2 and io_uring_setup.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage202-protected.json and eighth-run-1.json, eighth-run-2.json.

U-20261030-23 · 2026-10-30 · Key the purge's directory identity, stay on the root's mount, and refuse passed-in io_uring rings · #snapshot #agent #linux #security

  • A ninth independent review confirmed M1, m1, N1 and N2 of U-20261030-22 fixed and m2 mostly fixed. It found:
    • MAJOR-1. Only io_uring_setup was refused. A ring another process made and passed over a socket could still be entered, and its OPENAT creates set-ID files without passing the filter.
    • MINOR-1. The directory key was an unkeyed digest anyone could compute, and a match now meant "skip".
    • MINOR-2. A walk could enter other mounts; once untracked, a bind loop walked forever.
    • MINOR-3. A user's FUSE mount reporting a payload UID could taint a slice.
    • MINOR-4. Tests read only the last 2000 characters of guardian output, and the probe's ENOSYS results had no control.
  • io_uring. io_uring_enter and io_uring_register answer ENOSYS too.
  • Directory identity.
    • A slot holds the exact inode number and a SipHash-2-4 of the file handle, keyed by getrandom for each purge. The SipHash implementation matches the reference vectors for lengths 0, 8 and 15.
    • A walk stays on one filesystem, so the device is the same for all slots.
    • A payload directory met again outside the quarantine makes the purge run again instead of being skipped. The first such meeting is logged.
  • Mounts. A walk compares each entry's mount ID (statx STATX_MNT_ID) with the root's. It never enters, disposes of or judges an object on another mount. This removes bind mounts as a revisit source, the untracked bind loop, and the FUSE taint.
  • Smaller fixes.
    • The file-handle buffer is a union with alignas, with no flexible array in a struct.
    • Tests keep 60,000 characters of guardian output.
    • The probe makes an openat2 file and a ring before installing the filter, and requires both to succeed. After the filter, entering and registering that ring answer ENOSYS.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.
    • The bind loop, static tree, squats and 300-level chain behave as before, with no churn logged.
    • Probe controls: openat2 0 and io_uring_setup 0 before the filter; io_uring_enter 38 and io_uring_register 38 after it.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage204-protected.json and ninth-run-1.json, ninth-run-2.json.

U-20261030-24 · 2026-10-30 · Test the purge's mount boundary, walk btrfs subvolumes, and check SipHash against the reference · #snapshot #agent #linux #security

  • A tenth independent review verified every finding of the ninth fixed:

    • io_uring enter/register are refused, and the probe has controls;
    • the keyed identity matches the SipHash-2-4 reference;
    • walks stay on the root's mount;
    • stderr is kept and the flexible-array member moved into a union.

    It found no major problem and judged that the gate could open on this component once MINOR-A's tests land.

  • MINOR-A (tests).

    • The siblings scenario now asserts that the bind loop is stopped by the mount check, with no "met a directory again" logged.
    • A directory from outside every root, holding a payload-owned file and bind-mounted under /var/tmp, is left untouched.
    • Guardian stderr is drained by a thread while the guardian runs, so a guardian that logs past the pipe's buffer never blocks.
  • MINOR-C (btrfs subvolumes).

    • The seen key holds the device again, beside the inode number and the keyed handle digest.
    • Directories on another device of the same mount, such as subvolumes a payload created, are walked instead of only being closed off.
  • Notes.

    • The incomplete paths now log: unknown mount ID, no random key, and a quarantine that cannot be reopened (note 1).
    • An unknown mount ID for an entry, other than ENOENT, makes the purge run again instead of skipping (note 2).
    • The SipHash key is 128 random bits, and tests/purge_siphash_check.c checks the implementation against eleven reference vectors (note 3).
    • Deferred directories keep the quarantine flag of where they were met (note 5).
    • The seen table is capped at 2^20 slots of 32 bytes.
  • MINOR-B (mounts). Every purge, the startup ones included, now runs in a child that unshares a mount namespace and makes it private (without that, it detaches nothing).

    • It then detaches every mount below each root, deepest first, so a payload directory another user covered with a mount of their own is laid bare and removed. Removing it detaches that mount on the host too.
    • A mount that cannot be detached is still skipped.
    • The test covers a payload directory under a tmpfs another user mounted over it: it is gone after the startup purge, with no mount left on the host.
  • Recorded in Progress.md as open:

    • A cooperating local user who renames a payload directory behind the walk while it runs can still make it escape one purge. Removing that needs private temporary directories for payloads.
    • The owned-revisit fail-safe has no automated test.
  • Evidence. The root protected acceptance meets 43 of 43 expectations. The unprivileged suites, including the new SipHash check, pass, and the template builds.

  • Local evidence: .worktrees/agent-tools/stage206-protected.json and tenth-run-1.json, tenth-run-2.json (stage208-protected.json with the namespace).

U-20261030-25 · 2026-10-30 · Detach mounts by descriptor during the purge walk, and refuse payload btrfs subvolumes · #snapshot #agent #linux #security

  • An eleventh independent review found one major problem in U-20261030-24:

    • MAJOR-1. detach_under unmounted paths read from mountinfo.
      • A local user with FUSE could split a long mountinfo line, so an attacker-chosen mount source was read as a mount point.
      • The path could then route through a symlink, so /dev, /run or /proc was detached in the purge namespace.
      • Whole roots and the SysV IPC purge were then skipped while the purge reported clean.
      • One undetachable mount or 64 extra mounts also undid the cover-mount fix.

    It also raised:

    • MINOR-1: the copy of the host's mounts was private, not a slave;
    • MINOR-2/3: payload subvolumes could delay or taint a slice;
    • MINOR-4: other IDs' read-only snapshots could taint every slice;
    • MINOR-5: no test checked that the host's mounts survive;
    • notes on silent paths and the startup sleep.
  • Mounts.

    • detach_under and the mountinfo parsing are gone. A walk that meets an entry on another mount opens it with O_PATH|O_NOFOLLOW relative to the walked directory and unmounts that descriptor through /proc/self/fd. It does this up to 16 stacked layers, then goes on with what lies beneath.
    • No path anyone else wrote is resolved. A mount it cannot detach is logged and makes the purge run again.
    • Every root and the three /proc/sysvipc tables are opened before anything is detached. A table that cannot be opened, other than one absent from the kernel, makes the purge run again.
    • The namespace is MS_REC|MS_SLAVE, so the host's unmounts still reach it and it pins nothing.
  • Subvolumes.

    • The service filter, inherited by payloads, refuses BTRFS_IOC_SNAP_CREATE, _SUBVOL_CREATE, their _V2 forms and _SUBVOL_SETFLAGS with EPERM.
    • A directory on another device of the same mount is entered only when a payload owns it; another ID's subvolume is logged and left.
  • Smaller fixes.

    • Manifests may name at most 16 purge roots.
    • The remaining silent paths now log: the root walk failing, every quarantine pass used, a mount left, an entry whose mount is unknown, and a purge running in the guardian with mounts skipped.
    • The synchronous startup purge no longer sleeps when it is incomplete.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.

    • A tmpfs another user mounted over a payload directory is removed with it.
    • The host still lists the bind mounts at the window and loop paths, and the file behind the window survives.
    • The probe answers EPERM to BTRFS_IOC_SUBVOL_CREATE and _SETFLAGS; the control before the filter answers ENOTTY. FIONREAD still works.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage210-protected.json and eleventh-run-1.json, eleventh-run-2.json.

U-20261030-26 · 2026-10-30 · Read mount IDs without asking the filesystem, so other users' FUSE mounts are detached · #snapshot #agent #linux #security

  • A twelfth independent review found the descriptor-based detach of U-20261030-25 sound, and the open-first ordering, the slave namespace and the subvolume ioctl filter correct, with exact BPF arithmetic. It found:
    • MAJOR-1. The mount ID was read with a statx that asks the filesystem.
      • Another user's FUSE mount without allow_other (sshfs, an AppImage, or one whose daemon is gone) refuses root that getattr with EACCES.
      • So nothing was detached, and every purge reported incomplete: no slice was ever handed out.
      • The 16-layer cap was a second static lever.
    • MINOR-1. Another ID's subvolume, now not entered, was missing from the README's escape list.
    • MINOR-2. The purge-root limit carried the client limit's comment, and a clamp of the roots list did not mark the purge incomplete.
  • Mount IDs. mount_of calls statx with an empty request mask and AT_STATX_DONT_SYNC.
    • FUSE answers that even for a process it does not allow.
    • No request reaches a daemon, so one that never replies cannot stall the purge.
    • The kernel names the mount all the same.
  • Stacked mounts. These are detached until none is left: each detach removes one of a namespace's finite mounts, bounded at the kernel's default fs.mount-max.
  • Docs and limits. The README lists another ID's subvolume as an escape that needs that ID's leave. The header comments are fixed, and a clamped roots list marks the purge incomplete.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.
    • The new test mounts two FUSE filesystems for user 65534, without allow_other, and closes their device at once, so the daemon is gone. A plain stat by root on such a mount fails with EACCES, as verified separately.
    • The one covering a payload directory is detached in the purge namespace; the directory and its file are removed.
    • The one on that user's own directory in /tmp is detached there too, and every slice is still handed out. The host keeps that mount.
    • The unprivileged suites pass, and the template builds.
  • Cold-recovery test race. One background run failed orphans_survive_crash.
    • A service that sees its guardian killed drains and kills its helpers, and there it did so before the test killed the service.
    • The test now freezes the epoch's cgroup first and thaws it after both kills (SIGKILL still reaches frozen tasks).
    • The next three runs met 43 of 43.
  • Local evidence: .worktrees/agent-tools/stage214-protected.json and twelfth-run-1.json to twelfth-run-3.json.

U-20261030-27 · 2026-10-30 · Read mount IDs from fdinfo, and kill purge children that stop making progress · #snapshot #agent #linux #security

  • A thirteenth independent review confirmed the twelfth review's findings fixed for a healthy FUSE root inode. It found:
    • MAJOR-1. fuse_getattr answers EIO for a root inode the kernel marked bad, before it looks at the request mask. An ordinary user can get there by having their own daemon answer their own stat with an invalid size, then exiting. Every purge then stayed incomplete and no slice was handed out. The docs also overclaimed that nothing was asked of the filesystem.
    • MINOR-1. A purge child had no deadline. A live user with allow_other could hang it on a FUSE request.
    • MINOR-2. The cold-recovery test did not check that the epoch thawed.
  • Mount IDs. mount_of opens the entry with O_PATH|O_NOFOLLOW, which neither opens nor stats it. It then reads mnt_id from /proc/self/fdinfo/<fd>, the kernel's record of the descriptor, with no inode operation.
  • Stall watch.
    • Each purge child bumps a heartbeat counter in memory shared with the guardian, once per directory entry and per detach.
    • The guardian checks every 5 seconds: in the main loop, and while it waits for a startup purge.
    • A child whose heartbeat stood still for a minute is SIGKILLed, and its slice is purged again rather than tainted.
    • A purge that is merely long keeps beating and is never cut short, so a large static tree cannot turn this into a denial of service.
  • Tests.
    • The harness now makes a FUSE mount for user 65534 whose root inode is bad. Its small daemon answers INIT and the owner's GETATTR with size 2^63 (so the owner's stat gets EIO), then closes the device.
    • A probe on that mount showed statx with an empty mask failing with EIO, as the earlier code would have, while fdinfo still names the mount.
    • The purge detaches it and removes the payload directory beneath.
    • The cold-recovery scenario now requires the thaw too.
    • The stall watch has no automated test yet; that is recorded in Progress.md.
  • Correction (U-20261030-28). The claim that a child stuck in one call is always killed and run again overstated it. A FUSE request its daemon has already read ignores SIGKILL; see the next entry.
  • Evidence. The root protected acceptance meets 43 of 43 expectations. The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage216-protected.json and thirteenth-run-1.json, thirteenth-run-2.json.

U-20261030-28 · 2026-10-30 · Open purge entries without crossing mounts, and let stalled purges back off · #snapshot #agent #linux #security

  • A fourteenth independent review confirmed U-20261030-27's fixes and found no major problem. It raised:
    • MINOR-A. A user's new host mount reaches the slave namespace at once. In the gap between the mount check and the name-based calls after it (fstatat, openat, still_seen), those calls could cross into a FUSE root and send a request.
      • With user_allow_other, a daemon that read the request and never answers holds the child where SIGKILL does not reach.
      • At startup await_purge then waited forever.
    • MINOR-B. A slow but finite single call, such as getdents over a huge emptied ext4 directory, could be killed again on every run.
    • NOTE-1. A failed fdinfo read could look like "entry gone".
    • NOTE-3. The test matched a localized error string.
  • Opening without crossing mounts.
    • Each entry is opened exactly once with openat2(O_PATH|O_NOFOLLOW, RESOLVE_NO_XDEV); everything after that uses the descriptor.
    • EXDEV means a mount sits on the entry. That mount is detached in the purge's namespace, by its root's descriptor, and the entry is opened again.
    • A directory is walked through openat(fd, "."), which never follows a mount.
    • still_seen and the close-off use the same opener.
    • No filesystem but the walked one is ever asked anything, and the fdinfo reads are gone.
  • Stalls.
    • The stall allowance is a minute, doubled after each stall of the same slice in a row, up to 64 minutes, and reset when a purge ends by itself.
    • A startup purge killed for a stall that still has not ended after 30 seconds is handed to the main loop, which reaps it whenever it ends. The slice waits for it, but the guardian goes on.
  • Tests and docs.
    • The test's stat runs with LC_ALL=C.
    • The README now says that a child stuck where no signal reaches it keeps its slice until it ends.
    • U-20261030-27 carries a correction.
  • Evidence. The root protected acceptance meets 43 of 43 expectations, with every mount scenario (bind loop, window, tmpfs cover, dead and bad-root FUSE) as before. The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage218-protected.json and fourteenth-run-1.json, fourteenth-run-2.json.

U-20261030-29 · 2026-10-30 · Re-detach mounts placed during the purge walk, and purge message queues through a detached mqueue mount · #snapshot #agent #linux #security

  • A fifteenth independent review verified U-20261030-28's fixes and found no major problem; it judged that this component would not block the gate. It raised:
    • MINOR-1. still_seen read EXDEV as "moved by another ID".
      • A live user mounting on a payload directory while the walk emptied it made the purge skip that directory and report clean.
      • The README's "a mount it cannot detach makes the purge run again" was false there.
    • MINOR-2. POSIX message queues were reached only through /dev/mqueue. Where the host had no mqueue mounted there, a payload's queue outlived it silently.
    • NOTE-1. The new quarantine was opened by name.
    • NOTE-2. Two edge cases where await_purge still blocks.
    • NOTE-3. Docs overstated "opened once", and the stall cap read "an hour" for 64 minutes.
  • Mounts during the walk. still_seen and the close-off open the entry with open_bare. A mount placed on it meanwhile is detached first; one that stays makes the purge run again. The fresh quarantine is opened with open_here and reopened as ".".
  • Message queues. The /dev/mqueue root is now a fresh mqueue mount made with fsopen/fsmount, attached nowhere and reopened as a directory. It shows this IPC namespace's queues, whatever the host mounted, and leaves nothing behind. Without it the purge runs again.
  • Read errors. A failed readdir now makes the purge run again instead of ending a listing silently. That is how the first attempt at the mqueue root (a mount descriptor that cannot be read as a directory) was caught.
  • Docs and tracking. The README wording is corrected. NOTE-2's edge cases, and the untested stall hand-off, are recorded in Progress.md.
  • Evidence. The root protected acceptance meets 43 of 43 expectations.
    • A message queue that a payload ID made and left, with a message in it, is gone after the startup purge, on a WSL host with no /dev/mqueue.
    • Every mount scenario passes as before.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage221-protected.json and fifteenth-run-1.json, fifteenth-run-2.json.

U-20261030-30 · 2026-10-30 · Start helpers with no core dump, and keep purges completing without message queues · #snapshot #agent #linux #security

  • A sixteenth independent review verified U-20261030-29's fixes and found no major problem left in the purge code itself. It found:
    • MAJOR-1 (beside the purge). Helpers could dump core.
      • On systemd-coredump hosts the crashing UID gets a read ACL on the core.
      • The next helper with the same ID could read an earlier helper's whole memory image, out of the purge's reach since the file is root's.
    • MINOR-A. A kernel without POSIX message queues, or a guardian whose confinement filters the mount API, made every purge incomplete for good.
    • MINOR-B. journald's default per-UID journal files keep what one helper logs, readable by the next with that ID.
    • Notes. Notes on the source header and README wording, and on the queue test's error handling.
  • Core dumps. child_protected_credentials sets RLIMIT_CORE to 0, soft and hard, before exec, so the helper cannot raise it.
  • Message queues without the mount API.
    • fsopen failing with ENODEV means the kernel has no message queues, so there are none to purge.
    • Any other failure falls back to /dev/mqueue, if that is the mqueue filesystem; otherwise the purge runs again.
    • The README's requirements name the mount API, and journald without per-UID files (SplitMode=none or volatile storage).
  • Docs and tests.
    • The purge header and the README's summary now say what is removed (/run/lock and message queues included) and point to the listed escapes.
    • The queue test checks ENOENT exactly, loads libc before forking, and adds a queue of another ID that must stay.
    • Untested paths are recorded in Progress.md.
  • Evidence. The root protected acceptance meets 44 of 44 expectations.
    • Payload processes show Max core file size 0 0.
    • The payload's queue goes; user 65534's queue stays.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage223-protected.json and sixteenth-run-1.json, sixteenth-run-2.json.

U-20261030-31 · 2026-10-30 · Purge /var/crash by default, and warn about unknown core_pattern handlers · #snapshot #agent #linux #security

  • A seventeenth independent review verified U-20261030-30's fixes and found no major problem. It judged that this component could open the gate once its MINOR-1 was fixed or documented.
    • MINOR-1. A pipe core_pattern handler receives a crashed helper's image whatever its core limit. apport writes a report, core included, owned by the crashing UID to /var/crash, which was not a default purge root.
    • MINOR-2. The new message-queue fallback branches had no test and were not recorded.
    • Notes. A stale comment, the journald wording, one unchecked assumption, the scope of purge roots, and an over-long line.
  • Crash reports. /var/crash is a default purge root. An absent directory is skipped; an existing one is root's and sticky, as open_root requires. This also closes plain files a payload writes there.
  • core_pattern. At startup the guardian reads kernel.core_pattern and logs a warning for a pipe to a handler other than systemd-coredump or apport. The README states the requirement and says what the zero core limit actually guarantees.
  • README requirements.
    • Every directory payload IDs can write must be a default or manifest purge root.
    • The journald requirement now names coredump metadata.
    • Where the mount API is refused, /dev/mqueue must show the guardian's own IPC namespace.
  • Recorded as open in Progress.md.
    • The three message-queue fallback branches have no automated test.
    • Installed-host acceptance must check the host requirements; the guardian checks only the core_pattern case.
  • Evidence. The root protected acceptance meets 44 of 44 expectations.
    • A payload-owned crash report in /var/crash, created by the test on this WSL host, is gone after the startup purge.
    • This host's core_pattern pipes to /wsl-capture-crash, an unknown handler, so the warning applies here.
    • The unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage225-protected.json and seventeenth-run-1.json, seventeenth-run-2.json.

U-20261030-32 · 2026-10-30 · Close the eighteenth review's notes on crash handlers, roots and line lengths · #snapshot #agent #linux #security

  • An eighteenth independent review verified every finding of the seventeenth fixed or documented. It found no MAJOR or MINOR, and judged that the production gate could open on the basis of this component; installed-host acceptance stays a separate, open condition. It left seven notes, all closed here.
  • Crash reports.
    • The README says that a crash report its handler finishes only after the reclaim purge stays until that slice's next purge (NOTE-1).
    • Its list of purged roots now includes /var/crash (NOTE-3).
  • core_pattern check (NOTE-2). The handler is judged by the base name of its path (systemd-coredump, apport), not by a substring. A socket pattern (@) and an unreadable pattern are warned about too.
  • Tests (NOTE-4, NOTE-5).
    • The crash report is checked right after the startup purge.
    • /var/crash is in the payload-leftover sweep.
    • The report is always unlinked afterwards.
  • Untrusted roots (NOTE-6). A default purge root that exists but fails the trust check (not root's, or writable without the sticky bit) is logged.
  • Line lengths (NOTE-7). The seven older C lines over 120 characters are wrapped; no line under native/owner_service/src exceeds 120 (the tests still have some, recorded in Progress.md).
  • Evidence. The root protected acceptance meets 44 of 44 expectations:
    • the report is gone at startup;
    • the warning appears for this host's /wsl-capture-crash handler;
    • the unprivileged suites pass, and the template builds.
  • Local evidence: .worktrees/agent-tools/stage227-protected.json and eighteenth-run-1.json.

U-20261030-33 · 2026-10-30 · Run the purge again for roots that exist but cannot be opened, and keep Progress.md to open items · #snapshot #agent #linux

  • A nineteenth independent review verified U-20261030-32. It found the wrapped lines purely cosmetic and warn_core_pattern correct, and found no MAJOR or MINOR. It left five notes:
  • Untrusted or unopenable roots.
    • open_root reports a failed trust check as EPERM.
    • A purge root that exists but is not trusted is logged and skipped.
    • One that exists but could not be opened for another reason is logged with its error and makes the purge run again, rather than counting as absent.
  • core_pattern wording. The comment covers socket patterns, and the changelog says the handler is judged by the base name of its path.
  • Test. The acceptance asserts the startup warning whenever the host's core_pattern pipes to a handler other than systemd-coredump or apport.
  • Docs.
    • U-20261030-32's line-length claim is scoped to src/.
    • Progress.md's owner-service item is rewritten to keep open items only; the review history is here. The test files over 120 characters or 750 lines are recorded there.
  • Evidence. The root protected acceptance meets 44 of 44 expectations, with the warning asserted on this host's /wsl-capture-crash handler. The unprivileged suites pass, and the template builds. Local evidence: .worktrees/agent-tools/stage229-protected.json.

U-20261030-34 · 2026-10-30 · Anchor manifest purge roots, and keep the purge's trust verdict out of errno · #snapshot #agent #linux

  • A twentieth independent review of U-20261030-33 found no MAJOR or MINOR and judged that the commit fails closed better than before. It left seven notes:
  • Manifest purge roots (NOTE-1). guardian_manifest_valid now requires every directory above a manifest purge root to be root's and not writable by others. The sticky exception first written here was dropped in U-20261030-35.
  • Trust verdict (NOTE-2). open_root reports a failed trust check through an out-parameter. A real EPERM, from an access-control agent say, now makes the purge run again rather than count as an untrusted, skipped root.
  • Absent roots (NOTE-3). Only ENOENT or ENOTDIR from lstat count as absent. Any other failure is logged and runs the purge again.
  • Tests (NOTE-4, NOTE-5).
    • Guardian output keeps its first 4,000 characters with its last 60,000, so the startup warning is never cut.
    • core_pattern is read with only its newline removed.
  • Progress.md (NOTE-6, NOTE-7).
    • The over-long-lines TODO covers everything outside src/, build.sh included.
    • One line lists the known limits not in the service README.
    • The history pointer now starts at U-20261029-23.
  • Evidence. The root protected acceptance meets 44 of 44 expectations, the unprivileged suites pass and the template builds (.worktrees/agent-tools/stage230-protected.json). The anchoring check has no dedicated test yet: the protected manifests list no purge roots.

U-20261030-35 · 2026-10-30 · Anchor purge roots without the sticky exception, and recheck what they resolve to · #snapshot #agent #linux

  • A twenty-first independent review found no MAJOR. It found one MINOR and five notes:
    • MINOR-1. U-20261030-34 accepted a sticky, world-writable ancestor. In a sticky directory such as /tmp, another user cannot remove root's entry but can create it while it is missing. A manifest root /tmp/app could then be made a file, holding every purge incomplete, or a link to /. The commit's own claim was false for a configuration the README allowed.
    • Notes. A root reached through a symlink was not anchored at its target. A dangling-link root counted as present, so the purge ran again forever. A failed fstat counted as untrusted. A refused manifest did not say which root failed.
  • Anchoring.
    • guardian_path_anchored, a static inline in guardian.h, requires "/" and every directory above a path to be a real directory, root's, and writable by no one else, sticky or not.
    • The manifest check uses it and names the root it refuses.
    • open_root applies it to what every root, default or manifest, resolves to, at each purge; a root that fails it is untrusted and skipped with a log line.
  • Smaller fixes.
    • A dangling-link root counts as absent.
    • A failed fstat keeps its errno and runs the purge again, rather than counting as untrusted.
  • Docs. The README says ancestors must be real directories that exist when the guardian starts. The CHANGELOG and U-20261030-34 are corrected.
  • Evidence. The root protected acceptance meets 44 of 44 expectations (default roots, including /var/crash, /dev/shm and /run/lock, pass the new check on this host). The unprivileged suites pass, and the template builds. Local evidence: .worktrees/agent-tools/stage231-protected.json.

U-20261030-36 · 2026-10-30 · Judge manifest roots by what they resolve to, and test the anchoring · #snapshot #agent #linux

  • A twenty-second independent review found no MAJOR. Its one MINOR was in the docs: Progress.md claimed three clean review rounds in a row, though the twenty-first had a MINOR. It also left six notes.
  • The gate record (MINOR-1). Progress.md now says which rounds were clean. It holds the "does not block the gate" conclusion until a review of this commit comes back clean.
  • Untrusted before absent (NOTE-1). An untrusted root is always logged. Before, a leftover ENOENT could make it look absent and lose the line.
  • Manifest roots (NOTE-2). An existing manifest root is also judged by what it resolves to, so a link into a user's directory is refused at load instead of being skipped at every purge.
  • Docs and build.
    • The README calls a world-writable mount below a sticky directory unsupported (NOTE-3).
    • The manifest template says to keep _GNU_SOURCE first (NOTE-4).
    • The CHANGELOG wording reads "sticky or not" (NOTE-5).
  • Test (NOTE-6). tests/path_anchored_check.c, run by the unprivileged suites, checks guardian_path_anchored on /usr/bin, /tmp/x, /proc/self/x, a relative path and /.
  • Evidence. The root protected acceptance meets 44 of 44 expectations. The unprivileged suites pass, the new check included, and the template builds. Local evidence: .worktrees/agent-tools/stage232-protected.json and, for the unprivileged suites, stage233-unprivileged.json.

U-20261030-37 · 2026-10-30 · Record the clean review of the owner service · #snapshot #agent #linux

  • A twenty-third independent review of U-20261030-36 found no MAJOR and no MINOR, and judged that the production gate could open on the basis of this component. Installed-host acceptance and the other gate conditions are outside that verdict and stay open in Progress.md.
  • Progress.md now records that conclusion.
  • The review's four notes are handled in docs only:
    • The CHANGELOG wording says that only an existing manifest root is resolved at load.
    • The README asks for purge roots without a trailing slash.
    • Two load-time configuration mistakes that only show at purge time are recorded as open in Progress.md: a realpath loop, and a root that is a user's own directory. So is the missing fixture for the manifest purge-root checks.
  • The unprivileged suite results for U-20261030-36 are saved as .worktrees/agent-tools/stage233-unprivileged.json, path_anchored_check included.

U-20261030-38 · 2026-10-30 · Test the purge's fault paths and stall watch, close the manifest load gaps, and split the long test file · #snapshot #agent #linux #test

  • Earlier entries had deferred several items to Progress.md: untested fault paths, two blocking edge cases, two load-time gaps, an over-long test file and lines over 120 characters. All are done here.
  • Stall watch. await_purge no longer blocks forever:
    • Without a pidfd it watches the child by pid (waitpid WNOHANG) and kills it by pid.
    • When even a kill does not end such a child, its slice is tainted and the guardian goes on.
    • Without the shared heartbeat it kills only after a longer allowance (PURGE_UNWATCHED_NS).
    • The allowances can be shortened for acceptance builds.
  • Manifest load check. guardian_purge_roots_valid, split out of guardian_manifest_valid, also refuses a root:
    • whose realpath fails with anything other than ENOENT or ENOTDIR (a link loop);
    • or that resolves to a directory the purge would not trust (a user's own directory).
  • New acceptance programs.
    • tests/purge_watch_acceptance.c, unprivileged, runs the guardian's real watch code against a fake purge. It covers:
      • a stall that is killed and purged again;
      • a child beating for three seconds, never cut short;
      • a kill without effect, handed to the main loop and reaped later;
      • no heartbeat;
      • no pidfd;
      • no pidfd and no effective kill, which taints the slice.
    • tests/purge_roots_check.c covers the purge-root check. Unprivileged it checks /usr/share, an absent root, /tmp/app, a file, a relative path and a path through a link. As root it also checks a link into a user's directory, a user's own directory, a link loop and root's own directory, all staged under /run.
    • tests/purge_fault_acceptance.c, root, injects faults around the real purge, each in a forked child with the purge's own namespace. It covers:
      • a failed listing, so the purge runs again;
      • a tmpfs mounted over a payload directory while its parent is listed, which is detached and the directory removed;
      • a payload directory renamed behind the walk and listed again, so the purge runs again (tmpfs since 6.13 does not list it again, so the fixture replays the entry as ext4's hash order can);
      • the mount API refused three ways: ENODEV means no queues; with no /dev/mqueue the purge runs again; with /dev/mqueue mounted, a payload queue is purged through it.
    • The protected acceptance runs the last two as root and adds purge_fault_paths and purge_roots_refused.
  • Sizes. The guardian-handoff cases of service_authority_acceptance.c moved to tests/service_authority_handoff.h, leaving 683 lines. Every line over 120 characters in tests/ and build.sh is wrapped.
  • Progress.md. The deferred TODOs are removed. The live-rename escape, an accepted limit of the threat model that the service README already lists, is recorded as a known limit; the installed-host requirements stay open with the other gate conditions.
  • Evidence. The root protected acceptance meets 46 of 46 expectations. The unprivileged suites pass with the new programs, and the template builds. Local evidence: .worktrees/agent-tools/stage237-protected.json and stage237-unprivileged.json.

U-20261030-39 · 2026-10-30 · Close the twenty-fourth review's notes on the stall watch and the fault fixtures · #snapshot #agent #linux #test

  • A twenty-fourth independent review of U-20261030-38 found no MAJOR and no MINOR. It confirmed that the deferred items are delivered and their tests meaningful, and judged the gate open on the basis of this component. Its notes are closed here.
  • Guardian.
    • A purge child the guardian could not wait for (waitpid failing) now taints its slice instead of counting as a clean exit (N4).
    • Without the heartbeat, the allowance doubles after each stall in a row as it does with one, and the startup message says stalls are judged by time (N5).
    • The pid kill is guarded against 0 and -1 inside purge_check itself (N8).
  • Fault fixtures (N1, N2).
    • The hook matches a directory by device and inode.
    • Every fixture lives under a fresh mkdtemp directory only root can enter, and each step must succeed.
    • Files are made with O_CREAT|O_EXCL|O_NOFOLLOW and fchown, so a planted name or link can never be written through.
  • Watch and roots tests.
    • The watch test's cleanup polls with WNOHANG and relies on PDEATHSIG instead of a blocking wait (N3).
    • The roots test first removes the names a crashed run may have left, and always removes its temporary directory (N9).
  • Docs and known limits.
    • The CHANGELOG says the pid-based fallback also runs while serving when no pidfd can be had (N6).
    • N7, a dangling-link root whose target would be untrusted being skipped at purge time, is unchanged and already accepted.
  • Evidence. The root protected acceptance meets 46 of 46 expectations, all six fault scenarios and the four root cases included, and leaves no fixture behind. The unprivileged suites pass, and the template builds. Local evidence: .worktrees/agent-tools/stage239-protected.json and stage239-unprivileged.json.

U-20261030-40 · 2026-10-30 · Reset SIGCHLD at guardian start, and fall back to the pid watch when a pidfd cannot be polled · #snapshot #agent #linux #test

  • A twenty-fifth independent review of U-20261030-39 found no MAJOR and no MINOR, the third clean round in a row. It judged the gate open on the basis of this component. Its notes are closed here.
  • Guardian.
    • It resets SIGCHLD to its default at startup. A parent that left it ignored would otherwise let the kernel reap purge children before the guardian learns how they ended, and every slice would be tainted (N2).
    • A pidfd that cannot be polled is closed, and the child is watched by its pid, never waited on blind (N5).
  • Tests.
    • The watch test adds two cases:
      • the no-heartbeat allowance doubling after a stall in a row (N1);
      • a child the guardian cannot wait for, made by ignoring SIGCHLD, which taints its slice (N2).
    • The fault fixtures remove a half-made fixture (N4).
  • Docs. Progress.md's status sentence names this round (N3).
  • Evidence. The root protected acceptance meets 46 of 46 expectations, and the unprivileged suites pass with both new watch cases. The template builds. Local evidence: .worktrees/agent-tools/stage241-protected.json and stage241-unprivileged.json.

U-20261030-41 · 2026-10-30 · Test the poll fallback and the SIGCHLD reset · #snapshot #agent #linux #test

  • A twenty-sixth independent review of U-20261030-40 found no MAJOR and no MINOR, the fourth clean round in a row, and judged the gate open on the basis of this component. Its notes concern tests and one wording, and are closed here.
  • Wording (N1). U-20261030-40 now says it was the third clean round, not the second.
  • poll fallback (N2). The watch test makes poll on the pidfd fail once. A stalled child is still killed by its pid and purged again, and a clean child still settles clean.
  • SIGCHLD reset (N3).
    • The cold-recovery scenario restarts the guardian with SIGCHLD ignored, as a careless parent might start it.
    • Its startup purges must settle without tainting a slice. Without the reset, every one would end in ECHILD and taint.
  • Fixture cleanup (N4). The fault fixtures clean up only inside a fixture root they made.
  • Evidence. The root protected acceptance meets 46 of 46 expectations. The restarted guardian logged no tainted slice. The unprivileged suites pass with both poll-fallback cases. Local evidence: .worktrees/agent-tools/stage242-protected.json and stage242-unprivileged.json.

U-20261030-42 · 2026-10-30 · Give each epoch private temporary roots, and accept the installed service on a WSL host · #snapshot #agent #linux #test

  • Private epoch roots. This closes the last known purge escape: another local user renaming a payload directory behind the walk while it runs.

    • The guardian starts each epoch's service with CLONE_NEWNS | CLONE_NEWIPC. Before it drops root, the service's child (guardian_private_linux.c) makes the host's mounts a slave and mounts a fresh tmpfs (mode 1777, nosuid, nodev) over /tmp, /var/tmp, /dev/shm, /run/lock, /var/crash and every manifest purge root that exists. It also mounts a fresh mqueue on /dev/mqueue.
    • The helpers inherit these namespaces. What a helper leaves in them is out of other users' reach and goes with the epoch when its last process is killed.
    • The purge still walks the host's roots, for anything a helper put where these mounts do not reach.
  • Connections from a payload ID. A payload range's mount namespace is now its epoch's own.

    • The guardian checks the range's user, pid and cgroup namespaces against the manifest as before.
    • It routes the connection only if the peer shares the mount namespace of the service whose epoch runs its slice (peer_shares_mount_namespace); anything else is dropped. The client account's check is unchanged.
  • Tests.

    • The session scenario reads the helper's leftovers through /proc/<pid>/root and its IPC namespace.
    • The new payload_roots_private checks that the epoch has its own mount and IPC namespaces, that its /tmp is another filesystem, and that the helper's file and SysV segment are not on the host.
    • The siblings scenario stages host leftovers of a payload ID itself (a file, a SysV segment, a 300-level chain with 8 MiB at its bottom, a directory another ID wrote into) for the startup purge to take.
    • outside_epoch_refused connects with a payload ID from the host's namespace and is turned away.
  • Installed-host acceptance. The new tests/installed_host_acceptance.py runs as root on a disposable host.

    • It follows the service README's install steps with the example manifest's values filled in.
    • It compares the installed binaries and binding file against the build: same content, root-owned and unwritable, nothing else installed.
    • It starts the guardian and checks the listener and the epoch's private roots.
    • The package's client, run as the client account, has its lease refused by the closed gate. Another account is refused at the socket.
    • The guardian stops cleanly and everything installed is removed again.
  • The WSL host's requirements. Run in the podman-webrunner-validation distro (Fedora 44, kernel 6.18.33.2-microsoft-standard-WSL2, x86_64), the acceptance met all 11 installation expectations. The host meets two of the README's requirements: no journald runs, and the mount API reaches mqueue. It misses two:

    • kernel.core_pattern pipes to /wsl-capture-crash. The guardian warns, as designed.
    • /mnt/c, /mnt/d, /mnt/wsl and /mnt/wslg can be written by every account, and they are not purge roots. A file nobody wrote to drvfs shows up owned by uid 1000.

    The service README now requires every directory a helper can reach and write to be a purge root, and says how to meet that under WSL. Whether to change this distro's settings and run again is recorded in Progress.md as a DECIDE.

  • Evidence.

    • The root protected acceptance meets 48 of 48 expectations, and its cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage246-protected.json, stage247-installed.json and stage247-unprivileged.json.

U-20261030-43 · 2026-10-30 · Close the twenty-seventh review of the private epoch roots · #snapshot #agent #linux #test

  • A twenty-seventh independent review of U-20261030-42 judged the namespace design sound:
    • helpers cannot leave their epoch's mount namespace;
    • propagation is a slave of the host's mounts;
    • the mounts are made before the service drops root. It found one MAJOR in the new acceptance script and seven MINOR in it, the tests and the docs. All are fixed here.
  • Acceptance script removed pre-existing installs (MAJOR). On a host that already had the service, the "not a fresh host" refusal still ran the removal and deleted the real installation.
    • installed_host_acceptance.py now records each path and change it makes and reverses only those.
    • It also does README step 4 itself: it enables pids and memory at the cgroup root if absent, and switches them off again afterwards.
  • The outside-epoch test proved nothing (MINOR). Garbage bytes were closed with or without the new route check. The scenario now sends the same well-formed nested open twice, as the payload ID of a running helper:
    • from the epoch's own mount namespace (nsenter -m), the service answers it with a refusal;
    • from the host's, the guardian drops it before any service sees it.
  • Released roots (MINOR). The second-overlap scenario no longer counts the host's absent files as purged.
    • Before H1 closes, it writes a randomly named marker into its epoch's private /tmp. H1's helper must see the marker and the host must not.
    • Once the epoch is reclaimed, no process may still see the marker through its root.
    • A device-number check was tried first and failed: the next epoch's tmpfs reused the freed number.
  • core_pattern expectation (MINOR). The acceptance script now expects a warning exactly where the guardian gives one: a socket, or a pipe to a handler other than systemd-coredump or apport.
  • A root missing at epoch start (MINOR). It is covered from the next epoch on, and the purge walks it on the host until then. The service README and the source say so.
  • Mode and owner of private roots (MINOR). Each tmpfs now takes the mode, uid and gid of the host's directory, instead of 1777 for all. A root-only /run/lock stays root-only. The README says that lock files in an epoch's /run/lock exclude only that epoch's processes.
  • Refusal checks (MINOR). The installed client must meet the closed gate's unavailable answer, and another account the socket's PermissionError.
  • Cleanup claim (MINOR). The README and the source now say that an epoch's roots are gone with its last process unless a helper handed a descriptor into them to a process outside the epoch.
  • Notes.
    • The service's mount-namespace fd stays open until the peer is compared.
    • A payload ID routes only to an epoch whose slice is its own.
    • guardian_forward says it is for tests only.
    • A listener path under a private root is refused at manifest validation, and purge_roots_check covers it.
    • A private root the guardian cannot make is logged with its errno.
    • Host SysV segments are matched by ID and payload owner.
    • The siblings scenario lost its unused parameter.
    • Further fixes to the acceptance script:
      • its evidence string is now host-neutral;
      • the work directory, which holds the installation's secret, is removed in finally;
      • parse errors are reported;
      • one file handle is closed.
    • The host-object helpers moved to tests/protected_objects.py, so protected_run.py is shorter than before U-20261030-42 (1426 lines, against 1427).
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations, and its cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11, and the host's cgroup controllers end as they began.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage257-protected.json, stage257-installed.json and stage257-unprivileged.json.

U-20261030-44 · 2026-10-30 · Close the twenty-eighth review of the private epoch roots · #snapshot #agent #linux #test

  • A twenty-eighth independent review of U-20261030-43 found no MAJOR and confirmed every earlier fix:
    • the acceptance script removes only what it made;
    • the outside-epoch and released-root tests fail without the behaviour they claim;
    • the slice check cannot drop a legitimate helper. It found two MINOR and some notes, which are closed here.
  • Roots compared as written (MINOR). The listener check compared purge roots as written, but each epoch mounts over the resolved root. A root written with a trailing slash, or one that is a symbolic link, could hide the listener and pass.
    • guardian_private_roots_hide_nothing compares each root as written (trailing slashes dropped) and as resolved.
    • It checks both the listener and the service executable, so a root such as / or /usr/libexec that would hide the service is refused.
  • Mount flags (MINOR). Each private tmpfs is now noexec where the host's mount is. Its pages count against the epoch's memory limit, which the README now says.
  • Notes.
    • The purge takes its default roots from guardian_private_root() (the message queues come last), so the list the mounts use and the list the purge walks cannot diverge.
    • A timeout or a failed drop in the outside-epoch probe, and a helper that died before its marker was written, fail an expectation instead of aborting the run.
    • The acceptance script reports any failure.
    • The probe moved to tests/protected_objects.py. protected_run.py is now 1414 lines, and U-20261030-43 quotes its measured size.
    • nsenter -G drops supplementary groups in the util-linux used here. The route check is redundant for a reclaimed epoch's helper, which already fails the mount-namespace check.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations, and its cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks, including the new purge_roots_check cases (trailing slash, /, a root over the executable).
    • Local evidence: .worktrees/agent-tools/stage260-protected.json, stage260-installed.json and stage260-unprivileged.json.

U-20261030-45 · 2026-10-30 · Close the twenty-ninth review of the private epoch roots · #snapshot #agent #linux #test

  • A twenty-ninth independent review of U-20261030-44 found no MAJOR and one MINOR. Its notes are closed here too.
  • A linked executable (MINOR). The check resolved only a path's directory, so a service executable that is a symbolic link into a purge root passed, and every epoch then failed to start. hides() now also compares the path as resolved, following the link. Paths that do not exist yet, such as the listener's, still go through their resolved directory.
  • What is checked (notes).
    • The same check now covers each policy's executable and working directory, and refuses relative paths and roots.
    • guardian_private_epoch runs it again at every epoch start, against the host as it is then. A root made since as a link over a needed path stops that epoch rather than hiding the path.
  • Mount flags (note). Each private tmpfs also takes the host mount's nosymfollow and read-only flags.
  • Tests (notes).
    • purge_roots_check covers:
      • a root missing and written with a trailing slash, which only the stripping can catch;
      • a relative listener;
      • as root, a root that is a link to /usr/libexec;
      • as root, an executable that is a link into /usr/bin, refused under that root and accepted under another.
    • The protected session now checks that each private root keeps the host mount's noexec and read-only flags. This host's /run/lock is noexec, so the check can fail.
  • Root list (note). guardian_private_root() asserts at compile time that its list has one name per root. A shorter list can no longer hand the purge a NULL.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 6 of 6, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage263-protected.json, stage263-installed.json and stage263-unprivileged.json.

U-20261030-46 · 2026-10-30 · Close the thirtieth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirtieth independent review of U-20261030-45 found no MAJOR. It found three MINOR and some notes, which are closed here.
  • A policy working directory equal to a root (MINOR). A policy that ran in /tmp, or in a manifest purge root, was refused after U-20261030-45, so a manifest that started before no longer did. A working directory may now be a root itself, in which case the epoch starts the helper in its empty tmpfs. Only a path below a root is refused.
  • The linked-executable case depended on host packaging (MINOR). It linked to /usr/bin/true, which is busybox on some hosts. The case now makes its own root-owned target under /run.
  • An over-long README line (MINOR) is reflowed.
  • Notes.
    • No denial of service through policy paths. Each epoch start now checks again only the listener and the service executable. A policy path that another local user could reach therefore fails only its own helper's launch; it can no longer stop every epoch.
    • Mount flags as a function. The flag mapping is now guardian_private_mount_flags() in guardian.h. purge_roots_check tests it directly: noexec, nosymfollow and read-only are copied, and nosuid and nodev are always set. Before, no host root here was read-only or nosymfollow, so the protected session alone could not show those copies.
    • Read-only roots. The README now says that a read-only host root gives the epoch an empty read-only tmpfs.
    • Policy checks tested. New purge_roots_check cases:
      • a policy run in / or in /tmp is accepted;
      • a policy run in /tmp/work, a policy executable under /tmp, and a relative or missing path are refused;
      • the epoch-start check never looks at policies.
    • /var/crash. The protected session's flag comparison now includes it where it exists.
    • U-20261030-45's link case. That entry listed the root that is a link to /usr/libexec among its new cases. It is a regression case: the code already resolved roots before that change.
    • CHANGELOG wording. It now says the flags are the host mount's.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 6 of 6, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage266-protected.json, stage266-installed.json and stage266-unprivileged.json.

U-20261030-47 · 2026-10-30 · Close the thirty-first review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-first independent review of U-20261030-46 found no MAJOR and one MINOR. Its notes are closed here too.
  • A working directory below a linked root (MINOR). U-20261030-46 stopped comparing a working directory's resolved parent with the roots. That comparison could never refuse a directory equal to a root, but it was the only one to catch a directory not made yet below a link to a root, such as /var/lock/app where /var/lock links to /run/lock.
    • hides() now applies it to every path again. A resolved parent inside a root always means the path lies below it.
    • A new root-only case links /run/autocontrol-lock-link to /run/lock and refuses a working directory below the link. The case fails without the comparison.
  • Notes.
    • Trailing slashes. Paths, like roots, now have trailing slashes dropped, so a working directory written as /tmp/ is accepted like /tmp. A new case covers it.
    • _GNU_SOURCE. guardian.h now stops the build with a clear message if _GNU_SOURCE is not defined first: it uses GNU names such as ST_NOEXEC. Every file that includes it, the manifest template too, already defines it.
    • Policy paths at epoch start (accepted trade-off). Each epoch start still rechecks only the listener and the service executable. A policy path hidden later by a root that root itself makes fails that helper's chdir or execve. A file can be planted there only if the host's directory is already writable by everyone.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 7 of 7, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage268-protected.json, stage268-installed.json and stage268-unprivileged.json.

U-20261030-48 · 2026-10-30 · Close the thirty-second review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-second independent review of U-20261030-47 found no MAJOR and one MINOR. Its notes are closed here too.

  • Only one missing level was caught (MINOR). U-20261030-47 compared a path's resolved parent alone. That missed:

    • a working directory two levels deep and not made yet below a link to a root, such as /var/lock/app/work;
    • a link whose target in a root does not exist yet.

    Policies are not rechecked at epoch start, and another payload ID could create such a directory first in a world-writable private root. The helper would then start in a directory it did not make. U-20261030-47's "the only one to catch" held for one level only.

    • hides() now walks every prefix of the path, the path itself first, and resolves each one that exists. A resolved prefix inside a root puts the path inside it. Only the whole path of a working directory is compared strictly, so a working directory may still be a root.

    • A prefix that is there but does not resolve, such as a dangling link or a loop, is refused: it could resolve into a root later.

    • New root-only cases:

      • a working directory one and two levels below a link to /run/lock;
      • a dangling link into /run/lock.

      They run only where /run/lock resolves, and they use a leaf name the host will not have. root_cases is now 8.

  • Template comment (note). The manifest template now says that guardian.h uses GNU names and refuses to build without _GNU_SOURCE.

  • Evidence.

    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 8 of 8, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage270-protected.json, stage270-installed.json and stage270-unprivileged.json.

U-20261030-49 · 2026-10-30 · Close the thirty-third review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-third independent review of U-20261030-48 found no MAJOR and one MINOR. Its notes are closed here too.
  • A link chain through a root (MINOR). Each prefix was judged by its final realpath alone, so a chain that passes through a root and back out was accepted. An example is /srv/w, linked to /run/lock/a, which in turn links to /opt/work. In the epoch, /run/lock is an empty world-writable tmpfs, so another payload ID could create a first.
    • Comparing final results of realpath has now missed something three rounds in a row. hides() therefore resolves the path itself instead: walk_hides() goes component by component, as the kernel does, and follows at most 40 links.

    • It checks every name it visits: each directory on the way, each link, each name a link leads through, and, once a name does not exist yet, what lies below it as written.

    • Only the final name of a directory the epoch enters is compared strictly. What it cannot resolve counts as hidden: a path too long, a link loop, or a directory it cannot read.

    • New cases:

      • a root-only chain from /run/autocontrol-chain through /run/lock/autocontrol-hop to /usr, refused both as a working directory and as an executable path;
      • unprivileged, . and .. resolve as the kernel resolves them: /usr/bin/../bin/python3 in /./tmp is accepted, and /tmp/../tmp/work is refused.

      root_cases is now 9.

  • Refusal message (note). It now also says "or cannot be resolved".
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage272-protected.json, stage272-installed.json and stage272-unprivileged.json.

U-20261030-50 · 2026-10-30 · Close the thirty-fourth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-fourth independent review of U-20261030-49 found no MAJOR. It confirmed that walk_hides() follows Linux's own path resolution on every point it was asked about:
    • . and .., including .. at / and .. after a followed link;
    • relative and absolute link targets, an empty target, and trailing slashes;
    • which name the strict comparison falls on;
    • buffer sizes, the limit of 40 links, and termination. It also confirmed that no legitimate manifest is refused, including merged /usr, /etc/alternatives chains, an existing listener socket, and a working directory of /. It found two MINOR and some notes, which are closed here.
  • .. below a name not made yet (MINOR). A working directory such as /opt/new/../../tmp/w, with /opt/new missing, was compared as written and accepted. Once root makes /opt/new, the kernel resolves that path into /tmp. A .. in what lies below a missing name is now refused (climbs()).
  • The .. case did not test the walker (MINOR). /tmp/../tmp/work was already refused by the as-written check. It is replaced by:
    • /usr/../tmp/work, which only resolving .. places in /tmp;
    • /usr/autocontrol-absent/../../tmp/work, which covers .. past a gap. U-20261030-49's claim about its .. case was too strong.
  • Notes.
    • A readlink result that fills the buffer may be cut short, so it now counts as unresolvable.
    • The epoch-start message also says the path may not be resolvable.
    • The chain test's name in the host's world-writable /run/lock now carries the test's process ID. A name another user planted can no longer skip the case, and the test never deletes another user's file.
    • The README no longer says the resolution is exactly "as the kernel would", and it lists a .. below a name not made yet among what is refused.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind, in /run/lock either.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage274-protected.json, stage274-installed.json and stage274-unprivileged.json.

U-20261030-51 · 2026-10-30 · Close the thirty-fifth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-fifth independent review of U-20261030-50 found no MAJOR. It confirmed climbs() for every spelling it was asked about. It found two MINOR, which are closed here.
  • Spelling below a name not made yet (MINOR). Below a missing name, the rest of a path was compared as a string. Take a working directory /opt/app/./cache/w or /opt/app//cache/w, with a manifest purge root /opt/app/cache that does not exist yet. The working directory was accepted, and once root made the root, every later epoch would cover it. (Corrected in U-20261030-52: through manifest validation only the root's own spelling could slip by this way. The tail tidying is defence in depth.)
    • Paths and roots are now tidied before they are compared (tidy()): repeated and trailing slashes are collapsed, and . components dropped. The same applies to the part below a missing name.
    • A root written with .. is refused, since where it leads is not known.
    • New unprivileged cases against a manifest root that does not exist yet:
      • ./ and // in the working directory are refused;
      • ./ and // in the root are refused;
      • a sibling directory is accepted;
      • a root written with .. is refused.
  • The test could delete another user's file (MINOR). The name it uses in /run/lock can be guessed from the process ID. If another user had made that name first, the test still removed it, and root ignores the sticky bit. It now removes the name only if it made it, so U-20261030-50's "never deletes another user's file" now holds.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind, in /run/lock either.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage276-protected.json, stage276-installed.json and stage276-unprivileged.json.

U-20261030-52 · 2026-10-30 · Close the thirty-sixth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-sixth independent review of U-20261030-51 found no MAJOR. It confirmed that tidy() is correct and memory-safe, and that every comparison now sees a tidied form on both sides. It found two MINOR about how the change was described and tested, which are closed here.
  • What could actually slip by (MINOR). Manifest validation anchors every manifest root first, and anchoring needs the root's parent to exist as a root-owned directory. The walker then visits the root by name. So the working-directory spelling that U-20261030-51 led with could not get past validation.
    • What could get past was the root's own spelling. While /opt/./x, /opt//x or /usr/../opt/x did not exist yet, a working directory such as /opt/x/w was missed by the string comparison.
    • That is now fixed by tidying the root and by refusing a root written with ... Tidying the part below a missing name is defence in depth.
    • U-20261030-51 now carries this correction.
  • A case that passed without the fix (MINOR). The walker had already skipped a // right after the missing name. The case now puts the // deeper (/usr/share/autocontrol-absent/sub//cache/w), where only tidying finds it.
  • tidy() precondition (note). It now leaves a relative name unchanged. Every caller refuses one, and rewriting one in place could write past its end.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage278-protected.json, stage278-installed.json and stage278-unprivileged.json.

U-20261030-53 · 2026-10-30 · Close the thirty-seventh review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-seventh independent review of U-20261030-52 looked at the whole path-hiding check, not only the change. It found no MAJOR: no path the check judges can end up under a root in a manifest that validation accepts, and the check is memory-safe. It found one MINOR, which is closed here.

  • Fixed arguments and environment were not judged (MINOR). Only a policy's executable and working directory were checked. Each of these points into a fresh, world-writable tmpfs inside the epoch, where any payload could create the name first:

    • a fixed argument such as /var/tmp/app/main.py;
    • an argument such as --cache=/tmp/cache;
    • an environment value such as PYTHONPATH=/opt/lib:/tmp/lib.

    names_hidden() now judges every absolute path that a policy's fixed arguments or environment name: the argument or value itself, what follows its first =, and each part of a : list. They are judged like a working directory, so a root itself is allowed (it is the epoch's own tmpfs) and anything below a root is refused. An interpreter that a script names on its #! line is not judged, and the README says so.

  • Notes.

    • New unprivileged cases cover a reachable root spelling. A root that is anchored but not made yet, written /usr//share/autocontrol-absent, is accepted, and a working directory below it is refused; only tidying finds it.
    • New unprivileged cases for arguments and environment:
      • a script under /opt and a PATH of /usr/bin:/bin are accepted;
      • a script under /var/tmp, --cache=/tmp/cache and a PYTHONPATH with one part in /tmp are refused;
      • /tmp itself, as an argument and as TMPDIR, is accepted.
    • Spellings with .. above a root, such as /tmp/../usr/bin/python3, are refused, as intended.
    • That policy paths are not rechecked at epoch start is unchanged, and recorded in U-20261030-47.
  • Evidence.

    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage280-protected.json, stage280-installed.json and stage280-unprivileged.json.

U-20261030-54 · 2026-10-30 · Close the thirty-eighth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-eighth independent review of U-20261030-53 found no MAJOR. It confirmed that names_hidden() parses safely, and that no legitimate manifest is refused. It found two MINOR and some notes, which are closed here.
  • Relative names (MINOR). Only absolute parts were judged. With a working directory of /, an argument tmp/app/main.py names /tmp/app/main.py. With a working directory that is a root, an empty or . part of PATH searches the epoch's shared tmpfs.
    • A relative part with a / is now judged joined to the policy's working directory.
    • In an environment value, an empty or . part means that working directory, and is refused when the directory is a root or lies in one.
    • An environment entry is judged by its value only, so PATH=/usr/bin is never read as a relative name. An argument is judged whole and after its first =.
    • Bare words are not judged: an option, a module name, or main.py alone.
  • Refusal message (MINOR). It now names fixed arguments and environment values too.
  • Scope (note). The README now lists exactly what is judged and what is not:
    • not judged: bare words, a second =, , lists, an option value attached as in -I/tmp/x, and a #! interpreter;
    • refused, conservatively: text such as a host:/tmp/x copy target, or a URL whose host is a root's name.
  • Tests (note). New cases:
    • with a working directory of /: a relative argument and a relative PYTHONPATH, both refused; PATH=:/usr/bin:, an empty value and an entry without =, all accepted;
    • with a working directory of /tmp: an empty or . part of PATH, and a relative sub/main.py, all refused; a bare -m and a PATH of /usr/bin:/bin, both accepted.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. Its manifests' python -c program text is not refused. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage282-protected.json, stage282-installed.json and stage282-unprivileged.json.

U-20261030-55 · 2026-10-30 · Close the thirty-ninth review of the private epoch roots · #snapshot #agent #linux #test

  • A thirty-ninth independent review of U-20261030-54 found no MAJOR. It confirmed that the argument and environment parsing is memory-safe, and that no legitimate manifest is refused: LANG=C, PATH=/usr/bin:/bin, HOME= and DISPLAY=:0 with a working directory of / all pass. It found three MINOR, which are closed here.
  • Program text was walked as a path (MINOR). Any relative part with a / was judged. So python -c text holding /../ was refused, and so was text whose first component ran past 255 bytes. A relative part now counts only when it reads as a path: letters, digits and ._-+@%,~=/, with no spaces, quotes or brackets.
  • One meaning for "a root itself" (MINOR). An empty or . part was refused for every variable when the working directory was a root (LANG=, DISPLAY=:0). Yet PATH=/tmp:/usr/bin was accepted. The rule is now:
    • a variable whose name ends in PATH or LIB is a search list, read for programs or code. There a root itself is refused too, since every helper of the epoch can write it. An empty or . part, and a bare name, are judged from the working directory.
    • for every other variable and every argument, a root itself is the epoch's own tmpfs. Only what lies below one is refused, and an empty or . part means nothing.
  • What the README lists (MINOR). U-20261030-54 said the README listed the conservative refusals; it did not. It now says that an absolute part which only looks like a path, such as the /tmp/x of a host:/tmp/x copy target, is refused. It also lists program text among what is not judged.
  • Tests (notes). New cases:
    • PATH=/tmp:/usr/bin is refused;
    • PYTHONPATH=lib is accepted from / and refused from /tmp;
    • a leading empty PATH part in /tmp is refused;
    • LANG= and DISPLAY=:0 in /tmp are accepted;
    • PATH=/usr/bin is accepted (the value alone is judged);
    • two python -c programs holding slashes are accepted.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage284-protected.json, stage284-installed.json and stage284-unprivileged.json.

U-20261030-56 · 2026-10-30 · Close the fortieth review of the private epoch roots · #snapshot #agent #linux #test

  • A fortieth independent review of U-20261030-55 found no MAJOR. It judged the two rules coherent and documented, with one exception, and found three MINOR, which are closed here.

  • A root itself was still allowed (MINOR). A policy could run in /tmp, or name /tmp itself in an argument or a variable such as HOME or PYTHONHOME. That is the same planting hazard as PATH=/tmp:

    • every helper of the epoch, under its own ID, can write a root's tmpfs;
    • so python3 -m app run from /tmp could import an app.py that another helper made first.

    The rule is now that nothing a policy names may be at or below a private root: its executable, its working directory, and every path its fixed arguments and environment values name. Only TMPDIR, TMP and TEMP may name a root itself, as scratch space.

    This reverses what U-20261030-46 allowed, a working directory equal to a root. No manifest here depends on that: the example and test manifests run in /.

  • Search lists were filtered as program text (MINOR). In a search list every part is a directory, so its parts are no longer required to read as a path. A PYTHONPATH of tmp/my lib from /var is refused.

  • The long-component case tested nothing (MINOR). The case now builds its python -c text with 300 literal x bytes inside quotes. That gives a first component well past 255 bytes, which the code before U-20261030-55 refused.

  • Notes.

    • The README now says plainly what is the manifest author's to get right: bare words outside search lists, program text, a second =, , or space-separated lists, attached option values, what other variables mean, and a #! interpreter.
    • The strictness flag is now called root_itself.
    • The positive cases that ran in /tmp now run in /var. From there, relative names still reach the root /var/tmp.
  • Evidence.

    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage286-protected.json, stage286-installed.json and stage286-unprivileged.json.

U-20261030-57 · 2026-10-30 · Close the forty-first review of the private epoch roots · #snapshot #agent #linux #test

  • A forty-first independent review of U-20261030-56 judged the path-hiding check settled. It found no MAJOR:
    • the refusal of a root itself applies the same way to the working directory, to absolute and relative argument parts, to every variable that is not scratch, and to empty search-list parts;
    • the TMPDIR, TMP and TEMP exception is exact;
    • no legitimate manifest is refused. It found one MINOR, a gap in the tests with no fault in the code, which is closed here.
  • The exception's edges were untested (MINOR). New cases:
    • TEMP=/var/tmp/ is accepted;
    • TMPDIR_X=/tmp and MYTMP=/tmp are refused. TMPDIR_X would pass if the name match lost its = check, and MYTMP if it matched a suffix. A forty-second independent review found no MAJOR and no MINOR, and judged that none remains in the path-hiding check; this wording was its one note.
    • root-only: TMPDIR through a link to /run/lock is accepted, and TMP below that link is refused.
  • Notes.
    • The empty or . branch for search-list parts is marked as defence in depth. A working directory at or below a root is refused before any part is read.
    • The CHANGELOG now states the rule in one sentence.
    • Bare words that name a root from the working directory, such as -d tmp from /var, remain the manifest author's responsibility, as the README says.
  • Evidence.
    • The root protected acceptance meets 48 of 48 expectations. The root-only purge_roots_check cases are 9 of 9, and cleanup leaves nothing behind.
    • The installed-host acceptance meets 11 of 11.
    • The unprivileged suites pass all 45 checks.
    • Local evidence: .worktrees/agent-tools/stage288-protected.json, stage288-installed.json and stage288-unprivileged.json.

U-20261030-58 · 2026-10-30 · Record the WSL host requirements as a finding · #decision #agent #linux

  • The installed-host acceptance (U-20261030-42 onward, 11 of 11 each time) ran in the WSL distro podman-webrunner-validation. That host misses two of the service README's host requirements:
    • kernel.core_pattern pipes to /wsl-capture-crash, which the guardian warns about;
    • /mnt/c, /mnt/d, /mnt/wsl and /mnt/wslg can be written by every account, and they are not purge roots.
  • Decided by the maintainer: leave the distro as it is and keep this as a recorded host finding. Changing core_pattern would affect every WSL distro, and changing the automount options needs wsl --shutdown. The service README already says how to meet both requirements under WSL. A production host must meet all of them.
  • Also decided by the maintainer: compatibility on other architectures, libc versions and kernels stays deferred, alongside the native and real-device acceptance, until another environment is available. It remains a TODO in Progress.md.