+ jHjFRt^RIHt^RIt^RIHtRtRRltRRltR#) a Cron external worker: the PM dependency boot its own entry point never gets. ``sys.executable -m cron.scheduler --external-worker-file ...`` (``cron/scheduler.py::_launch_external_cron_worker``) is a full Hermes entry point that reaches ``hermes_bootstrap`` only from its ``__main__``, and it imports Hermes packages the moment it starts. ``cron/scheduler_worker_env.py`` restores the committed generation's ``site-packages`` on its ``PYTHONPATH`` so those imports resolve, but a pinned path is not a boot: the worker holds no lease on the generation, so the PM collector may remove it between the gateway's exit and the worker's next import (#122290 review), and its ``sys.path`` never ran the generation's ``.pth`` files. ``pm.environments.activate_dependencies`` is exactly that boot -- the same call ``hermes_bootstrap`` makes for every other entry point -- and it leases the generation it selects for the life of the process. ``worker_bootstrap()`` runs it at the top of ``cron/__init__.py`` -- ``-m cron.scheduler`` executes the package before the module, and the package's first import (``cron.jobs`` -> ``hermes_yaml`` -> ``ruamel``) is already a dependency -- and does nothing unless ``_launch_external_cron_worker`` marked this child: the gateway already booted through ``hermes_bootstrap``, and every other importer of ``cron.scheduler`` is an interpreter that owns its own dependencies. A genuine activation failure propagates: continuing on the inherited, unleased path lets the collector delete the generation under a live worker. The worker then exits before its ownership acknowledgement, which ``_launch_external_cron_worker`` already reports as a failed dispatch with the worker's stderr. PM's legitimate no-ops (no committed generation under a venv, wheel, Nix) return normally. That boot covers dependencies only. ``hermes_bootstrap`` also finishes a pending source update and may relaunch the process into a fresh one (``hermes_cli/venv_sync.py::relaunch_command``, an ``-I`` interpreter that ignores the pinned ``PYTHONPATH``), and re-executes it after restoring a tree a killed ``hermes update`` half-wrote. ``finish_worker_boot()`` runs it from the worker's ``__main__`` before the payload is read, so a relaunch replays the whole worker: the payload is still on disk and the marker still set, and the new process boots its dependencies again. ``hermes_bootstrap`` re-runs the (idempotent) dependency boot; the package-init call above must stay, because ``cron.jobs`` needs dependencies before ``__main__`` can run. ) annotationsN)Path_HERMES_CRON_WORKER_BOOTcV^8dQhRR/#returnNone)formats":/home/ubuntu/.hermes/hermes-agent/cron/worker_bootstrap.py __annotate__r 1sBB$Bc\PP\4'gR#^RIHpV!\ \4P4PP4R#)zPRun PM's dependency boot in the marked external worker (again after a relaunch).Nactivate_dependencies) osenvironget WORKER_MARKERpm.environmentsrr__file__resolveparentrs r worker_bootstrapr1s< ::>>- ( (5$x.00299@@ArcV^8dQhRR/#rr )r s"r r r :s ( (D (rcV^RIp\PP\R4R#)aMRun ``hermes_bootstrap`` before the worker reads its payload; may relaunch the worker. Not from ``worker_bootstrap()``: while ``-m cron.scheduler`` executes ``cron/__init__.py``, ``sys.argv[0]`` is still ``-m`` and ``__main__`` has no spec, so the relaunch command could not name the module to re-run. In ``__main__`` both are set. N)hermes_bootstraprrpopr)rs r finish_worker_bootr:sJJNN=$'r) __doc__ __future__rrpathlibrrrrr rr r#s("H#  + B (r