+ jHjfa0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIt^RI t ^RI t ^RI H t H t RtR]R&RRR]/RR lltR sR R ltR RltRRltRRltRRltRRltRtRtRtRt.]ORN5tRRltRRltRRltRt Rt!R t"R!t#R"R#lt$R$R%lt%R&R'lt&R(R)lt'RR*R+llt(R,R-lt)]PT!R.4t+R/R0lt,R1R2lt-R3R4lt.R5R6lt/R7t0R8t1R s2]3!]Ph]Pj]Pl]Pn04t8R9R:lt9]PtR;R<l4t;!R=R>]<4t=]3!0R?kR@kRAkRBkRCkRDkREkRFkRGkRHkRIkRJkRKkRLkRMkRNkROkRPkRQkRRkRSkRTkRUkRVkRWkRXkRYkRZkR[kR\kR]kR^kR_kR`kRakRbkRckRdkRekRfkRgkRhkRikRjkRkkRlkRmkRnk4t>]3!0Rm4t?Rt@RoRpltARqRrltBRsRtltCRuRvltDRwRxltERyRzltFR{R|ltGRR}R /R~RllltH]3!RRN04tIRRltJRRltKRRltLRRltMRRltNRRltORRltPRRltQRR}R /RRllltRRtSRRltTRRR /RRllltU]PtRRl4tVRRltWRRltXRRltYRRltZRRlt[RRlt\RRlt]RR /RRllt^RRlt_RRlt`RRltaRRltbRRltcRRRlltdRRlteRRltfRRltgRRlthRRltiRRltjRRR /RRllltk^tlRRltmR#)zBStartup requests for PM recovery and rescue of orphaned launchers.) annotationsN)Path PurePosixPathtuple[int, ...]QUARANTINE_RESTORE_BACKOFF_MSstream backoff_msc$V^8dQhRRRRRR/#)movedzlist[tuple[Path, Path]]rrreturn)formats"?/home/ubuntu/.hermes/hermes-agent/hermes_cli/_early_recovery.py __annotate__rs&)) ")))c>Vf\Pp.pVEFcwrERpVFp\PP V4'g&\PP V4'gRpMAV'd\ P !VR, 4\P!WT4RpM VfKVPWE34\PP\V44p V P4PR4'dV RR MT p \RV RVPP R\PP\V44 RV RV R V R 2 VR 7EKf V# \dpTpRp?EKtRp?ii;i) a>Rename quarantined shims back, retrying a lock instead of giving up. A pair is not a failure when ``original`` already exists or ``quarantined`` has gone: the installer wrote a fresh shim, or a concurrent sweep won the race. Both are silent, so two processes sweeping the same orphan cannot produce a spurious error. Ng@@.exeu ✖ FAILED to restore  (u!) — it is still quarantined as z. `zZ` will NOT be on PATH until it is put back. Run this, then re-run the update: move "z" ""file)sysstderrospathexiststimesleeprenameOSErrorappendbasenamestrlowerendswithprint __class____name__) r rrfailedoriginal quarantinedlast_excdelay_msexcnamestems &$$ rrestore_quarantined_shimsr2sp~&(F!&#'"H 77>>(++277>>+3N3N#HJJx&01 +0#    x-.wwH . JJL11&99tCRyt &tf-""++,-''""3{#34566&-s8*A  7   '"'8 M!  s*A F1F5F=5F FFFFcV^8dQhRR/#)r r boolr )rs"rrrFs B Bd BrcT\;'g\PR,R.8H#)ubTrue inside any ``hermes update`` process (and its import probes). Every dotenv load in the process — ``hermes_cli.main``, ``run_agent``, ``cli`` — consults this, so the updater never resolves external secret sources: on Windows they map ``cryptography._rust.pyd`` into the process replacing that venv, and everywhere a slow ``op``/``bws``/command helper (up to 120s per source) would run inside the updater's 120s critical-module import probe and be reported as an import-health timeout. Profile flags are stripped before ``hermes_cli.main`` loads dotenv, so ``argv[1]`` is the authoritative subcommand. :r Nupdate)_UPDATE_RETRY_RECOVEREDrargvr rr$_should_skip_external_secret_sourcesr:Fs! # A Achhsmz&AArcV^8dQhRR/#)r r rr )rs"rrrTs22t2rcd\\4P4PP#N)r__file__resolveparentr rr _project_rootrATs! > ! ! # * * 1 11rc V^8dQhRRRR/#)r marker_pathrr intr )rs"rrrXstrcZVPRRR7P4pT'g^#^RIpTP T4P R^4p\ T4\Jd \T4h\^T4# \d^#i;i \\\3d\TP44FdpTPR4wrVpT'gK!TP4R8XgK8\^\T44uu# \d^#i;i ^#i;i)uOAttempt counter from a marker's opportunistic JSON body; corrupt/missing → 0. utf-8-sigreplaceencodingerrorsNattempts=) read_textstripr!jsonloadsgettyperD TypeErrormax ValueErrorAttributeErrorreversed splitlines partition)rCrawrOrKlinekey separatorvalues& r_read_marker_attemptsr_Xs##[#KQQS ::c?&&z15 > $H% %1h   2S^^-.D$(NN3$7 !CEySYY[J6q#e*--! /sN!A=AB= B  B A D*D*7D D* D!D* D!!D*)D*c V^8dQhRRRR/#)r pidrDr str | Noner )rs"rrrrs    rc \PR8Xdy\RV R2R4;_uu_4pVP4pRRR4XP R4pT^8dR#Y#^,T^,P RR4;'gR#\PR 8XdX\P!R R R R \V4.RRRR^RR7PpTP4R,;'gR#R# +'giL;i \dR#i;i \\P3dR#i;i)uSingle-letter process state (``ps`` style), or ``None`` when unknowable. ``os.kill(pid, 0)`` also succeeds for a ZOMBIE — a process that exited but whose parent has not reaped it yet. Reading the state lets callers treat a zombie as dead, so a crashed update stage lingering under an un-reaping parent cannot keep a stale update marker "live" for the whole age ceiling (#77259, #120635, #125932). Best-effort and stdlib-only: on any failure the answer is ``None`` and callers keep their signal-0 verdict. linuxz/proc/z/statrbN)asciirGdarwinps-ozstat=-pTutf-8F)capture_outputtextrIrJtimeoutcheckNr6N) rplatformopenreadr!rfinddecode subprocessrunr$stdoutSubprocessErrorrN)rafhstatcomm_endouts& r_process_staterrs ||w se5)400Bwwy1 ::d# a<qL8a<077KSStS ||x ..tWdCH5#$f yy{2&&$& )10  334  s@DC<D$5D!< D D D DD!E?Ec V^8dQhRRRR/#r rarDr r4r )rs"rrrs****rcV^8:dR#\PR8XEd6^RIpRpVPRRR7pVPVP VP.VP nVPVP n VPVP.VPnVPVPn VP.VPnVP VPn VP VRV4pV'gVP4^8H#VPV^4R8HVPV4#\P!V^4\'T4pTe(TP)4P+R 4'dR#R# TPT4i;i \dR#i;i \ dR#\"dR#\$dR#i;i) uLBest-effort stdlib-only process liveness probe. ``os.kill(pid, 0)`` is not a no-op on Windows, so use the Win32 process handle API there. An access-denied result counts as live: racing an elevated updater is worse than postponing recovery for one launch. A zombie (exited, un-reaped) counts as dead — see :func:`_process_state`. Fwin32Nikernel32T)use_last_erroriZ)rrrctypesWinDLLc_ulongc_int OpenProcessargtypesc_void_prestypeWaitForSingleObject CloseHandleget_last_error ExceptionrkillProcessLookupErrorPermissionErrorr!rupper startswith)rar synchronizerhandlestates& r_pid_is_runningrs ax ||w  $K}}Z}EH-3^^V\\6>>,ZH )+1??H (5;__fnn4UH ( ( 139>>H ( ( 0-3__,=H )+1<#E$$V, Q 3 E U[[]55c:: $$V,     sZC9F;F;/F%F;G %F88F;; G  G  G6G6$G6(G61G65G6c V^8dQhRRRR/#)r markerrr r4r )rs"rrrs  $ 4 rcVVPRRR7pTP4F[pTPR4wr4pT'gK!TP 4R8XgK8\ \ TP 444u# R# \dR#i;i \dR#i;i)z?True when a legacy update marker names a process still running.rFrGrHFrLra)rMr!rXrYrNrrDrU)rbodyr[r\r]r^s& r_marker_owner_is_liversYG! $s 3 9- &s5;;='9:: "    s#B!B BB B('B(zhermes-update-pull120000c V^8dQhRRRR/#)r rootrr rbr )rs"rrrs  D Z rc@\V4p\FpW, pVP4'gK#VR8Xd&VR, P4'dRu#Ru#VR8XdR#VPR4P 4P RR4u# R #) zEReturn the active Git operation currently controlling *root*, if any. rebase-applyapplyingamrebase rebase-merge_HEAD_-N)_git_dir_GIT_OPERATION_IN_PROGRESSr removesuffixr%rG)rgit_dirrrs& rgit_operation_in_progressrstnG, ||~~  ^ #!J.66884 Fh F ^ #""7+113;;CEE- rc V^8dQhRRRR/#r rrr r )rs"rrrs4DrcVR, pVP4'dZVPRR7P4pVPR4'd#W\ R4RP4, #V#)zW``root``'s git dir: ``.git`` itself, or where a linked worktree's ``.git`` file points.z.gitrFrIzgitdir:N)is_filerMrNrlen)rdot_gitrns& rrrseVmG  + 6<<> ??9 % %s9~/5577 7 Nrc V^8dQhRRRR/#rr )rs"rrrs44$444rc.\V4\, #r=)rINTERRUPTED_PULL_MARKERrs&rinterrupted_pull_markerrs D>3 33rzhermes-update-recoveryMANIFESTzhermes_cli/__init__.pyc$V^8dQhRRRRRR/#)r rrprer$r r )rs"rrrs!77t7#7$7rc|\V4'g\RV: 24h\V4\, V, #)znot a commit id: ) is_object_idrUrRECOVERY_CLOSURE_DIR)rrs&&rrecovery_closure_dirrs5   ,SG455 D>0 03 66rc V^8dQhRRRR/#r r^r$r r4r )rs"rrrsIIIIrcV\\P!RT;'gR44#)z[0-9a-f]{40}|[0-9a-f]{64})r4re fullmatch)r^s&rrrs  95;;BG HHrc$V^8dQhRRRRRR/#)r databytesliker$r r )rs"rrrs&mm%msmsmrc^RIpTP\V4^(8XdRMRR\V4,V,4P4#)z[Git's object id of a blob holding ``data``, in ``like``'s object format (SHA-1 or SHA-256).Nsha1sha256sblob %d)hashlibnewr hexdigest)rrrs&& rblob_idrs; ;;Tbvh sSWy@X[_@_ ` j j llrc$V^8dQhRRRRRR/#)r closurerrr$r r4r )rs"rrrs!  t # $ rcaa\RS\, PRR7P444p\ V40\ m\ k8H;'d{V\ ,\RS48H;'dY\;QJd.VV3RlVP44F 'dK R# R#!VV3RlVP444# \\3dR#i;i)zZEvery closure file present with exactly the bytes its manifest names, and nothing missing.c3X"TF qPR^4RRR1,xK" R#5i) N)split.0r[s& r ,recovery_closure_verified.."s-jh48jja(2..hs(*rFrrc3p<"TF+wr\SV, P4S4V8HxK- R#5ir=)r read_bytes)rreloidrrs& rrr&s.iZhhc3 : : A22 BBz[0-9a-f]{40}(?:[0-9a-f]{24})?c$V^8dQhRRRRRR/#)r rr$rr ztuple[list[str], set[str]]r )rs"rrr]s"--S-#-:T-rcV!RW4PP4pV'dW18XdV.\43#V!RRRRRW4pVPR 9d5VPP R4vrVW%.\\ RV443#W3Uu.uF;p\\ RV!R RRR W74PP R444NK= ppV.V^,V^,,3#uupi) aThe trees the killed git was moving the checkout to, and the paths whose new content is unknowable. A fast-forward or ``reset --hard`` writes ``target``. On a custom branch the updater runs ``git merge``, whose files are the merge of both sides: ``merge-tree`` computes the same tree. A conflicted path (its markers carry other labels) and, on git < 2.38 (no ``--write-tree``), every path both sides changed count as git's whatever their content. merge-basez merge-treez --write-tree-z --name-onlyz --no-messagesNdiff --no-renamesr6)ryrNrrrfilter) rrrbasemergedtree conflictedsidechangeds &&& r_trees_git_could_writer%]s |S ) 0 0 6 6 8D 4;x ~t]OUX aF F""MM//5~s6$ #;<<<=*(46$FM4QU \ c c i ijn opq( * 8WQZ'!*, ,,*sAC1c V^8dQhRRRR/#)r r list[str]r dict[str, str]r )rs"rrrqs  y ^ rcVUu.uFpRV9gK VNK pp/pV'dV!RRRPV4R,R7pVP^8wd/\P!VPP 44hVP \W5PP444\V4\V4, F'pV!RRV4PP 4WF&K) V#uupi)zaBlob ids of the checkout's files, through the repo's clean filters, like ``git add`` would store. z hash-objectz --stdin-pathsr--) joinrrwrzrrNr7zipryrr)rrprblobshashedrs&& r_hash_worktreer2qs 0A$a-aaF 0 E ]O499V;Lt;ST    !,,V]]-@-@-BC C S!4!4!678E S[((-t4;;AAC ) L1s C?C?c(V^8dQhRRRRRRRR/#)r rrentriesrlinksset[str]r r )rs"rrrs(!!!t!H!!rcVP4UUUUUU u/uF4wpwrVqvfKYGUU u0uFwrW8XgK W8wgKVkK up pbK6 p pppppp V P4UU u/uFwrKV 'gKWKbK p pp V 'g \4#V!RRR4PP4R8gp V!.R OV O5!p V P^8wd/\ P !V PP44hRV PPR44UUUu/uF'wrpV'gKWNP4^,bK) pppp\4pV P4FwrKWC9dR0pMW, P4'g \4pMo\PR8Xd\\4M1W, P4P^@,'dR MR 0pV 'gVPR4W$,^,V9dVV ,'gVP!V4V 9gKVPV4K V#uup piuup pppppiuup piuupppi) a;Paths whose new entry keeps the ``pre`` blob under another mode, already in that mode. Equal bytes cannot tell a regular file holding ``original`` from a symlink to ``original`` (one blob id), nor 644 from 755: only the entry's mode can (review N07). The worktree shows a link (lstat), except under ``core.symlinks=false`` where git checks a link out as a plain file holding its target, and the executable bit, except on Windows. The index shows the mode git staged where the worktree cannot; git writes it after the files, so it covers a git killed after a whole tree. configz --type=boolz core.symlinksfalsec3B"TFqPR4xK R#5i) NrY)rrecords& rr#_modes_git_wrote..s M3Lt$$3Lrrr100755100644)ls-filesz-srr,)rrryrNrrwrzrrrrrr_REGULAR_FILE_MODESr|st_modeaddrQ)rrr4r5rold_modeold_blobrmbwantedmodessymlinksr meta_tabindexwrittenshowns&&&& r_modes_git_wroterRs6=]]_^^5D1$1SKd3J341!-QAMQQ3JJ5D ^-3\\^ E^kdukdk^F E u 8]O<CCIIKwVH  7 7F A(()<)<)>?? M6==3F3Ft3L M W M(8t4QU#T::<? " M  WeG||~  =JE+&&((EE03 0GC+,"k//199EAAxP  (# M! E )eemm $SX@X KK & N1K^ E Ws> I5I5 I/I/I/ I5, I?=I?- J?J/I5c(V^8dQhRRRRRRRR/#)r rrrr$rr z6tuple[list[str], list[str], set[str], set[str]] | Noner )rs"rrrs);*;*;*3;*;*@v;*rcV!RRRV R24P^8wdR#\WV4wrE/pVEFpV!RRRR R W'4pVP^8wd/\P!VPP 44hVP PR 4p \V R ,V R ,4F~wrV PR4P4wrrpVR8XdT MT \9dK>TPYVR8XdRMT.34pV^,PT VR8XdRMT34K EK VU u0uF2p \PPW, 4'gK0V kK4 pp \!YU u.uF+qV9gK W, P#4'gK)V NK- up 4pTP%VU u/uF=q\'\P(!\P*!W, 44V4bK? up 4\-WVV4p..\/4pppVP14EFewp wrpW, VUUu0uFwppV'gKVkK ppppV V9dVRJpMVV ,V8XdV V9pMVV ,V9gW9dRpMV V9dRpMVP34pRpVFpV!RRRV 2VRR7pVP^8wd?\P!VPP5RR7P 44hT;'gVP P7V4pK V'gEKVfTMTPV 4VeEK;VP9V 4V9gEKTVP;V 4EKh VP14U U UU!U"u0uFKwp wp pp!VeK\=V 4P>F"p"V"P@'gK\CV"4kK$ KM p#p!pp p p"V#'d7V#\/V!RRRRRV4P PR 44,p#VVV#V3#uup iuup iuup iuuppiuup"p!pp p i)aPaths the killed git already touched on the way to ``target``: (restore from HEAD, remove as added, directories git may have created for its added files, the added ones to keep aside, not delete). Git rewrites a file as unlink, create, write, so a kill leaves it missing, empty or cut short: all of those count as git's, like the full new blob. Content that matches neither side and is not the start of a new blob is the user's own edit (e.g. a re-applied stash) and is left alone. An added path holding less than a whole new blob may equally be the user's own file created there after the kill (a ``touch``, a first line): it leaves the tree, but renamed aside, never deleted. ``None``: git no longer knows ``target``. rev-parse-qz--verifyz ^{commit}Nrz--rawrrz --no-abbrevrNNr :r6Nr :DATFcat-filez --filtersz--path=)rnrG)rJls-treez-r-dr)"rr%rwrzrrNryrr.lstrip_WORKTREE_BLOB_MODES setdefaultr"rrislinkr2rr7rfsencodereadlinkrRrrrrvrrQrErparentspartsr$)$rrrrtreesunknownr4r!rrerMrrFnew_moderGnew_blobstatusentryr5 worktree_blobretypedrestoreaddedkeptr_modeblobrr0rPcontentrQ_m_nr@new_dirss$&&&& r_paths_git_wroterws ;jVHK*@ALLPQQ+Cf=NEG67D.-S ??a ,,T[[->->-@A A !!$'eCj%+6JD=A[[=M=S=S=U :HF"cMx@TT&&t# S[]_-`aE !HOOXv}t(K L 7 & Egd )DTTgE E"3'(s'$QVEV\`\g[p[p[r'(stM`ef`eX\ BKK 4L(Ms SS`efgs'59Gr35DUG+2==?''x3kC#HC[UD4DDCe#H } $d*G 4 H ,goG 4 E )T_G U]Goo'GGJ wtf5EtRWX##q($44U\\5H5HPY5H5Z5`5`5bcc!EEU\\%<% <<7 "  HHRBKK ( NN2$vFOOQ O   KKtU]]U]]: W  ><s%A/B:3AB:: C1!C,&C1,C1cV^8dQhRR/#)r rrr )rs"rrrsDrc#>"\P!V\, \P\P,R4p\ P!4\,p\TR4'gP\ P!4T8dRx\P!T4R#\ P!R4Ka\P!T^4\P!TR\P!4 R2P44Rx\TR4\P!T4R# \ d RxR#i;i \ dLMi;i \TR4i;i \P!T4i;i5i)z`Yields True while this launch holds the restore claim, False when another held it past the wait.TNFg?pid=r*)rrs_RESTORE_CLAIMO_RDWRO_CREATr!r monotonic_RESTORE_CLAIM_WAIT_SECONDSrcloser ftruncatewritegetpidencode)rrydeadlines& r_restore_claimrs  WWW~-ryy2::/Eu M>>#&AA2t$$~~(*    JJt   LLQ  HHR4 }B/668 9 J R   )      R   sFAE AFF4F AE !E1% F2F EFEF E.+F-E..F1E??FFFc]tRtRtRtRtR#)_Holderi zaA process that may own a git lock, e.g. ``pid 4242 (git commit)``: truthy, and never ``is True``.r N)r) __module__ __qualname____firstlineno____doc____static_attributes__r rrrr skrrannotateblamer[z check-attrz check-ignorez check-mailmapzcheck-ref-formatcherryz count-objectsdescriberz diff-filesz diff-indexz diff-treez for-each-refzfsmonitor--daemongrephelplogrBz ls-remoter\rzname-revz range-diffzrev-listrUshortlogshowz show-branchzshow-refrjvarz verify-commitz verify-tagr whatchanged credentialzcredential-cachezcredential-storefetchz fetch-packz http-fetchz index-packz pack-objectsz remote-httpz remote-httpsz upload-packc V^8dQhRRRR/#)r arg0r$r rbr )rs"rrr=sFFsFzFrc\P!RVP44R,P4pVP R4pVR8XgVP R4'dV#R#)z``git`` or ``git-`` when ``arg0`` (an argv[0], a comm, a psutil name) runs git, else None. Any directory (``/usr/lib/git-core/git-commit``), either separator, ``.exe`` and case folded: Windows runs ``git.exe`` and ``git-commit.exe``.z[\\/]rrgit-Nr)rrrNr%rr)rr0s& r _git_programr=sW 88Hdjjl +B / 5 5 7D   V $D5=DOOF$;$;4EErc V^8dQhRRRR/#)r cmdlinebytes | list[str]r r'r )rs"rrrGs**(*Y*rc\V\4'd;VPR4Uu.uFq'gK VPRR4NK up#VUu.uFq'gK \ V4NK up#uupiuupi)rlrG) isinstancerrrvr$)ras& r _git_argvrGse'5!!6=mmE6JP6Ja,),6JPP# )GqqFCFG ))Q )s A5A5 A:#A:c V^8dQhRRRR/#)r rrr rbr )rs"rrrMs 1jrc(\V4pV'd\V^,4MRpVfR#VR8wdV\R4R#\VR,4pVF7pV\9d\ VR4KVP R4'dK5Vu# R#)zThe subcommand a git argv runs: ``commit`` for ``git -C x -c k=v commit`` and for a dashed ``/usr/lib/git-core/git-commit`` (``git-commit.exe``); None when argv[0] is not git or names none.Nrrr6NNr)rrriter_GIT_VALUE_OPTIONSnextr)rargsprogramitargs& r_git_subcommand_ofrMs W D'+l47#G%s6{|$$ d2hB $ $ TN$$J  rc V^8dQhRRRR/#)r rzPath | str | Noner tuple[str, ...]r )rs"rrr_s!!.!?!rc VUu0uFaqfK\PP\PP\PP V444kKc ppY Uu0uFDqfK\PP\PP V44kKF up,p\ \V44#uupiuupi)z_The checkout's own paths as given AND resolved, so another process's path need not be resolved.)rrnormcasenormpathabspathrealpathtuplesorted)rr/placess* r_checkout_placesr_sNS eeDbggrww//0BCDeF e eUe4rww 0 0 34eUUF   fUsCAC2C`` too) or a ``GIT_DIR``-style variable is inside one.c V^8dQhRRRR/#rr )rs"rr"git_works_in..__annotate__zs++c+d+rc<V'gR#\PPV4'g+S'gR#\PPSV4p\ VS4#)F)rrrr-r)r^rrs&rinsidegit_works_in..insidezsCww}}U##GGLLe,EE6**rTrrrLc3h<"TF'pS!S;'g/PVR44xK) R#5i)rN)rQ)rr\rrs& rrgit_works_in..s,M;LCvsyybooc2.//;Ls22F)rrrYany_GIT_LOCATION_ENV)rrrrrrs&fff @r git_works_inrws++ |C((Bxx 3>>#+>+>#--$Q'C H H 3M;LM33M3M3M;LM MMrc$V^8dQhRRRRRR/#)r uid int | Nonerrr r4r )rs"rrrs&LLjL4LDLrc\P!V4pTRJ;'g6T^TP39;'g\ TP ^,4# \dR#i;i)zdA process running as ``uid`` may write ``git_dir`` (root, its owner, or a group/world-writable dir).TN)rr|r!st_uidr4rD)rrsts&& r _could_writers` WWW  $; K K#!RYY/ K K4 U8J3KK sA A('A(any_gitc(V^8dQhRRRRRRRR/# r rrr Path | Nonerr4r _Holder | bool | Noner )rs"rrrs)00T000Rg0rc\R4R, R, P4'd \WV4#\WV4#)aWhether a running process may still own ``path`` (a git lock): the holder, False, or None (unknowable). The holder is a truthy :class:`_Holder` naming it (``pid 4242 (git commit)``). False is proof, not a guess: Linux reads every process's fds through /proc and, with ``root``, also counts any live git working in the checkout (cwd, a path argument or ``GIT_DIR``) that is not a pure reader (:data:`_READER_GIT`; ``any_git`` counts readers too), whatever form runs it: ``git commit`` waiting in the editor has CLOSED its lock fd, and a dashed ``git-commit``, an alias or ``git.exe`` is the same git. A git that could write the git dir but whose cwd or environment cannot be read makes the answer None. macOS/BSD ask ``lsof`` for open fds and ``ps`` for any such git (``ps`` cannot say where it works, so any counts). Without either check the answer is None and the caller never deletes the lock. Windows needs no answer here: it refuses to unlink a file another process has open, so the caller's unlink is the probe. /procselfry)ris_dir_held_open_proc_held_open_lsof)rrrs&&$r _held_openrs; W %--//t733 4w //rzcredential-cache--daemonc$V^8dQhRRRRRR/#)r rr'rr4r r )rs"rrrs&KKIKKKrc`\V4pV\9;'dT;'g V\9#r=)r _NEVER_LOCKS _READER_GIT)rrsubs&& r_counts_as_holderrs, T "C l " J J(I(I3k3IJrc V^8dQhRRRR/#)r pid_dirrr r4r )rs"rrrs $ $T $d $rcVR, P4'*# \dTP4'*u#i;i)aHThe process has released its memory (exiting, or a zombie) or is gone. The kernel drops its fds before its cwd, and refuses its cwd/environ once it is exiting, so an unreadable cwd there is not a hidden git: counting it made any git exiting anywhere on a busy machine postpone the repair. A live process keeps a non-empty argv.r)rr!r)rs&r_exitedrs= $i'33555 $>>###$s AAc(V^8dQhRRRRRRRR/#rr )rs"rrrs)9)9)$9)k9)D9)EZ9)rc a \R4p\PPV4o Ve\ WP 4MRpRpRRlpVP R4EFAp\;QJd:V 3Rl\P!VR, 44F 'gK RM/ RM+!V 3Rl\P!VR, 444'dF\VR , P44p\R VP R V!W4 R 24u#VfKVP4Pp \TR , P44pTR , P4P!RR4P#4p T'gEKC\)T^,4f\)T 4fEKg\+TP4\P,!48Xg\/Y4'gEK\P0!TR, 4P3R4p \5RTR, P4P7R444p \;YY4'gEK \R TP R T!Y4 R 24u# V'dR#R# \d.pELi;i \dELi;i \dEKi;i \d9TP%4'd\'YP 4'dRpEKi;i \d\9T4'dEK\;TRRT4'd'\R TP R T!Y4 R 24uu#TP%4'd\'YP 4'dRpEKbi;i)rNFc$V^8dQhRRRRRR/#)r rr'rrr r$r )rs"rr%_held_open_proc..__annotate__s!9trc V'd@RP\PPV^,4.VR,O4#VR, P 4P RR4P 4# \dR#i;i)rr6NcommrgrG?)r-rrr#rrvrNr!)rrs&&rr0_held_open_proc..namest 88RWW--d1g6CcCD D f$00299'9MSSU U  s 4A>> B  B z[0-9]*c3j<"TF(p\P!VP4S8HxK* R#5ir=)rrcr)rrkrs& rr"_held_open_proc..s%]B\2;;uzz*f4B\s03ryTrpid r)r rgrGrz (deleted)c3"TF6q'gK VPRR4PR4R,xK8 R#5i)rlrGrLrWN)rvrY)rrks& rrrs<^$S5W\Lu||GY7AA#FsKK$Ss A0Aenvironr)rrrrrr@globrscandirrrr!rr0r|rrvrNrrrrDrrrcrrrrr)rrrprocr unknowabler0rrrr rrrs&&& @rrrs =D WW  d #F484D dKK 0$FJ99X& s]"**WW[^B\]sss]"**WW[^B\]]]$g &9%E%E%GHDgll^2d46I5J!LMM ^ >  ,,.''C g 1==?@Df$00299'9MSSUD   Q (\$-?-G  w||  +3DT3S3S  ++go.;;LIC^%,y%8$D$D$F$L$LU$S^^C 3 / /T',,r$t2E1FaHI IU'V4(5(MD         ~~Lkk$B$B!   wD$f55gll^2d46I5J!LMM~~Lkk$B$B!  s%:K"8K J2.s)(m4Wq[][b[b[i[ijk[l4W'8 8-Fpcr,TrlrGFrmrnrIrJrorrpr/rcrrr r)z/usr/sbin/lsofz /usr/bin/lsofr)rrrrwrxr$rr!rzryrXrrr_ps_git_holderr@) rrrrrrr[pidsnamess &&& rrrsT <<  t t4(m4W(mos#tD |dD$D BSW^bmt&/%/%7%7uF "'!8!8!: S!:ooc>RHDHH!:D S &+ll&=&=&?X&?d??SVCWb&?Xd1gYbUq(DAFGG v%L5VnT;;&VV Z// 0 SXs):E#F+ FF ; F #FFc$V^8dQhRRRRRR/#)r rr$r%r'r rr )rs"rrrs"S .Crc \P!VRRRRRRRPV4.RRR R ^\PR R 7pTP R9dR #/pR pTPP4FOpTPR4'd TR,pK%TPR4'gK>TfKDTR,Y4&KQ T# \\P 3dR #i;i)zWEach pid's cwd from ``lsof -d cwd`` (macOS has no /proc); None when lsof cannot answer.z-ar]rr pnrk,TrlrGFr"Nr/rnr) rwrxr-rr!rzrryrXr)rr%r~cwdsrar[s&& r _lsof_cwdsr-snndD$tT4RVXim"&TV^h^p^px} ~~V#D C %%' ??3  r(C __S ! !coRDI ( K Z// 0sAC C*)C*c V^8dQhRRRR/#rr )rs"rrr!srct\P!V^4R# \dR#\dR#i;i)z_POSIX only (the lsof branch never runs on Windows); stdlib, as this launch-time repair must be.FT)rrrr!)ras&r_still_runningr0!s8 Q   s 7777c ,V^8dQhRRRRRRRRRR /#) r rr$rrrrr4r rr )rs"rrr,s0555t545$5K`5rc a^RIpVPR4;'g\RR4R4oSfR#RV3RllpV!RRR4pV!RR 4pVeVfR#VUu/uF4p\V4^8XgKV^,V^,P 4bK6 p p/p VEF_p\V4^8wgeV^,P 4'dHV^,P 4'd+\ V^,4\P!48XdKz\V^,4fFV PV^,4'd&\W^,,^,4'gKV PV^,4;'g V^,.p \V ^,4f V^,.p \\ V^,4V4'gEK@\W4'gEKTWV^,&EKb V 'gR #\V\V 44p V fR#\W!4p V P!4FwrV PV4pVf\#\ V44'dR#\%WRV 4'gKL\'R V R R P)\P*P-V ^,4.V R,O4 R24u# R #uupi)aAn empty ``lsof`` is no proof: ``git commit`` waiting in the editor has closed its lock fd. Every git (by executable name, dashed forms included) that could write ``git_dir``, is not a pure reader, and works in the checkout (its cwd from ``lsof -d cwd``, or a path argument) keeps the lock; one whose cwd cannot be read makes the answer None. Gits elsewhere on the machine do not count, or any commit open in another repository would block every launch-time repair.Nric3t"TF.p\PPV4'gK*VxK0 R#5ir=rrs& rr!_ps_git_holder..6s)(d4NqRTRYRYR`R`abRc4Nrc V^8dQhRRRR/#)r columnsr$r zlist[list[str]] | Noner )rs"rr$_ps_git_holder..__annotate__:s h hS h3 hrc <\P!SR.RV4ORRRR^\PRR7pTP ^8wdR#TP P4Uu.uF<q"P4'gKTPR\T4^, 4NK> up# \\P3dR#i;iuupi)z-Ac3."TF pRV R2xK R#5i)rjrLNr )rr#s& rr-_ps_git_holder..ps..<s1MWBqc)WsTrlrGFr"N) rwrxrr!rzrryrXrNrr)r6r~r[ps_bins* rri_ps_git_holder..ps:s ..&$!N1MW1M!N_c&*WY)+:3E3EUTC >>Q ?Bzz?T?T?Vg?VtZdZdZf2 4W!12?Vgg 334  hs7B.)C&C.C  C rarr commandFrrrr r)z/bin/psz /usr/bin/ps)rrrrrisdigitrDrrrrQrrr-rrrr0rrr-rr#)rrrrrrinamedcommandsrowr9 candidatesrr,rrarr;s&&&& @rr$r$,s] \\$  k k4(d4N(dfj#kF ~ h h ueV $E%#H }(.6 Hhs#c(a- "CFCFLLN "hD H')J s8q=Q!1!1c!fnn6F6F3sSTv;Z\ZcZcZeKe  A  '#a&1A1AlSW\]X^S_`aSbFcFc xxA++CF8 Q (F8D CF W - -2CD2R2R!%s1v   dF:. /D | d ,F%%' hhsm ;>#c(33 4 0 0T#b2773C3CDG3L2YtTWy2Y)Z([[\]^ ^ ( 1 Is "K'9#K'c$V^8dQhRRRRRR/#)r rrrrr r$r )rs"rrrds&WWWKWCWrc\PR8XdRM\VR, V4p\V\4'dRV R2#R#)z\Who keeps ``index.lock`` for the user-facing message: ``pid N (name)`` when it can be named.rN index.lockza running git (rz a running git)rrrrrr)rrhelds&& r_index_lock_holderrGdsA<<7*4 7\;QSW0XD(24(A(A_TF! $VVrc(V^8dQhRRRRRRRR/#)r rrrrrr4r r )rs"rrrjs*d+RVcgrcVR, p\P!4^,pVP4'd\PR8XdRM \ W1VR7pVRJg\PR8XdVP 4R#VfR#\P!4V8dR#\P!R4KR# \dR#\dLPi;i)aDrop a killed git's ``index.lock`` (it refuses every git command) once its owner is PROVEN gone. False while a live git may hold it, or when this platform cannot prove it dead: the caller then keeps the interrupted-pull marker, so the next launch tries again instead of a rollback being lost. ``any_git``: every git working in ``root`` keeps it, readers included (:func:`_held_open`). rErN)rFTg?) rrrrrrrunlinkFileNotFoundErrorrr)rrrrzrrFs&&$ r_release_dead_index_lockrLjs \ !D~~!#H ++--||w.tJtSZ4[ 5=CLLG3   \ >> h & 3 % "  s<C C%C%!C%$C%z.hermes-update-zip-swapc$V^8dQhRRRRRR/#)r rrrnr$r Noner )rs"rrrs!Trc\P\P,\P,\ \R^4,pVP VP R\P!^4P4 R24p\P!W2R4p\P!TRRR7;_uu_4pTPT4TP4\P!TP44R R R 4\P !Y04R # \dKi;i +'giL:;i \"dTP%RR 7hi;i) a``text`` at ``path`` as one durable record, never a half-written one. The temp is an unpredictable name created exclusively (no-follow) beside ``path``: a pre-existing name there is never written through (its symlink or hardlink would carry the record onto another file) and never deleted (it may be a user's file: review Z5). fsync before the rename: an empty record over a mixed tree is no record. O_NOFOLLOWT.z.tmprwrlrN missing_ok)rO_WRONLYrO_EXCLr with_namer0urandomhexrsFileExistsErrorfdopenrflushfsyncfilenorG BaseExceptionrJ)rrnflagstmpryrs&& rwrite_durable_textrbs  KK"** $ryy 072|Q3O OE nn {!BJJqM,=,=,?+@EF U+B  YYr3 1 1V LL  LLN HHV]]_ %2 3   2 1  d # s7D6/!EAEE6 EE E EE: after_failurec$V^8dQhRRRRRR/#)r project_rootrrcr4r r )rs"rrrs(BB;BQUBbfBrc dVf \4MTp\V4pVP4'g-\V4\, P4'gR#\ V4'dR#Rp\V4\, P4'd\ \V44;_uu_4pV'd6\VPV4\PR7RRR4R#^RI H pV!V4'd RRR4R#RRR4VP4'gR#\VP4;_uu_4pV'gV'd RRR4R#\R4hVP4'g RRR4R#\ \V44;_uu_4pV'd>\VPV4\PR7RRR4RRR4R#\!W#VR7uuRRR4uuRRR4# +'giEL;i +'giM;iRRR4R# +'giR#;i \"\$P&\(3d*p\R T 2\PR7Rp?R#Rp?ii;i) aPut back the files a killed ``hermes update`` had half-moved to the new commit. ``after_failure``: the updater itself calls this when git exited non-zero mid-move (a locked or read-only file): same restore, and the marker stays whenever the tree is not verified whole. Returns True when the tree changed under this process: modules it already imported may be the half-written ones, so the caller must relaunch (``relaunch_after_restore``). Fast path (no marker) is one or two ``stat`` calls. Acts only when the marker's owner is gone, HEAD is still the pre-pull commit and no merge/rebase is in progress; then every path git wrote (the target's content, or torn on the way there) returns to HEAD (the commit the venv was built for), so the install is whole again and ``hermes update`` redoes the update from the start. Local edits are never touched; the updater's autostash (if any) stays in ``git stash list``. Concurrent launches take turns (``_restore_claim``); a launch that waited out another's restore relaunches. A torn ``hermes_bootstrap.py``, ``hermes_cli/__init__.py`` or recovery/lock/custody module fails before (or inside) the checkout's copy of this code: a minted launcher then runs the copy the updater published beside the marker (``RECOVERY_CLOSURE``). Limits, by design: other entry points (``python -m``, the ``hermes-agent`` hook's ``agent/__init__.py``) have no such fallback, and a launcher minted before that fallback existed has none either. A file git also changes that the user deleted, emptied or cut to a prefix of git's version looks exactly like git's own half-written file and is restored too, as is a user edit to a conflicted path or, on git < 2.38, to a path both sides of a custom-branch merge changed. NFuF⚠ Not repairing the checkout now: {}. Launch again once it finishes.r)restore_interrupted_zip_swapTzdhermes: another Hermes launch is finishing an interrupted `hermes update`; launch again in a moment.rcu8⚠ Could not check for an interrupted `hermes update`: )rArrrZIP_SWAP_JOURNAL_pytest_owns_live_checkout_checkout_custodyr'rrrhermes_cli._early_recovery_ziprgrr@ SystemExit_restore_holding_claimr!rwrzrU) rercrr busy_notebusyrgclaimedr/s &$ rrestore_interrupted_pullrrs0)a"."6}L(.~~d6F)F(O(O(Q(Q %d + +] J) ) 2 2 4 4"4:..$)**40szzB /.X/55/. 6 /~~ FMM * *g  + *!"=>>>>##+ *#4:..$)**40szzB /+ *".d-X /.+ */.../..+* ++ **  Z// <a HNUXU_U_`` asAI&I&2AI&:4H .I&8H  H  I&I&8I&I&I'I&1 III&I94H4 -I5I&? H4 I I& H1 + I&4 I ?II& I# I&#I&& J/J**J/cV^8dQhRR/#)r rrr )rs"rrrs%(%(D%(rc#$"^RIHpTP \T44pTe;TP\T44'gTP \T44pTeFTP\T44'gRxR#TPT4;'gRxR#RxTP4R# \d,p\R\ T4P RT R24ThRp?ii;i TP4i;i5i)aHold the checkout kernel lock (``hermes_cli.update_lock``) for a repair, like an updater (R2). Yields ``""`` while this process holds or joined it (the updater's own ``after_failure`` settle and its children join), else the busy reason: a live update tree owns the checkout and the repair leaves the tree alone. The restore's mutating git children inherit the lock (POSIX) or join this process's kill-on-close job (Windows) through ``update_custody.run_git``, so a launch killed mid-restore keeps the checkout locked until its git is gone. A torn lock module cannot prove custody: an already-running updater retains its imported copy and may still be writing this checkout. Refuse launch rather than race that writer. ) update_lockzNCannot safely repair the interrupted update: checkout custody is unavailable (: z). The recovery marker was kept. Wait for any running update to finish; if this persists, repair the checkout before launching Hermes again.Nrz&another update holds the checkout lock) hermes_clirur RuntimeErrorrRr)_acquire_checkoutrcheckout_lock_helddescribe_holder_release_checkout)rrur/holders& rrkrks* * *4: 6F +"@"@d"L"L..tDz: --d4j99H ))&1]]5]](%%'/  S ""#2cU+- -   . %%'sFDCBD$D,C;0D C8 &C33C88D;D  Dc$V^8dQhRRRRRR/#)r fieldsr(rrr r4r )rs"rrrs& Z Z~ Zt Z Zrc<\VPRR44pV\P!48g;'dO\ V4;'d<\ P !4VP4P, \8# \dRpL}i;i)zVThe updater that wrote ``marker`` is still running and the marker is fresh: hands off.rarr) rDrQrUrrrrr|st_mtime!_INTERRUPTED_PULL_MAX_AGE_SECONDS)rrowners&& r_claim_owner_aliversFJJub)* RYY[  Y Y_U%; Y Y fkkm4447XXZ sB BBc4V^8dQhRRRRRRRRRRR R R R /#) r rr(rrrrr$rollbackrcr4r rbr )rs"rrr sA$d!$03GKPZrc V!RRR4pRV9gHVP^8XdVPP4MRVR,P48wdVPRR4P4P R4pV'd RV RV R 2M>RT R VPR R4P4R ,;'g VR , R 2p \ R VR , RV R2\ PR7R#\WW4WVR7p V e,\ R VR , RV R2\ PR7R#\V4#)zZRedo a killed syntax rollback's HEAD move to ``pre``; the new HEAD, or None (marker kept).z symbolic-refrVHEADrefrz refs/heads/z`git -C checkout `z checkout --detach rN Nu/⚠ An interrupted `hermes update` rollback to zB was not resumed: HEAD now names another branch. Switch back with z*, then launch `hermes` again to finish it.rNrhz cannot resume yet (); the next launch retries.) rryrNrQ removeprefixr'rr_redo_rollback_head _read_head) rrrrrrrcr?rbackreasons &&&&&&$ r_resume_killed_rollbackr sO f -E Fu7G7G17Lu||113RTY_`eYfYlYlYnnjj#))+88G58(4& 3%q1v%8Hb9Q9W9W9YZ]9^9j9jbefibj8kklm  ?CzJ2267ac::  !t( `F  ?CzI]^d]ef))/2zz ; c?rc ,V^8dQhRRRRRRRRRR/#) r rrrrr$stashr rNr )rs"rrr<s0  $ d C  PT rcVR, p\'gxVP4'd`VPRR7P4V8Xd9Rs\ RV R2V'dRV R2MR ,\ P R 7R #R #R #R #) zSOnce per process, tell the user to abort the killed updater's own unfinished merge. MERGE_HEADrFrTuD⚠ A killed `hermes update` left its merge unfinished. Run `git -C z# merge --abort`, then launch again.z& Your local changes are in its stash ().rrN)_merge_advice_shownrrMrNr'rr)rrrr merge_heads&&&& r_advise_killed_merger<s<'J  J$6$6$8$8$$k$:@@BfL" TUYTZ[##\a(NugUW&Xgik:: M%9 rc V^8dQhRRRR/#)r rrrr$r )rs"rrrIstsrcaaa\V4o^RIHoRRRR/R TTT3R lllpT# \d,p\ R\ T4P RT R24ThRp?ii;i) zeThe restore's ``git(*args)``: the binary the updater recorded, every run under custody (``run_git``).)run_gitzKCannot safely repair the interrupted update: child custody is unavailable (rvzS). The recovery marker was kept. Repair the checkout before launching Hermes again.NrrnTc(V^8dQhRRRRRRRR/#) r rr$rrbrnr4r zsubprocess.CompletedProcessr )rs"rr"_custody_git..__annotate__Us)3333z33Hc3rc <SRR\S4.p\RRTR\S4RRR^xRVeRM\P/V'd R RR R R R /M/BpS!V\ V43/VB#)z--literal-pathspecs-CinputrrmTrorNrnrIrlrJrGr )r$rrwrlist)rrnrrkwargs executablerrs$$* rr_custody_git..gitUs14TCdEds4yddsd$)$5D:;M;MdUY&$ GXyQ_adtT$Z2622r)r hermes_cli.update_custodyrrrxrRr))rrr/rrrsf& @@r _custody_gitrIs *J53D3t33 J  S ""#2cU+A A   s) A&AAc ,V^8dQhRRRRRRRRRR /#) r rr(rrrrcr4r ztuple[bool, bool, bool]r )rs"rrr_s133n3d3$3%)3.E3rcVPpVR, pT;'dVP4pV'd\W4'd \W4\ VP RR4P 44;'d$VR,P 4\V48HpT;'gV'*;'d \WB4pWgV3#)aW``(foreign_lock, known_foreign, index_free)`` for the git dir's ``index.lock``, before any git runs. A killed git's lock goes first (an unresolvable or failing git would otherwise strand it, and it refuses every later git command). Proven-dead only; after a git that EXITED (``after_failure``) a lock now is another git's, never ours to drop.rE foreign_lockr) r@r_lock_predates_move_remember_foreign_lockr4rQrN_lock_identityrL) rrrrcrrzr known_foreign index_frees &&&$ r_judge_index_lockr_smmG \ !D 22T[[]L+F99 v,NB7==?@??~$$&.*>>``m"3"_"_8PQX8_J  22rcV^8dQhRR/#)r r rbr )rs"rrrvs  z rcTV!RR4pVP^8XdVPP4MRp\P V4'dV#VP P4;'gRV: RVP 2p\ RV R2\P R7R#) rUrrz git printed z, exit uB⚠ Could not read HEAD to repair an interrupted `hermes update` (rrN)rryrN_OIDrrr'r)rheadrdetails& rrrvs {F #D!%A!5$++   2C ~~c [[   R Rl3'@Q$RF NvhW% %+.::7 rc 0V^8dQhRRRRRRRRRRRR /#) r rrrrrr$rr rNr )rs"rrrs@ m m mT m4 mc m[^ mcg mrc \WV4'gC\RVR, RVR, RV RV RVR, R2 \PR7R #VP 4\R VR, R 2\PR7R #) z``target`` is gone (a gc or re-clone): nothing left to compare the tree against. Unattributable bytes are not proof of a whole tree: only a clean tracked tree at ``pre`` retires the record, rollback or not (review G2).uG⚠ An interrupted `hermes update` left tracked files that differ from rz and commit z/ is gone; the marker was kept. Inspect `git -C z status`, then `git -C rz+ -- ` for each file the update wrote.rNu7⚠ Ignoring a stale interrupted-update marker: commit z is gone.)_rollback_verifiedr'rrrJ)rrrrrrs&&&&&&r_retire_unattributablers cC 0 0 WX[\_X`Waam LTFSjS 2]_eheoeo q  MMO CF3K=PY Zadakaklrc(V^8dQhRRRRRRRR/#)r rrrrcr4r r )rs"rrrs/&U&U&Ut&Ut&UX\&Urc aVPo\RVPRR7P444p\ W14'dR#VP RR4P 4VP RR4P 4rTVP RR4P 4p\WP RR4P 44p\W1WR 7wrp VP R R4P 4p V R9dT MRp \V4p V fR#V 'd7V'd/V'd'W8Xd!\YsSYT T;'gT R 7p V fR#V'dV'dW8wdVP4R#\;QJd#V3R l\4F 'gK R M RM!V3R l\44'd\SWV4R#V 'g,\R \!SV4 R2\"P$R7R#\'WpWE4p V f\)VSWWE4R#\+WpWWFV WR7 #)c3P"TFqPR4R,xK R#5i)rLrWNr<rs& rr)_restore_holding_claim..s!k7jt..%c**7js$&rFrFrrrrrrhrc3R<"TFpSV, P4xK R#5ir=)r)rr0rs& rrrs# L1KGdN " " $ $1Ks$'Tu⚠ z\ holds the index after an interrupted `hermes update`; the next launch finishes the restore.r)rrc)branchdetach)r@rrMrXrrQrNrrrrrJrrrr'rGrrrwr_put_back_written)rrrcrrrrrrrrrrrPrs&&$ @rrnrnsmmG kv7G7GQ\7G7]7h7h7jk kF&))**UB'--/Hb1I1O1O1Q JJw # ) ) +E tZZr288: ;C.?PT.r+Lzz*b)//1H#';;xH c?D |CFt~&sGT5B5S5SmU < f   s L1K Lsss L1K LLLWdE:  '67866#_put_back_written..s aggclrT)r\reverseN)ownedu ✗ The rollback to ze is not verified yet (files the update wrote still differ); the next launch retries. Inspect `git -C z status`.u: ✓ Checkout restored; `hermes update` updates it again.z6 Your local changes are still in the update's stash (rr)r'rr_put_back_pathsrNrXrrrr!rmdirrr@rr4rJ)rrrrPrrrrrcrnrorvrpr*rrs&&&&&&&$$ rrrs&-"GH5l 4:=** F% mJb,SXJc:;AD M!GDA mm))+668JJ\NBOF >vhFabzz #h$:DI   ) ) Z   * )J*3 s#g,WW &s3xj1::>yJPSPZPZ \G$$u%% MMO 5 FSZZX  FugRPWZWaWab * ) )s &H H. c V^8dQhRRRR/#)r rzrr r$r )rs"rrrs+++#+rc~VP4pTP RTP 2# \dR#i;i)z_``inode:mtime_ns`` of a lock file, "" when there is none: a recreated lock is a new generation.rrX)r|r!st_ino st_mtime_ns)rzrs& rrrsB YY[ii["..) ** s - <<c$V^8dQhRRRRRR/#)r rr(rzrr r4r )rs"rrrs!;;;d;t;rcRV9dR#VR,P4p\V4;'dV\V48H#)z``lock`` is the generation ``arm_tree_move`` saw before the move's git ran. A marker without the record (an older updater's, hand-written) cannot say: every lock counts as foreign. index_lockT)rNr4r)rrzbefores&& rrrs>6! L ! ' ' )F < : :FnT&:::rc$V^8dQhRRRRRR/#)r rrrzr rNr )rs"rrrs&WW4WtWWrc\V4pV'gR#VPRR7P4Uu.uFpVPR4'dKVNK pp\ VRP .VORV 2N4R,4R#uupi)z_Record ``lock``'s identity in the marker (atomically: the marker is the restore's only record).NrFrz foreign_lock=r*)rrMrXrrbr-)rrzidentityr[liness&& rrrsd#H $.. .DOOQ 6QdOOO4TQE 6vtyy)M5)MM(2L)MNQUUV 6s B B c 0V^8dQhRRRRRRRRRRR R /#) r rrrrr$modercr4r rbr )rs"rrrs8d$S_chrrcxVR, pVP4'd(V'g\W4'g\W4 R2#VR8XdZV!RRRV4pVP^8wd>RVPP 4P 4;'gR.R, 2#V!R R V4pVP^8wd>R VPP 4P 4;'gR.R, 2#V!R R4p V P^8wg V PP 4V8wdR #R#)aMove HEAD (and the index) back to ``pre`` for a killed syntax rollback; None, or why not yet. The killed step's ``index.lock`` is reclaimed first, and only when its git is proven gone. After a git that exited in this very process (``after_failure``) a lock is never ours to judge. rEz may still hold .git/index.lockrz update-refz --no-derefrzgit update-ref failed: r resetrVzgit reset failed: rUzHEAD did not move backNr)rrLrGrrrNrXry) rrrrrrcrzr rrs &&&&&$ rrrs \ !D {{}}-/G/V/V$W344STT xL,<   q ,ell.@.@.B.M.M.O.X.XTWSXZ\-],^_ _ s #E 1#U\\%7%7%9%D%D%F%O%O3%QS$T#UVV {F #D !t{{002c9' rc(V^8dQhRRRRRRRR/#) r rrrr$rzset[str] | Noner r4r )rs"rrrs/ZZTZZOZW[ZrcV!RR4pVP^8wg=VPP4V8wgVR, P4'dR#V!RRRRR 4pVPP R 4Uu0uFqf'gK VR ,kK ppVP^8H;'dVfTMWs,'*#uupi) zThe rollback landed: HEAD is ``pre``, no index lock, and no tracked change among ``owned`` (the paths the update wrote), or anywhere when they are unknown (``target`` gone).rUrrEFrjz --porcelainrz--untracked-files=norr:r NN)rryrNrr)rrrrrrjrkr$s&&&& rrrs {F #D !t{{002c9g >T=\=\=^=^ =$0F WF&,mm&9&9$&?I&?U5yuRyy&?GI    ! Y Yem7&YYJs  C  C c ,V^8dQhRRRRRRRRRR /#) r rrrnr'rorpr6r z"subprocess.CompletedProcess | Noner )rs"rrrs1ti "'Irc V'd3V!RRRRRRRPV4R7pVP'dV#V'dV!R R R R RRRPV4R7pVF^pWd9d>\R V R\W, 4P R2\ P R7KFW, PRR7K` VP'dV#R#)zmReturn ``restore`` to HEAD and drop ``added``, renaming those in ``kept`` aside; the failed git run, or None.rnz --source=HEADz--stagedz --worktreez--pathspec-from-file=-z--pathspec-file-nulrr+rmrVz--cachedz--ignore-unmatchz Kept z as z: it may be your own file.rTrSN)r-rr' _keep_asider0rrrJ)rrrnrorprxrs&&&&& rrrs)_j,H`'tyy/AC >>>J $j*<>V'tyy/?AC{uDTZ)@)E)E(FF`ahkhrhrs##t#4  >>>J rc V^8dQhRRRR/#)r rrr r )rs"rrr2sdtrc^p\PPTPVP R2V^8dRV 2MR,4;p4'd V^, pKa\P !W4V#)zjRename ``file`` to a free ``.hermes-update-kept[-N]`` beside it (never importable, never clobbered).z.hermes-update-keptrr)rrlexistsrWr0r )rr+asides& rrr2si A ''//4>>TYYK?R2SbcfgbgYZ[\Z]W^mo2p#qq% r r QIId LrcV^8dQhRR/#)r r rNr )rs"rrr;s # # #rc\P.\PR,Op\PP 4\P P 4\P R8Xd+\P!\P!V44\P!\PV4R#)zRe-run this command from the restored tree; never returns. Everything imported so far (this package, ``hermes_bootstrap``, ``hermes_cli.main`` itself) may be the killed git's new files, and they would run against the restored old tree. rrN) rr orig_argvryr\rrrexitrwcallrexecv)r9s rrelaunch_after_restorer;sq NN /S]]2. /DJJJJ ||w &'HHS^^T"rc V^8dQhRRRR/#r rrr r4r )rs"rrrJsbbTbdbrcR\P9;'d5V\\4P 4P P 8H#)zKeep lifecycle tests from repairing the checkout that runs the suite. Copied installations in tmp_path remain eligible for real recovery tests. PYTEST_CURRENT_TEST)rrrr>r?r@rs&rrjrjJs9 !BJJ . a a44>;Q;Q;S;Z;Z;a;a3aarc V^8dQhRRRR/#rr )rs"rrrRs  t  rc^RIHpHpHpV!V4P 4'gR#V!V!V44P 4'*# \ dR#i;i)zATrue when PM recorded an environment whose site-packages is gone.)runtime_facts_path selected_venv site_packagesFT)pm.environmentsrrrrrrx)rrrrs& r_missing_environmentrRsRPP d # + + - - t!45<<>>> s A AAc V^8dQhRRRR/#)r rrr rNr )rs"rrr^s22$242rc^RIp\P!\4;_uu_4\ V4^,pVP RRR7p\ ;QJd*RVP44F 'gK RM RM!RVP444'dXVP4Uu.uFqDPR4'dKVNK ppR P.VORV 2N4R ,pMVPR V/4pVPVR R 7RRR4R#uupi +'giR#;i) zNBump ``marker``'s attempt count in its own format so the retry limit can trip.NrFrGrHc3B"TFqPR4xK R#5i)rN)rrs& rr(_count_failed_attempt..gsE3D4v&&3Dr?TFz attempts=r*rKrlr) rOrrr!r_rMrrXrr-dumps write_text)rrOrKrr[rs& r_count_failed_attemptr^s   W % %(014YG 3E4??3DE333E4??3DE E E&*oo&7\&7d{?[TT&7E\99=u= (&<=>ED::z845D$1 & % ] & % %s1AD/:(D/#D/5D*D*AD/*D// E explicitc(V^8dQhRRRRRRRR/#)r rerr9zlist[str] | Nonerr4r r )rs"rrros+77K7>N7dh7uy7rc>Vf \4M\V4P4pV'g\V4'dR#^RIHpT!Vf\ PR,MT4pV'gVR,R.8XdR#^RIH pV!V4R, pVR , VR , V3pVU u.uFqP4'gKV NK p p VR , P4'd"V'gV 'g\V4'gR#\V4p V fR#VU u.uFqP4'gKV NK p p V 'gIV'g+\V4'g\P!V 4R#VPR R R7V.p \ ;QJdRV 4F 'gK RM RM !RV 44'd\P!V 4R#V'go\ ;QJdRV 4F 'gK RM RM !RV 44'd5\#R\ P$R7\P!V 4R#^RIHp \#R\ P$R7V !V4V Fp V P+RR7K VR,R.8Hs\#R\ P$R7\P!V 4R#uup iuup i \.dp^RIHp\3T\44'dT!Y>4'dhT Fp \7T 4K \#RT R2\ P$R7Rp?\P!T 4R#Rp?ii;i \P!T 4i;i)zRAsk PM to restore dependencies before activation; leave failed requests retryable.NF) command_argvrrqrinstall_state_dirz.repair-incompletez.update-incompletez.lazy-refresh-incompletezpyproject.tomlz{"attempts": 0}rlrc38"TFp\V4xK R#5ir=)rrrs& rr$recover_if_needed..sC7$V,,7sTc3F"TFp\V4\8xK R#5ir=)r_ _EARLY_CORE_INSTALL_MAX_ATTEMPTSr s& rrr sxpwfl 5f =Aa apws!zOhermes: automatic dependency repair retry limit reached; run `hermes pm repair`r)repair_dependenciesz8hermes: repairing the recorded dependency environment...rSr7z'hermes: dependency environment repaired) install_state_permission_messagez"hermes: dependency repair failed: z; run `hermes pm repair`)rArr?rjhermes_cli._parserrrr9rr rr_claim_recovery_lockrrrrr'r pm.recoveryrrJr8rrrrr)rer9rrrrr missing_marker marker_pathsrmarkersrzrrr/rs&&$ rrecover_if_neededros+2=?\8J8R8R8TD 2488/   $ ?D RTF*1&t,/CCN//8R1RTbcL ,?  tt G? # # , , . .x7NbcgNhNh  %D | $0CLDLLN44LC$8$>$>6 5  % %&7' % J%&G 3C7C333C7C C C. -CCxpwxCCCxpwxxx cjmjtjt u( ' 4 HszzZD!F MMTM *"&r(xj"8 7cjjI O@D( D c? + +0PQU0[0[ F !& ) 23%7OPWZWaWab  s1K- K-'K7+K2K2 K7K7 K7*K7>K72K7: K7K7K74K7(A,K72K77 NAM< N<NNNc V^8dQhRRRR/#)r rrr rr )rs"rrrst rcx^RIHp^RIHpV!V4pVP RRR7\ P !VR, \ P\ P,R4pV!VRR7'dV#\ P!T4R # \d\ P!T4hi;i) z?Hold a kernel lock in writable state; process exit releases it.r)_lockT)rdexist_okz.recovery.lockiF)waitN) rr hermes_cli.runtime_statermkdirrrsrrr_r)rr rrrys& rrrs1. d #E KKtK, ))2:: +A5 IB % I ! HHRL     s+B;B#B9)rdiiiX)rCHERRY_PICK_HEAD REVERT_HEADrr)rAr@)zhermes_cli/_early_recovery.pyzhermes_cli/update_lock.pyzhermes_cli/update_custody.py)r>r-c --git-dir --namespace --work-tree --config-env --attr-source--super-prefix)GIT_DIR GIT_WORK_TREEGIT_INDEX_FILEGIT_COMMON_DIRr=)NN)n__conditional_annotations__r __future__rrrrrrwrrpathlibrrr__annotations__r2r8r:rAr_rrrrrrrCr_rrrrrrrrrrrr rcompilerr%r2rRrwrrr frozensetEAGAIN EWOULDBLOCKEACCESEDEADLKrrcontextmanagerrr$rrrrrrrrrrrrrrrrrr-r0r$rGrLrirbrrrkrrrrrrrrnrrrrrrrrrrjrrrrr)r.s@rr9sH"  '2JI).2)"?)`  B24 F*Z (/$+!n*7,7h7 40q '07 Im B L zz23-( !H;*D," e.?.?u}}]^, 6lcl   # %1 3A CR Tf    ) +1 3? AM OZ  ( *0 28 :? AK MX Zc   + -7 9D FP RX Zg        "1  3?  AJ  LY    %  '9    ( *6 8F HU We     UF* $!"N(L000*46IJK K $9)xW*&5pW Y^<-6BX]BBJ %(%(P Z8 ,3.  m&Ue&UR$N+;W,Z* #b 2"7kp77v$% r