߲j  UdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlmZddlmZddlmZmZmZmZmZmZmZddlmZddlm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&dd l'm(Z(m)Z)dd l*m+Z+dd l,m-Z.e j^e0Z1ejdddddZ3e4e(jje(jlhZ7dZ8dZ9de9dZ:de9dZ;dZdZ?dZ@dZAdZBdZCdZDdZEd ZFe:e;eZXdd?ZYdd@ZZddAZ[ ddBZ\ddddC ddDZ] ddEZ^GdFdGZ_dHZ`dIZadJZbdacejZddKZedLZfddMZgdNZhejZidajddOZkdddPZldQZmdddRZnddS ddTZoddUZp ddVZqddWZrddXZsddYZtddZZudddddd[ dd\Zv d d]Zw d d^Zx d d_Zyd d`Zz d daZ{ddddddbddddc dddZ|Gdedfe}Z~dgZddhZddiZddjZddkZddlZdbdmddnZddoZdddp ddqZddrZddsZddtZdduZddvZ ddwZddxZddyZddzZdd{Zdbdmdd|Zdd}Zdd~ZddZ ddZd dZd!dZddZdd d"dZGddZd#dZGddZd$dZ d%dZd&dZddZddZd'dZddZ d d(dZdZd)dZdZd*dZdZdZd+dZd*dZd,dZd-dZd.dZd/dZd0dZdZd1dZd2dZedZd3dZd4dZd5dZddd6dZdZd7dZd8dZd9dZGddZGddZd:dZ d d;dZddZ d?dZƐd@dZǐdAdZ dBdZ dCdZʐdDdZːddZ dEdZ͐ddZΐdFdZϐdGdZ dHdZdd„ZddbdĜdIdńZ dJdƄZ dKdDŽZejGdȄdɫZ dLd˄ZejGd̄dͫZ dMd΄ZejGdτdʫZېdNdЄZ dOdфZ dPd҄ZddddddddԜ dQdՄZߐdRdքZdSdׄZdddd؜ dTdلZdZdddddddZdUdVdZdWdZdXdZdYdZdZdZddd[dZgdZGdde}Zy(\aContext compression: feasibility probe, warning replay, compress, image fix. Thread-safety contract for extension points: with ``compression.context_timeout_seconds > 0`` (default) the whole pass, context engines and memory providers included, runs on a pooled daemon thread. Calls may arrive on any pooled thread (never rely on thread-affinity/locals); the message list is a private deep snapshot (in-place mutation is invisible to the live conversation unless the pass commits); state is published ONLY on an admitted :class:`CompressionCommitFence` commit (work still running after a host timeout is discarded); one pass per session at a time (durable lock) but sessions run concurrently, so shared engines must be thread-safe. ) annotationsN)datetime)Path)AnyCallableDictListLiteralOptionalTuple)AuxiliaryExplicitCancellation)#automatic_compaction_status_messagesanitize_memory_context)#PRE_COMPRESS_CHECKPOINT_API_VERSION)estimate_messages_tokens_roughestimate_request_tokens_rough)ActivityProvenancenormalize_activity_provenance)set_usage_anchor)new_session_idFexc_infoc#K dy#t$r?}|rtj|dntj||Yd}~yYd}~yd}~wwxYww)zLRun a best-effort block; on Exception log ``message`` at DEBUG and continue.NTr) Exceptionloggerdebug)messagerexcs C/home/ubuntu/.hermes/hermes-agent/agent/conversation_compression.py_swallowr *sFY Y08 Wt ,fll7TW>X>X,Ys6A A A/A AA A AA<zCompacting contextu🗜️ u: — summarizing earlier conversation so I can continue...u@ — still summarizing earlier conversation so I can continue...u6✓ Context compaction complete — continuing turn...c ddlm}t|ts|S|Dcgc]>}t|tr*|j Dcic]\}}||k7s ||c}}n|@c}}}Scc}}wcc}}}w)aCopy ``msgs`` with the ``_db_persisted`` marker removed for no-op comparison. Live dicts carry the marker while ``compress()`` output is swept, so a raw ``==`` would misclassify an identical no-op copy as progress. Non-list inputs and non-dict entries pass through unchanged.r_DB_PERSISTED_MARKER)agent.context_compressorr$ isinstancelistdictitems)msgsr$mkvs r_strip_marker_for_comparisonr.Jsc> dD ! mq r rhiTUW[I\aggi Eda10D+DQT Ebc c rr E rs(A- A'A'A-'A-ct|dd}|sytdd5|dtdddy#1swYyxYw)z;Emit the structured terminal edge for a started compaction.status_callbackNz.status_callback error in compaction completionTr compacted)getattrr COMPACTION_DONE_STATUS)agentr0s r_emit_compaction_doner5TsBe%6=O  BT R= %;<===s5>ur📦 Pre-API compression: ~{tokens:,} tokens near the context/output limit. Compacting before the next model call.ub📦 Preflight compression: ~{tokens:,} tokens >= {threshold:,} threshold. This may take a moment.u\💤 Resumed after {idle_seconds}s idle — compacting ~{tokens:,} tokens before continuing.uS🗜️ Context too large (~{tokens:,} tokens) — compressing ({attempt}/{cap})...u=🗜️ Compressed {before} → {after} messages, retrying...uA🗜️ Compressed ~{before:,} → ~{after:,} tokens, retrying...uL🗜️ Context reduced to {new_ctx:,} tokens (was {old_ctx:,}), retrying...u⚠ Context is over the compression threshold (~{tokens:,} tokens >= {threshold:,}) but compression is currently blocked ({reason}). The model may stop responding. Run /new to start a fresh session or /compress to retry immediately.i@)tokensii)r6 thresholdi) idle_secondsr6i)r6attemptcap )beforeafter)new_ctxold_ctxct|tr|jnd}|syt|vry|tk(ry|j }d|vsd|vryd|vxs d|vxsd|vS) a=True for in-progress auto-compaction lifecycle lines (not the done edge). The gateway re-tags matches as ``kind="compacting"`` for the whole pause; matching only the marker left idle/preflight/retry lines looking hung. ``COMPACTION_DONE_STATUS`` is emitted as ``kind="compacted"`` and must not match here.FTzcompaction completez compression is currently blockedcompactcompresszcontext reduced to)r&strstripCOMPACTION_STATUS_MARKERr3lower)textbodylowereds ris_compaction_progress_statusrNsw &dC04::E  =ve}M ;rO)_previous_summary_summary_has_user_turncompression_count_last_compression_savings_pct_ineffective_compression_count_anti_thrash_recovery_deadline_fallback_compression_streak$_verify_compaction_cleared_threshold_last_compression_made_progress_summary_failure_cooldown_until_cooldown_persist_failed_last_summary_error_consecutive_timeout_failures _consecutive_truncation_failures_last_summary_dropped_count_last_summary_fallback_used_last_compress_aborted_last_summary_auth_failure_last_summary_network_failure#_last_summary_empty_content_failure_last_summary_truncated_failure_last_summary_overload_failure_last_aux_model_failure_error_last_aux_model_failure_model_last_aux_resolved_model_summary_model_fallen_back summary_model_last_compression_telemetry_active_compression_telemetry_compression_telemetry_seed_proactive_prune_rearm_tokens)rbrdrcc t|}tDcic] }||vs|||}}tj|S#t$ricYSwxYwcc}w)zCopy only the mutable bookkeeping owned by one compression attempt. The allow-list avoids copying clients, DB handles, locks and plugin resources; missing fields are ignored so legacy/third-party compressors keep working.)vars TypeError _COMPRESSOR_ATTEMPT_STATE_FIELDScopydeepcopy) compressorvaluesnameselecteds r"_snapshot_compressor_attempt_statersbj!0PbtSW[aSafTl"bHb == ""  bs > AA A  A $hermes_compressor_attempt_generation)defaultzcontextvars.ContextVar[Any]_COMPRESSOR_ATTEMPT_GENERATIONct5t|dd}|tj} ||_|cdddS#t $r t jcYcdddSwxYw#1swYyxYw)aPer-compressor lock serializing the durable cooldown rollback against claims. The process-wide claim lock must stay cheap (every compressor in a gateway shares it), so the slow SQLite write in ``_restore_compressor_attempt_state`` is fenced by THIS lock instead; ``_claim_compressor_attempt`` takes it first so a claim on that compressor waits for the restore while other compressors proceed. A slotted/frozen compressor that cannot hold the attribute gets a no-op (its guard is off anyway). _compression_attempt_serial_lockN)_COMPRESSOR_ATTEMPT_LOCKr2 threadingLockrr contextlib nullcontext)r~locks r_compressor_attempt_serial_lockrs} "z#EtL <>>#D 0>B ;  0!--//  0 s+$A*>A*A'A*&A''A**A3c t|5t5tt|ddxsddz} ||_|cdddcdddS#t $rYddddddywxYw#1swYnxYwdddy#1swYyxYw)zClaim the compressor for a new attempt; return its monotonic generation id. Restores or cancelled-check mutations stamped with an OLDER generation no-op, so a detached late attempt cannot clobber its successor's state._compression_attempt_generationrr9N)rrintr2rrr~ generations r_claim_compressor_attemptrs ) 46N-NPQRWVWX[\\  9CJ 6     sIBA,A A, B A)A,B(A))A,,A5 1BB cz|syt5tt|ddxsd|k(cdddS#1swYyxYw)zETrue when *generation* still owns the compressor (or guard disabled).TrrN)rrr2rs r_compressor_attempt_is_currentrsB  !a7:'H!LQPQRV``aaas1:ct5tjt5||_ddddddy#1swYxYw#1swYyxYw)aXPublish the generation of the attempt that is ACTUALLY running summary work. The entry claim is taken before the breaker gates and the per-session lock, so no-op entries (lock sit-outs, transient gates) bump ``_compression_attempt_generation`` without doing any work. Candidate supersession must key on this separate marker, published only when the summary dispatch begins, or those no-op claims discard a completed candidate and compression livelocks. Slotted/frozen compressors that cannot hold the attribute keep the entry-generation check as a conservative fallback. N)rrsuppressr'_compression_working_attempt_generationrs r _mark_compressor_working_attemptr sU "L   + LAKJ > LLL L LLLsA:AA AAc.t|s ty)zUnwind the CALLING attempt (its generation rides the ContextVar) as a cancellation when a newer attempt has since begun summary work on *compressor*, so none of the shared-state writes that follow the call site can land.N)_caller_attempt_is_currentr r~s r_raise_if_stale_attemptrs &j 1+-- 2rOc>t|tjS)u`Working-attempt check for the calling attempt's own generation (ContextVar; None → unguarded).)_working_attempt_is_currentrgetrs rrr#s &z3Q3U3U3W XXrOc|syt5t|dd}|&tt|ddxsd|k(cdddSt|t|k(cdddS#1swYyxYw)zTrue when *generation* is still the last attempt that began summary work. Without a published marker (attribute-less compressor, or the attempt never reached dispatch) supersession falls back to the entry-generation ownership check.TrNrr)rr2r)r~rmarkers rrr(sq  !.%NPTU >wz+LaPUTUVZdd..6{c*o- ...s,A A  A)ct5tjt5||_||_ddddddy#1swYxYw#1swYyxYw)zDInstall the F4 cancellation consult, stamped with its owner attempt.N)rrrr_compression_cancelled_check"_compression_cancelled_check_owner)r~checkrs r$_install_compression_cancelled_checkr6s[ !G   + G6;J 3s " $H$O  0C  + A6:J 3<@J 9 A A A s(A.A.A" A."A+ 'A..A7c t|jd}t|jd}||sy|durLtt|dd}t |r| t d|||t j|ytdd5t|d xsd }td |tjz }|d kDrQtt|d d} t | rZ| ||tj|z|jd n*tt|dd} t | r | ||dddy#1swYyxYw)zRecreate/clear the durable cooldown row from the attempt snapshot. Authoritative captures use the exact raw-row restore API (verifies read-back, propagates failure); the legacy path re-derives deadline/error best-effort. _session_db _session_idNT(restore_compression_failure_cooldown_rowz6exact compression cooldown rollback API is unavailablez0compression cooldown persistence rollback failedrrbr#record_compression_failure_cooldownrd"clear_compression_failure_cooldown) ryrr2typecallable RuntimeErrorr|r}r floatmaxtime monotonic) r~snapshot authoritative durable_state session_db session_idrestorerdeadline remainingrecorderclearers r_rollback_durable_cooldownrKsB j!%%m4Jj!%%m4J4 +-WY]^!]%:WX XZ})EF Dt T 0"CDKLX(889 q=tJ/1VX\]H!Zy1H(,,WlJmnd:.0TVZ[G  J/ 0 0 0s B4EEdurable_cooldown_authoritativedurable_cooldown_stateattempt_generationc B|/t||s#tjd|t|ddyt j |}t |5t5|xrtt|ddxsd|k7}dddr tjd| dddyd|vr1|dur-|dust|jd dst|||||jD]\}}t||| dddy#1swYxYw#1swYyxYw) anRestore the per-attempt snapshot after a pre-commit hard cancel. A restore stamped with a stale ``attempt_generation`` no-ops so a timed-out primary's late unwind cannot roll back state owned by the fallback attempt. ``attempt_generation`` (when provided) is the claim the calling attempt took via :func:`_claim_compressor_attempt`. See #96634. NzSkipping stale compressor attempt-state restore: attempt generation %s no longer owns the compressor (current: %s). A newer (stall-fallback) attempt's state is preserved.rrzuSkipping stale compressor attempt-state restore at write time: attempt generation %s lost the compressor mid-restore.rbFTrc)rrwarningr2r|r}rrrrVrrr)setattr) r~rrrrrestoredlostrvalues r!_restore_compressor_attempt_staterhsE%.LZYk.l @  4UW[ \ }}X&H ) 4- % D%D#gjBcef.g.lkl*mrD+DD D  NNOPb  -- . 9.e;/47tHLLQkmrDs?t &z8=[]s t#>>+ -KD% Je , -%-- D D--s+D"D ;!D%AD D DDc\ ddlm}t||syt|}|j d}|j d}||syt t |dd}t|sy|||}t|ts td |j|d t |d d} | d ur| dfSt|}tD]"} | |vstj || || <$d tj |fS#t$r }tjd |Yd}~yd}~wwxYw)a5Refresh and snapshot built-in durable cooldown state under the lease. Third-party compressors are not invoked: plugin code must not run under the lease. Returns ``False`` on durable read failure (rollback must not mistake unknown state for an empty row) and ``None`` when the legacy API is absent.rContextCompressorNNrrN$get_compression_failure_cooldown_rowFNz3raw compression cooldown snapshot must be a mappingTrefreshz5authoritative compression cooldown capture failed: %s(_last_cooldown_refresh_was_authoritative)r%rr&ryrr2rrr(rz'get_active_compression_failure_cooldownrrr!_COMPRESSOR_COOLDOWN_STATE_FIELDSr|r}) r~attempt_snapshotrrrr raw_readerrrrrs r+_capture_authoritative_cooldown_under_leasers8>*&78j!ZZ . ZZ .  ZT*-/UW[\  #":z: -.QR RAA*VZA[J(RTXYMD d"" * F1A 6>%)]]6$<%@ T "A }- --  LcRs(D1D!D)7D D+ D&&D+c eZdZdZdddZddZddZeddZeddZ eddZ d d Z dd!d Z d"d Z dd!d Zdd ZeddZeddZddZddZeddZddZddZddZddZd#dZd$dZddZy)%CompressionCommitFencea Fence timeout cancellation against post-summary session mutation. The sync worker thread cannot be killed; the fence makes the commit boundary deterministic: cancellation wins before mutation starts, or waits for an already-started commit to finish completely.Ncrtj|_d|_d|_tj |_d|_tj|_d|_ d|_ tj|_ d|_d|_d|_d|_||j%|yyNF)rr_lock _cancelled_commit_startedEvent _commit_phase_admission_revoked_lock_release_guard_cancelled_lock_release!_cancelled_lock_release_requestedrr_last_progress_progress_observed _deadline(_retain_cancelled_lock_until_worker_done_commit_watermark_fencedset_total_ceiling_seconds)selftotal_ceiling_secondss r__init__zCompressionCommitFence.__init__s^^% $'__. #($->>#3 EI$16."nn."''+8=5(-% ,  * *+@ A -rOcrt|}|dkr tdtj|z|_y)z:Arm the wall-clock deadline shared by the host and worker.rz*total compression ceiling must be positiveN)r ValueErrorrrr)rsecondss rrz0CompressionCommitFence.set_total_ceiling_secondss1. a<IJ J)G3rOcDtj|_d|_y)zURecord forward progress (a streamed token); a bare float store is atomic, so no lock.TN)rrrrrs rtouch_progressz%CompressionCommitFence.touch_progresss"nn."&rOc|jS)zAWhether semantic provider progress was reported for this attempt.)rrs rprogress_observedz(CompressionCommitFence.progress_observeds&&&rOcT|j}|duxrtj|k\SN)rrr)rrs rdeadline_exceededz(CompressionCommitFence.deadline_exceededs'>>t#D(8H(DDrOc|jS)uXArmed deadline (absolute monotonic); the worker's stream consumer stops when the host stops waiting. :meth:`set_total_ceiling_seconds` documents this deadline as "shared by the host and worker", but until #99692 only the host could read it — ``deadline_exceeded`` answers "is it past?" for a caller that is already polling, which is useless to a worker blocked inside a provider stream. Publishing the instant itself lets the worker's stream consumer stop at exactly the moment the host stops waiting (see ``auxiliary_client.aux_stream_deadline``). )rrs rdeadline_monotonicz)CompressionCommitFence.deadline_monotonics~~rOcXtdtj|jz S)z8Seconds since the worker last reported forward progress.r)rrrrrs rseconds_since_progressz-CompressionCommitFence.seconds_since_progress s!3(4+>+>>??rOc|j5|jsd|_||j|j cdddS#1swYyxYw)zYCancel a pending commit (``True``), or block until an active commit finishes (``False``).TN)rrrsetr cancel_events rcancel_before_commitz+CompressionCommitFence.cancel_before_commitsL ZZ ,''"&'  "+++  , , ,s 2A  Ac|jjdsy |jsd|_|j |jj S#|jj wxYw)zZNon-blocking :meth:`cancel_before_commit`; ``None`` while an active commit owns the fence.FblockingNT)racquirerrreleasers rtry_cancel_before_commitz/CompressionCommitFence.try_cancel_before_commits\zz!!5!1 !''"&+++ JJ   DJJ   s AA5c\|jj|js'|js|Wt |j r>d|_|jj|jr|jyd|_ |jjy)z?Atomically admit commit unless a hard cancellation already won.TF) rr  is_cancelledrrVis_setrr "release_cancelled_compression_lockrrrrs r begin_commitz#CompressionCommitFence.begin_commit"s     7 7L   "   " "  3 3 5 #rOc6|jjS)zbLock-free read: an admitted commit is in progress (hosts reach the overrun loop on a hung commit).)rrrs rcommit_in_flightz'CompressionCommitFence.commit_in_flight9s!!((**rOcR|jxs|jxs |jS)z7True after cancellation won before the commit boundary.)rrrrs rrz#CompressionCommitFence.is_cancelled>s$S$"9"9ST=S=SSrOcd|_y)z9Prevent a timed-out live worker from overlapping a retry.TNrrs r)retain_compression_lock_until_worker_donez@CompressionCommitFence.retain_compression_lock_until_worker_doneCs 8<5rOcd|_y)u]Record a watermark-bounded commit (later rows survive as tail); a detached worker may keep admission. Called by the compression worker right after it captures ``get_active_message_watermark()`` under the durable compression lock (#75316/#87484). A watermark-fenced commit archives ONLY rows at or below the watermark; rows appended later — e.g. the user turn the host released at the turn-hold boundary (#97963) — are cloned as live concurrent tail. That is exactly the property a host needs before letting a detached worker keep its commit admission. TNrrs rmark_commit_watermark_fencedz3CompressionCommitFence.mark_commit_watermark_fencedGs )-%rOc|jS)z9Lock-free read: the worker's commit is watermark-bounded.rrs rcommit_watermark_fencedz.CompressionCommitFence.commit_watermark_fencedRs,,,rOcd|_y)zdUndo :meth:`retain_compression_lock_until_worker_done` once a bounded join proved the worker exited.FNrrs rallow_cancelled_lock_releasez3CompressionCommitFence.allow_cancelled_lock_releaseWs 8=5rOcd|_|jjdr, |j|jj yy#|jj wxYw)aCRevoke FUTURE commit admission without blocking on the fence lock. An in-flight commit is never abandoned (``begin_commit`` re-checks the flag under the lock). The lease release must not run mid-commit: released now if the lock is free, else deferred to ``finish_commit``/refusal (holder-qualified).TFr N)rrr rr rs rrevoke_commit_admissionz.CompressionCommitFence.revoke_commit_admission[s[ #' ::  u  - %779 ""$ . ""$s AA-c|jj|js |jr|jj yy)zbHold the fence across lock acquisition + release-hook publication so a timeout cannot win between.FT)rr rrr rs rbegin_lock_setupz'CompressionCommitFence.begin_lock_setupos9     7 7 JJ   rOc8|jjy)z@Leave a lock setup boundary entered by :meth:`begin_lock_setup`.N)rr rs rfinish_lock_setupz(CompressionCommitFence.finish_lock_setupws rOc|j5||_|j}dddr||S#1swYxYw)zhPublish the worker's holder-qualified release; if cleanup was already requested, run it and return True.N)rrr)rr  requesteds rregister_cancelled_lock_releasez6CompressionCommitFence.register_cancelled_lock_release{sC  % % ?+2D (>>I ?  I  ? ?s4=cp|j5|j|urd|_dddy#1swYyxYw)z>Forget ``release`` after the worker's normal cleanup finishes.N)rrrr s rclear_cancelled_lock_releasez3CompressionCommitFence.clear_cancelled_lock_releases6  % % 4++w6/3, 4 4 4s,5c|jry|j5d|_|j}ddd|yy#1swYxYw)zdAfter cancellation won: release the worker's lock (a request ahead of hook publication is retained).NT)rrrrr-s rrz9CompressionCommitFence.release_cancelled_compression_locksQ  8 8   % % 359D 222G 3   I  3 3s AA r)r float | NonereturnNone)rrr1r2r1r2r1rV)r1r0)r1r)rrr1rV)r1Optional[bool])r Callable[[], None]r1rV)r r6r1r2)__name__ __module__ __qualname____doc__rrrpropertyrrrrrr rrrrrrr r"r$r&r(r+r.rrOrrrsa#BJ4' ''EE  @, ! 6++TT= ---> %(4 rOrg^@g@stall_interruptedg>@g@cd}tjtt5t t |d}ddd |j |y#1swYxYw#tjj$r|jcYStjj$rYyt$rtjddYywxYw)aBest-effort bounded join of a fence-cancelled compression worker. Returns True when the future settled within ``grace_seconds`` (thread provably exited); False for a still-running worker, which the caller must treat as an orphan behind the poison fence.rNtimeoutTz5cancelled compression worker exited with an exceptionr)rrrzrrrresult concurrentfutures TimeoutErrordoneCancelledErrorrrr)future grace_secondsgraces r_join_cancelled_workerrJs E   Y 3/E-(#./  e $ //    * *{{}    , ,  LW[ \s)AAA-CC,C Cc|t5ttk\r dddytdz a dddy#1swYyxYw)z9Reserve one bounded compression-pool admission slot (F6).NFr9T)_compress_admission_lock_compress_admitted_count_COMPRESS_EXECUTOR_MAX_WORKERSr<rOr_try_admit_compression_jobrPsB " #'E E !A%  s 2 2;c^t5tdkDr tdzadddy#1swYyxYw)z?Free an admission slot (future done-callback or failed submit).rr9N)rMrN)_futures r_release_compression_admissionrSs/ "* #a ' $ ) $***s#,ct}||Sddlm}t5t|tdatcdddS#1swYyxYw)zBReturn the process-wide compress-timeout DaemonThreadPoolExecutor.Nr)DaemonThreadPoolExecutorzcompress-ctx-timeout) max_workersthread_name_prefix)_compress_timeout_executortools.daemon_poolrU_compress_timeout_executor_lockrO)executorrUs r_get_compress_timeout_executorr\sK*H: (* % -)A:Oe* &* ***s ;Ac6t}t}|}|ii}tjt5ddlm}|}t|tr|jdini}t|tr|ni}dddt|trtjtt5|jdt|d}dddtjtt5|jdt|ddkDrt|d}ddd|dkDrFt||}ddlm}t|dd}|dkDr||kDr|}t|t!||}||fS#1swYxYw#1swYxYw#1swYqxYw)zReturn ``(idle_timeout_seconds, total_ceiling_seconds)``. ``idle_timeout_seconds <= 0`` disables the progress-aware wrapper. The ceiling is clamped to at least one idle window when the idle budget is positive.Nr) load_config compressioncontext_timeout_secondscontext_total_ceiling_seconds)_effective_aux_timeout)DEFAULT_CONTEXT_TIMEOUT_SECONDS%DEFAULT_CONTEXT_TOTAL_CEILING_SECONDSrrrhermes_cli.configr^r&r(rrzrrragent.auxiliary_clientrbmin) compression_cfgidleceilingcfgr^rawmayberb _aux_budgets r$resolve_context_compression_timeoutsros +D3G C {   + ; 5-C2?4G G 5#44== z "   z "s4 A'A<"B 'A98A9< BB BBc4t|dd}t|ddxst|ddxsd}t|tr t|nd}d}t j t t5t|xsd}dddd|d|d |S#1swYxYw) z:Identity of the stalled source context + summary strategy.context_compressorNrsmodelrDrzmsgs=z:tokens=z:model=) r2r&r'lenrrrzrr)r4messages approx_tokensr~rx n_messagesr6s r_stall_source_fingerprintr};s 4d;J J 6 ]'%RV:W ][]E",Xt"<X!J F   Y 3)]'a() :,hvhgeW ==))s +BBcFt||syt|dd}t|dd}t|sytdt |||} ||dt jd t|d dxsd|y #t $rt jd d YywxYw)zPersist a stall-interrupted cooldown after snapshot restore. Must run *after* ``_restore_compressor_attempt_state`` so rollback cannot wipe the new row. Returns True when the backoff was recorded.)rrrsFrwNrecord_timeout_failure:r=) failure_kindz5stall-interrupted compression cooldown persist failedTrz?Recorded stall-interrupted compression backoff (session=%s, %s)rnone) rur2rSTALL_INTERRUPTED_FAILURE_CLASSr}rrrrT)r4rrrsrzr{r~recorderrors r!_record_stall_interrupted_backoffrFs 'LZ X 4d;JZ!94 @F F ./q1J5RZ\i1j0k lEu#67 KKI7SXZfhlKmKwqw    LW[ \s A== B B c ^ ddlm}m}|djd}t|tsyt|D]\}}t|tst|jd xsd j}t|jd xsd j}|r|su ||}dd lm }||jd} d|d|d||t|jdxsd jxsd|xsdt|jdxs|jdxsd jxsd| dcSy#t$rt j ddYywxYw#t$rt j d |dd}YwxYw)aReturn the first usable ``auxiliary.compression.fallback_chain`` entry. The aux client applies the chain only from its exception handler, so a silent stall never reaches it; this pins the route onto one bounded retry instead. Only the first complete entry: if it errors, the aux client's own exception path walks the rest. ``None`` when none is usable (skip compression).r)_fallback_entry_api_key_get_auxiliary_task_configr_fallback_chainz(compression fallback_chain lookup failedTrNproviderrDrxz8compression fallback_chain[%d] api key resolution failed)_coerce_positive_timeoutr@zfallback_chain[z]()base_urlapi_mode transport)labelrrxrapi_keyrr@)rfrrrrrrr&r' enumerater(rGrHr) rrchainindexentryrrxrrr@s r"resolve_compression_fallback_routerbs ^*=9==>NO eT "!%( u%& uyy,2399;EIIg&,"-335u  -e4G D*599Y+?@&ugRz; EIIj17R8>>@HD$EIIj1QUYY{5KQrRXXZb^b  ! 2 =  ?$ O   LLSUZeiL jG s#E 3F FF#F,+F,ctfDcgc]}|| }}|r ddlm}|jt ||Scc}w)zPinned routes for the stall retry, in order: the configured chain entry, then (only once a stall-class backoff has already burned a window in this session) the deterministic fallback summary.r)DETERMINISTIC_SUMMARY_ROUTE)rr%rappendr()escalate_deterministicrouteroutesrs r_stall_retry_routesrsF#E"F!H ^EL]e ^F ^H d678 M _s AAcztt|dddd}t|trt|ts|SdS)zZTimeout-class failures this session that no healthy summary has cleared yet (type-pinned).rwNrer)r2r&rrV)r4counts r_prior_timeout_failuresrs: GE#7>@_ab cEuc*:eT3J5QPQQrOctt|dddd}t|tst|tr|dkryt|tst|tsy||kDS)aWhether a ~``request_tokens`` request cannot be sent at all (above the model's context window). ``None`` when either side is unknown (no compressor / unresolvable window / no estimate), so callers keep their conservative default instead of treating "unknown" as "fits".rwNcontext_lengthr)r2r&rVr)r4request_tokenswindows rrequest_exceeds_model_windowrs[WU$8$?AQSW XF&$z&#'>&A+.$'z.#/N F ""rO)on_commit_overrunon_timeout_causetelemetry_agent new_fencerc t|dd} tt| ddr| jryt| D]} t | ||||||||| } | | cSy)uMRe-run an aborted compression with the summary route pinned: once on the configured chain entry, then — when ``escalate_deterministic`` (a stall backoff already burned one idle window this session, #112420) — once with the summary LLM skipped so compress() commits its deterministic fallback summary. Returns ``(messages, system_prompt)`` on real compression, else ``None`` and the caller degrades as before. The entry's ``timeout`` sets the idle window. Re-runs the whole worker, so pre-compression callbacks must be idempotent. The retry is bounded the same way the primary was: silence for one idle window ends it, while a fallback that is streaming keeps its ceiling. The entry's own ``timeout`` (when declared) sets that idle window, so a fallback tuned for a slower-but-healthy backend is not held to a deadline the stalled primary defined (#62452 semantics, applied to the stall path). Known limitation (accepted, #96634 review): the retry re-runs the COMPLETE worker, which repeats memory/plugin pre-compression callbacks. Built-in callbacks are idempotent (re-reads and overwrites of attempt-scoped state); third-party plugin callbacks are advised to be. Splitting the worker to resume mid-pipeline would couple this path to every host's callback ordering — deliberately out of scope. _hard_interrupt_requestedNr) workerrzsystem_prompt_fallbackrprrrrr)r2rrr_run_pinned_compression_retry) rrzrrprrrrrr hard_cancelr recovereds r$_retry_compression_on_fallback_chainrs2/+FMK Xt45+:L:L:N$%;<1 &8Lb!5Mb/BRds     rOc d} |  | } t| tstjdt } t |j dxs|} tt || } |j ddu} | rtjd|d ntjd |d |d t|d d}t|d d} ddl m }||5t|||| | ||| |d \}}ddd|urtjd|d yt|d d}| s%t|tr2t|tr"||kDrtjd|d |fStjd|d |fS#t$rtjddYwxYw#1swYxYw#t$rtjd|d dYywxYw)zaOne bounded re-run of ``worker`` with ``route`` pinned; ``None`` when it produced no compression.Nzcompression stall-fallback fence factory failed; the retry will run on an unpublished fence (a /stop mid-retry cannot serialize against its commit boundary)Trzcompression stall-fallback retry running on an unpublished fence; hard-interrupt admission will read the aborted attempt's fence rather than the retry's commit boundaryr@ deterministicuContext compression stalled on every summary route — committing the %s (no summary model) before continuing without compressionru~Context compression stalled on the configured summary route — retrying once on %s (%s) before continuing without compressionrxrwr_r)pin_summary_routeF) rrzrrprrrfencerstall_fallbackz1Context compression fallback attempt on %s failedzbContext compression fallback attempt on %s produced no compression; continuing without compressionzContext compression committed a deterministic fallback summary on %s after the primary summary route stalled (no summary model produced output)zKContext compression recovered on %s after the primary summary route stalled)rrrr&rrrrr2r%r*run_compress_context_with_progress_timeoutrrT)rrrzrrprrrrr retry_fencerirjrr~ streak_beforer result_msgs result_prompt streak_afters rrrs(K #+K k#9 : u -. 9%=)= >D%-.5GIIo.$6M 45:7^  MNST[n^cdk^l *>EJJ(FJM > u % )SI_%)\m!1Ve$ * &K h p 'N :'EqILL#6:mUX;Y^jmz^z 9:?.  %%  achipcqr  %%u  NNt   :    JERYNeij s;FG$F8=G F54F58G=G$G+*G+cV tj|z }||z }|dkry|j}tt ||z d|} d|j |fS#t jj$r|jr>|j} | d|j fcYStjd| Yytj|z }|j}|js%||kr ||krtjd|||Y$YywxYw)zTPoll ``future`` under the idle budget + ceiling; ``(True, result)`` when it settled.Trrg{Gzt?r?uCContext compression worker exited with %r — taking the stall pathulContext compression still streaming after %.0fs (last progress %.1fs ago) — extending wait (ceiling %.0fs))rrrrgrrArBrCrDrE exceptionrrTr) rGrrirj wait_startedwaitedremaining_ceilingsince_progress wait_slicers r_await_worker_within_budgetrs% !L0#f,  !557TN2E:>GT@RSI q O$3q$8&..fllC OPVY`P`bh   $(9(E#' OZ^_7%fg67 ===3 377!!.. {{}}}&  s B1B=1B:==C?>C?cr |jry|j}||Stjd7)zSCancel pre-commit; ``False`` when an admitted commit owns the fence (caller waits).Fg?)rr rsleep)r cancelleds r_cancel_or_join_workerrbs@   ! !224    5 rOc|rCtt|}t||r|jntj d||j y)aQIdle-timeout unwind: free the worker's durable lease via the holder-qualified hook. Total-ceiling only: bounded grace for the worker to exit (it checks the fence between provider phases; an uninterruptible call is orphaned). Idle-stall skips the join: the worker is hung, the fallback needs a prompt return, the fence guards.uCancelled compression worker did not exit within %.1fs grace — orphaning it behind the poison fence (late result will be discarded); retaining the session compression lease until it exits so no new attempt overlaps itN)rg(_CANCELLED_WORKER_TEARDOWN_GRACE_SECONDSrJr"rrr)rGrtotal_exhaustedrjrIs r_release_cancelled_workerrqsO 0; call compress_context directly to disablec,trSSr)r)rsr_resolve_fallback_promptzLrun_compress_context_with_progress_timeout.._resolve_fallback_prompts+34J+K%'gQggrONr9)propagate_context_to_threaduContext compression pool saturated (%d workers busy) — refusing new compression this cycle and continuing without compression. Wedged workers are fence-cancelled and free their slot when they return; if this persists, check the summary provider health.abortedpool_saturatedrs commit_status split_status failure_classc|jrtjjd|jrt j ddfS|S)Nz0compression deadline expired before worker startz._fence_gated_workersQ  ) )$$112de e  $ $ KKV WR< l##rOF)rirjrTz.compress_context timeout-cause callback failedr)rjrr)rrj) rrzrrprrrrrrz(compress_context timeout callback failedzpContext compression made no progress for %.1fs (total wait %.1fs, ceiling %.1fs); continuing without compression)r1rG)rr) rrrrrrtools.thread_contextrr\rPrrrO#_emit_compression_attempt_telemetryrrsubmit BaseExceptionrSadd_done_callbackrr$cancelrrr rrrrrr)rrzrrprrrrrrrrrrrrjrirrr[rrGr handled_exitsettledrArrrrs``` rrrsq$q  R  h%-.6J0KLG % &D &E,B,DE ##G, ,O"9/"Ja"O A-/H & ' Z +    & /DNN,>#LLE,5 EgL  Lx  ) ) +q  ..*\9WD_H_H_   ; ; =  'JUYZ K %2I2IJ K%e,,lVgF LD  ) ) += !&%Zab!L0557 <&0&8\r%)\m!1?^g'= I $   ) ) +  !DtT 948 9 9 NN-vw  133  ) ) +U &( B K K< 9 9  ) ) +s\%J<)K-AK-.K%K-;AK-%K-4 K!?)K-<KKK-!K*&K--LceZdZdZy) CompressionCheckpointUnavailablezGRaised when required durable pre-compress checkpointing is unavailable.Nr7r8r9r:r<rOrrr+sQrOrzlset compression.checkpoint_required: false, or switch to a memory provider that implements checkpoint API v2cRt|dd}|yt|dd}g}|a t|}|D]P}t|dd}t|ts!|j s2|j |j R|rdj|SdS#t$rg}YwwxYw)zBHuman-readable active provider name, or an explicit none sentinel._memory_managerNzno active provider providersrz, )r2r'rzr&rGrHrjoin)r4memory_managerrnamesiterablerrs r_active_memory_provider_labelr7sU$5t*>>  H s B B&%B&ctd|S)NzLBLOCKED_MISSING_PREREQUISITE: required pre-compress checkpoint unavailable: )rreasons r_checkpoint_blockedrJs + VW]V^_ rOc*t|dtS)uCapability refusal: the gate can never pass with this provider set, so the message carries the config-level way out. Transient checkpoint failures keep the plain form — there the provider is capable and the right move is a retry.z . Recover by )r _CHECKPOINT_REQUIRED_REMEDIATIONrs r_checkpoint_incapablerPs &7W6XY ZZrOcPt|ddduryt|dd}|0t|dd}t|r t|try t jd t|tty#t$r"}t j d|dYd}~yd}~wwxYw) uStartup warning when fail-closed compress will block (init itself must not refuse). Capability-probe exceptions are suppressed so a broken provider cannot crash agent construction — same fail-open style as the micro-compact warning. Probe failures log at DEBUG so a flaky probe can be diagnosed without refusing init or emitting the incapable-provider WARNING. compression_checkpoint_requiredFTNr supports_pre_compress_checkpointz?checkpoint-required capability probe failed; init continues: %srzcompression.checkpoint_required is enabled but the active memory provider (%s) does not implement checkpoint API v%s. Compress will fail closed. Recover by %s.) r2rrVrrrrrrr)r4rsupports_checkpointrs r2_warn_checkpoint_required_without_capable_providerrWsu7?tKU$5tEmit one content-free JSON log line for a compression attempt.z0failed to emit compression attempt telemetry: %srtNeventcompression_attempt attempt_id_compression_attempt_idrDr)total_duration_msrrr commit_msrchunkingF chunk_count fallback_usedrhrpz)context compression attempt telemetry: %sT),r) sort_keys separators)r rwr2r&r( setdefaultuuiduuid4hexupdaterrrrrVrrrTjsondumps) r4rsrrrr!r~ telemetrypayloads rrrs D E -- J(EtL )T*Iy/7$9:<8QSU)V)jZ^ZdZdZfZjZjk< b)I)ORP!4>>#3j#@D"HIYf%    ($ FF A As )A""A+c|j}t||tt|dd}t |syd}|rHt j tt5dtj|jv}dddt|r ||dn||}|r t|||S#1swY6xYw)a:Refresh durable guards, then evaluate the compressor's automatic breaker gate. ``bypass_cooldown`` ignores the cooldown when the gate accepts ``ignore_cooldown`` (engines predating it get the legacy no-argument call). When blocked, the transient-block signal is published for automatic-path consumers. r_automatic_compression_blockedNFignore_cooldownT)ra)rwrr2rrrrrzrr  signature parametersrV#_mark_compression_blocked_transient)r4bypass_cooldownrr~blockedacceptsrAs r"_automatic_compression_gate_blocksrhs ))J)*GWXd:&(H$OG G G  J 7 Q'7+<+ M  Q Qs "B55B>cVt|dd}t|txr t|S)uoType-pinned read of the transient-block signal. Set when an automatic pass no-ops on a TRANSIENT guard (summary-failure cooldown or structural backoff). Consumers must defer, not count it toward ``compression_exhausted``, or an overflow auto-reset wipes a session that was merely cooling down. The permanent ``ineffective`` breaker never sets it. See #97488. Consumers (the overflow-recovery loops in ``conversation_loop``) must treat such a no-op as a temporary defer, NOT as evidence the session is incompressible: counting it toward ``compression_exhausted`` lets a real upstream ``context_length_exceeded`` auto-reset (wipe) a session whose compression was merely cooling down (#97488). The permanent ``ineffective`` breaker intentionally does NOT set this signal — a genuinely incompressible session must still be able to exhaust. _compression_blocked_transientN)r2r&rGrVrFs rcompression_blocked_transientlyrk-s) 5:D AD dC /T$Z/rOc t|dd}d}t|rtdd5|}dddt|tr|j ds|j dr`t jd|t|d dxsd t|d dxsd tjt5||_ dddyyy#1swYxYw#1swYyxYw) zPublish the transient-block signal when the active guard is transient. Classification comes from ``_compression_block_reason``: ``cooldown:*`` and ``structural_backoff:*`` are transient; ``ineffective`` stays unmarked._compression_block_reasonNz$compression block-reason read failedTrcooldownstructural_backoffuSkipping automatic compression re-entry: transient guard active (%s, session=%s, last failure: %s) — will retry after the backoff lapses; /compress forces an immediate retryrrrdunknown) r2rr r&rG startswithrrTrrrrj)r4r~ reason_fnrs rrdrd>s $?FI F  =2 compression hops (root -> mid -> tip) recovers to the live tip — the depth-1 ``find_live_compression_child`` lookup this used to call finds no live *direct* child in that shape and skipped recovery (#82001). The tip walk returns the input id when no continuation exists, and a resolved tip is adopted only while its row is still live — both cases fail closed exactly as before. get_compression_tipNrget_messages_as_conversationrT system_prompton_session_startz4context engine compression-child adoption failed: %sr_platformcli_gateway_session_key)boundary_reasonold_session_idrrconversation_idbind_session_state)rrz4memory manager compression-child adoption failed: %sFparent_session_idresetr)r2rrrGr&r(rr'rr{_session_db_createdr:ry_last_flushed_db_idx_flushed_db_message_session_idid_flushed_db_message_idsrwr rrrron_session_switch)r4rrresolver row_getterloadertipchild_session_idchildr confirmedrr bind_states r_adopt_live_compression_childr_sstJ')>EHj)=$?J T*%'Et LF H Xj%9&AQ :0 1C #c(c"3443x z#3 4E eT "eii &;&Gz#34I y$ 'I%67I I*::'E,- $E yy!&+O&<#!$YE+;E(@I$gWZX_aeMfR[$gE!u779KTR ! L M   -Pa%z40P0YTY '/Et L   U557KTR J $$Y/ Oj=MN O H I   ! ! 3 3 4EU[h 4  '%h   O O s0I I)I! I-&,I9!I*-I69Jctt|dd}t|sy |||rtj d|yy#t $r!}tj d||Yd}~yd}~wwxYw)zOReopen a compression-ended parent that has no continuation and no lease holder.#reopen_orphaned_compression_sessionNzGcompression recovery: reopened orphaned session=%s with no continuationz5orphaned compression session reopen failed for %s: %s)r2rrrrr)rrorphan_reopenerrs r_reopen_orphaned_parentrsod:.0UW[\O O $a :z 2 NNdfp q 3 aNPZ\_``asA A/A**A/ct|dd}t|ddxsd}||sy t||syt|dd}tdD]V}t|||}||cSt |r||nd}|st ||y|dk(ryt jdXy#t$r5}tjd |t|j|Yd}~yd}~wwxYw) zFRecover a stale live agent before a new turn writes to its old parent.rNrrDget_compression_lock_holderrz;compression session recovery failed for session=%s (%s: %s)) r2r rangerrrrrrrrrr7)r4rr holder_getterr;rholderrs r#recover_rotated_compression_sessionrs t4J d39rJ2:zJ ,I4P Ry G5eZTI$  2:=2I]:.tF' J?"} JJt    I:W[\_W`WiWikn  s. B$-B$ $B$B$ B$$ C"-+CC"c dtjdtjdt |ddt j jddS)zBuild a unique lock holder id: ``pid:tid:agent-instance:uuid``. pid+tid tell crashed holders apart in diagnostics; instance id and per-acquire uuid disambiguate co-resident agents on one thread or pooled compressions.zpid=z:tid=z:agent=xz:nonce=N)rxgetpidr get_identrr1r2r3rXs r_compression_lock_holderrsS"))+eI$7$7$9#:'"U)AgVZV`V`VbVfVfgihiVjUk llrO)rec>|||d}|rd|d<|r||d< tj|j}t d|j Dr|S|jD cic] \}} ||vs || c} }S#ttf$rd|icYSwxYwcc} }w)zReturn only compression kwargs accepted by an engine callable. Inspecting first keeps older plugin signatures compatible without catching ``TypeError`` and running a stateful compressor twice.)current_tokens focus_topicforceTrememory_contextrc3hK|]*}|jtjju,ywr)kindr  Parameter VAR_KEYWORD).0 parameters r z0_supported_compression_kwargs..s% `y9>>W..:: : `s02)r rbrcrzranyrr)) compress_fnrrrrre candidatesrcrrs r_supported_compression_kwargsrs%3;Y^_J(, $%'5 #$2&&{3>>  `JL]L]L_ ``+5+;+;+= TKD%ASD%K TT z "2!.112 UsB* B7BBBcpeZdZdZ d ddd ddZddZdddZddZddd dd Zdd Z dd Z y)_CompressionActivityHeartbeatzMRefresh the agent inactivity tracker while compression blocks in an aux call.NF)emit_client_statusrrcx||_||_d|_| t|dd} t |xsd}t j |sd}td||_ ||_ tj|_tj|j dd|_y#ttf$rd}YlwxYw)NF(_compression_activity_heartbeat_intervalN@皙?zcompression-activity-heartbeatTtargetrdaemon)_agent _commit_fence _suppressedr2rmathisfiniterzrr_interval_seconds_emit_client_statusrr_stopThread_run_thread)rr4interval_secondsrrrs rrz&_CompressionActivityHeartbeat.__init__s )!  #&u.XZ^_  $$%5%=> ==!12#' "%S*:!;$6 __&  ''tyy?_hlm :& $#  $s&B%%B98B9cnd|_|jdd|jj|S)NFzcontext compression startedT)allow_terminal_overwrite)r_touchrstartrs rrz#_CompressionActivityHeartbeat.starts2! 1D Q  rOc,|jj|jjruser assistantr tool_callscontent) r%rr&r(rrVrGrHr)r) rzrdirect_messagesrrr has_proser,r-s r(_direct_messages_for_pre_compress_memoryrPs I,.O>r ('4( {{6" , , <[0\  ; 7;;|#<kk),G 7C0HW]]_gVI(/ M11 ;Lq!tMGMw' ( Ns 2 CCcFeZdZ d ddZddZd dZd dZy) _CompressionLockLeaseRefresherNc||_||_||_||_|t dt d|dz }t dt ||_t dt|j|jz |_ tj|_ tj|jdd|_y) Nrrg@rr9zcompression-lock-refreshTr)_dbr_holder _ttl_secondsrrgr_refresh_interval_secondsr_max_consecutive_failuresrrrrrr)rdbrr ttl_secondsrefresh_interval_secondss rrz'_CompressionLockLeaseRefresher.__init__hs% ' # +'*3D+:K0L'M $),S%8P2Q)R&*-QD4E4EHfHf4f0g)h&__&  ''tyy?Ybfg rOc:|jj|Sr)rrrs rrz$_CompressionLockLeaseRefresher.startxs  rOc|jj|jjr>t j |jur|jj dyyy)Nrr?)rrrrrrrrs rrz#_CompressionLockLeaseRefresher.stop|sT  << "y'?'?'A'U LL  c  *(V "rOcd}d}|s%|jj|js|rd}|jjryd}t d5|j j |j|j|j}ddd|rd}|dz }||jk\r"tjd||jy|r|jj|jsyy#1swYoxYw)NrTFz#compression lock refresh raised: %srr9zZcompression lock refresh failed %d times in a row; stopping lease refresher for session %s) rrrrr rrefresh_compression_lockrrrrrr)rconsecutive_failuresfirst refresheds rrz#_CompressionLockLeaseRefresher._runs !4::??4+I+IJ::$$&I?@ } HH==d>N>NPTP\P\jnj{j{=|  }'($ A % #t'E'EE p($*:*:#4::??4+I+IJ  } }s =DD r) rrrrGrrGrrrr0r1r2)r1z '_CompressionLockLeaseRefresher'r3)r7r8r9rrrrr<rOrrrgsPrvhh#&h03hBGhcoh h +rOrcdt|dd|k(ry||_||_|j|y)zStore + emit a feasibility verdict once per distinct text: every main-runtime change re-probes, and an unchanged verdict must not re-warn on each `/model --once` restore or fallback cycle (#114707)._last_feasibility_noticeN)r2r_compression_warning_emit_diagnostic_status)r4msgs r_emit_feasibility_noticers7u0$73>%(E"!$E !!#&rOc |j}|j}|x}|_||_t|dd}t|dddk(rd|_n)t |t tfrt ||z|_|j} | r || z |_ | rt || z dznd} ddl m } d} | r=t || r1| j| | j| | dz t|d d} | duxs| |k} t|d d xsd }t|d d xsd }|r|dk7r|nd }|s ddlm}||j"xs|}|r|d|dn|}|d|d}d|d|dd|d|dd|dd }| r|d|dd| dz }n|d|dd|d| dd| dd |dd! z }t'||t(j+d"||||y#t$$r |xsd}YwxYw)#a;Lower the live threshold to the aux model's window and tell the user how to fix config. The summariser sends one user prompt (no system/tools), so threshold == aux_context is safe. Retention is recalibrated through its selected policy: lean is window-relative; only legacy follows the lowered threshold.summary_target_ratioN tail_modeleand2rr max_tokensrxrD?rauto)urlparsez (ru⚠ Compression model z context is r-z tokens, but the main model z's compression threshold was z2 tokens. Auto-lowered this session's threshold to z tokens so compression can run. u To make this permanent, edit config.yaml — either: 1. Use a larger compression model: auxiliary: compression: model: 2. Lower the compression threshold: compression: threshold: 0.02dz To make this permanent, use a larger compression model in config.yaml: auxiliary: compression: model: (Lowering compression.threshold cannot help here — with z's zb-token window, Hermes's small-context floor and output reservation would recompute the trigger to z- tokens, still above the compression model's z.)uAuxiliary compression model %s has %d token context, below the main model's compression threshold of %d tokens — auto-lowered session threshold to %d to keep compression working.)rwthreshold_tokens_aux_context_ceilingr2_tail_token_budgetr&rrtail_token_budgetrthreshold_percentr%r_compute_threshold_tokens_effective_threshold_percent urllib.parserhostnamerrrr)r4 aux_model aux_context aux_provider aux_base_urlr~ old_threshold new_thresholdrmain_ctxsafe_pct_CCrecomputed_thresholdthreshold_suggestion_viable _main_model_main_provider_aux_provider_labelr _main_label _aux_labelrs r_lower_threshold_to_aux_contextr9s))J//M2==MJ/'2J#":/EtLz;-7(, % (3, 7'*=;O+O'P $((H'4x'? $6>sK(*c12BHBJz3/"<< c66xCP J d 3 #7$">"eBVZeBe%"-4KUJ39rN*6<6;Q,WY  9 -"*<"8"A"A"Q\ :H[MN#315[K;b!4 5Q7J  LQGc -4]14EF44A!3DDe g # WWdefVghaaijm`n p  DDQRSCTUKKV-WZ[cdeZfgb#A&&ST_`aSbbd  f UC( NN WXacn}1 9"."8&  9s&F::G  G c 4ddlm}t|xsdjj tt |ddxsdjj k7ry|tt |ddxsd}| xs |||k(S)zRTrue when the auxiliary compression client is the main model on the main endpoint.r)normalize_route_base_urlrDrxFr)hermes_cli.route_identityr;rGrHrJr2)r4r)r,r; main_bases r_aux_inherits_main_router>sB 9?!!#))+s75'23N3TRT/U/[/[/]/c/c/ee(WUJ-K-Qr)RSI= O4\BiOOrOc d|jsy ddlm}m}m}ddlm}m} |d\}}}}}|d|j\}} || sB|d|\} } } | 3| r1| | } }d| vr)| jd r| jdd d dd }|| s2|r |d k7rd |d} nd} t|| tjdytt!|dd}t!|dd}t#|rt%|tsdnt|xsd}|r|d k7r|n t!|dd}t!|dd}|-t'|| |r t)|j*j,}n|| |||||j.}|r"||krt1d| d|dd|dd|dzd ||j*j2krt5|| |||yt!|ddd|_d|_yy#t$rd}YwxYw#t0$rt$r }tj;d|Yd}~yd}~wwxYw) zWarn at session start if the aux compression context is below the threshold. Called from ``AIAgent.__init__`` (CLI sees it via ``_vprint``); the gateway wires ``status_callback`` later, so ``replay_compression_warning`` resends it.Nr)_resolve_task_provider_model/_try_configured_fallback_for_unavailable_clientget_text_auxiliary_client)MINIMUM_CONTEXT_LENGTHget_model_context_lengthr_rD) main_runtime(rr9ru/⚠ Configured auxiliary compression provider 'z' is unavailable, so older messages in long chats will be cut without a summary. Sign in to that provider again, or change auxiliary.compression in your config.u⚠ No auxiliary LLM provider configured: Hermes has no helper model for summarising long chats, so older messages will be cut without a summary. Run `hermes setup` to add one.uLNo auxiliary LLM provider for compression — summaries will be unavailable.rrr&_aux_compression_context_length_config)rrconfig_context_lengthrcustom_providerszAuxiliary compression model z has a context window of r-z$ tokens, which is below the minimum zE required by Hermes Agent. Choose a compression model with at least r'zK context (set auxiliary.compression.model in config.yaml), or set auxiliary.compression.context_length to override the detected value if it is wrong.)r)r*r+r,rz4Compression feasibility check failed (non-fatal): %s)compression_enabledrfr@rArBagent.model_metadatarCrDr_current_main_runtimeendswithrsplitrrrrGr2rr&r>rrwr_custom_providersrr r9rrr)r4r@rArBrCrD_aux_cfg_provider_clientr) fb_clientfb_modelfb_labelrr, _raw_aux_key aux_api_key _aux_provider _aux_cfg_ctxr*rs r#check_compression_model_feasibilityr[s  $ $SR   Z #,H,W ) q!Q6mRWRmRmRop >,[0- )Ix$$-x (?x'8'8'=(0Q(?(B3B(G% > %6&%@EFWEXYVVr %UC 0 NNi j 76:r:; vy"5 %l3J|UX ! u $ GE6 >?H~ rO)z-[System: Your previous response was truncatedz*[System: The previous response was cut offz [System: Your previous tool callz@[Your active task list was preserved across context compression]z[IMPORTANT: Background process ct|tr|jdnd}t|tr|St|trdj d|DSy)Nr c3K|]F}t|tst|jdxs|jdxsdHyw)rKrrDN)r&r(rGr)rparts rrz _message_text..sB CGV`aegkVlC =DHHY$7=2 > s A6ArD)r&r(rrGr'r)rrs r _message_textrrsW(27D(Agkk)$tG'3'4 yy KR    rO)_todo_snapshot_synthetic_empty_recovery_synthetic_verification_stop_synthetic_pre_verify_synthetic_dropped_toolcall_nudgecttrjddk7rytfdtDryt j }|r|jtryddl m }|j S)zDistinguish human intent from user-role runtime scaffolding. A compaction summary flipped to ``role="user"`` for alternation is scaffolding and must not short-circuit anchor restoration.rrFc3@K|]}j|ywr)r)rflagrs rrz(_is_real_user_message..s ?7;;t  ?srr) r&r(rr_SYNTHETIC_USER_FLAGSrrrHrq_SYNTHETIC_USER_PREFIXESr%r#_is_synthetic_compression_user_turn)rrKrs` r_is_real_user_messager~sp gt $ F(;v(E ?)> ??  ! ' ' )D 4??#;<: DDWM MMrOz[OUT-OF-BAND USER MESSAGEz[/OUT-OF-BAND USER MESSAGE]cR ddlm}m}||fS#t$rtt fcYSwxYw)zU``(open, close)`` steer markers from prompt_builder, or the stable fallback literals.rSTEER_MARKER_CLOSESTEER_MARKER_OPEN)agent.prompt_builderrrr_STEER_FALLBACK_OPEN_STEER_FALLBACK_CLOSErs r_steer_markersrs1;N "444 ;#%:::;s &&cLt|}|syt\}}||vxr||vS)zReturn whether *message* carries a busy-steer marker. Steer follow-ups are now their own ``role=user`` rows (caught by ``_is_real_user_message``); in transcripts persisted before that they ride inside ``role=tool`` results, so those still count.F)rrr)rrK open_marker close_markers r_message_contains_busy_steerrs6  !D  . 0K $  7<4#77rOct|}|syt\}}|j|}|dk(rJ|jt}|dk(ry|jd|}|dk7r|dzn|t tz}n|t |z }|j||}|dk(r|jt |}|dk(ry|||j xsdS)z9Extract the inner user text from a steer marker, or None.NrGror9)rrrfindrryrrH)rrKrrrnlends r _extract_steer_text_from_messagers  !D  . 0K IIk "E { ./ B; YYtU #(Q4H0I(I [!! ))L% (C byii-u5 "9 c? " *d*rOc&td|DS)zWhether *messages* already carries a steer marker in a ``role=tool`` row. Only tool rows count, so a summary merely quoting the marker text is not mistaken for live intent.c3K|]7}t|txr!|jddk(xr t|9yw)rtoolN)r&r(rr)rrs rrz-_compressed_has_busy_steer..s=fi 3a#''&/V";a@\]`@aas=?)rrzs r_compressed_has_busy_steerrs mu rOcddlm}t|tr+|j |}|dk(r|S|d|j St|t rg}|D]}t|tr2|jddk(rt|jdxsdnd}|r|j |nd}|dk(r|j|s|d|j x}s|ji|d|i|S|S)zRemove a previously merged todo-snapshot block from message content. Snapshots are appended to the trailing user turn, so a surviving header is stale; stripping before re-injection prevents accumulation across boundaries.r)TODO_INJECTION_HEADERrGNrrKrD) tools.todo_toolrr&rGrrstripr'r(rr)rridxcleanedrqrKstrippeds r_strip_stale_todo_snapshotrs6'3ll01 "9Nt}##%%'4  ;D2>###'4 Z$%?| rOc*ddlm}||d<||y)zFRewrite message content without allowing an old API sidecar to replay.r)drop_stale_api_contentrN)agent.turn_contextr)rrrs r_replace_message_contentr s9 GI7#rOuJ[Skills pruned during compression — reload before acting on these tasks]cddlm}m}g}|D]?}t|ts|t |D]}||vs|j |A||d=|sydjd|D}td|dS) zReload notice for skills whose bodies were pruned, or ``""``. Scans ``[SKILL_PRUNED: ...]`` markers in the post-compression transcript; first-seen order, deduplicated, capped at ``_MAX_PRUNED_SKILL_MARKERS``.r)_MAX_PRUNED_SKILL_MARKERS_extract_pruned_skill_namesNrDz; c3(K|] }d|d yw)zskill_view(name='z')Nr<)rrs rrz._pruned_skill_reload_notice..; sEt)$r2Esz The task list above crossed the compression boundary verbatim, but the skill instructions that governed it were pruned. Before executing any preserved task that depends on these skills, reload them first: u. After reloading, re-check that each pending task is still justified — findings recorded before the boundary may have invalidated it.) r%rrr&r(rrrr"_PRUNED_SKILL_RELOAD_NOTICE_HEADER) compressedrrrrrcallss r_pruned_skill_reload_noticer, s`E#'4( / g0FG #D5  T" ## '()  IIEuE EE - ./ge  erOcT|jd}|jd}t|tst|tr dd}t|||||zn)|xsdd|xsdj }t||t D]}|j |dy)zFold the human anchor into an existing user-role scaffolding turn. Used only when any insertion would create consecutive user turns. Anchor text leads, scaffolding follows, and synthetic flags are cleared.rc^t|tr t|Sdt|xsddgS)NrKrD)rrK)r&r'rG)rs r_partsz/_merge_anchor_into_user_message.._partsN s/$.w$=4= qV]`ahanln]oDpCq qrOrD N)rrr1r')rr&r'rrHr{pop)ranchoranchor_contenttarget_contentrmergedrzs r_merge_anchor_into_user_messagerF sZZ *NZZ *N.$':nd+K r !)?&BX)XY"(b)n.B-CDJJL 0% 4rO)insertedralready_presentplaceholder_appendedcZddlmm}d d}d fd }tD]1\}}||dk(s|dk(s||dz dk7s)||cSr+|ddk7s|j t dr|t Stdd d<y ) z?Insert the latest human turn without breaking role alternation.r)r$rcHt|tr|jdSdS)Nrr&r(r)rs r_rolez'_insert_real_user_anchor.._role` s",S$"7swwvATArOc4d<j|y)NTr)r)rr$rrzs r_placez(_insert_real_user_anchor.._placec s'+#$v&rOrr9rrGTr)rrr1 Optional[str])rrr1CompressedUserTurnOutcome)r%r$rr_is_context_summary_contentrrryr)rzrrrrrrr$s`` @r_insert_real_user_anchorr\ sPB$H-!w >[ (eqjE(5ST9BU. s Dg  ) Dsrr)_INFLIGHT_REPLAY_MERGED_KEY%COMPRESSION_CONTINUATION_USER_CONTENT_fresh_compaction_message_copyc3dK|]'}t|txr|j)ywrr)rrrs rrz3_ensure_compressed_has_user_turn.. s+ lV]:gt $ Q5P)Q Q ls-0rrrrr)append_messager)rrr%rrrreversedr~rr&r(rragent.message_metadatar)original_messagesrrrr steer_textrrs @r _ensure_compressed_has_user_turnr} s D DDHbcmHn  lak ll -.a  )+J8VW^8_` `'4(GKK,?6,I 5g> +JT^8_` `a6:;`ab !rOc(t|trVt|trF|jd|jdk7s#|jd|jdk7ry|jd}|jd}||||k(Sy)zCCompare the live turn identity we care about for rotation stamping.rrF timestampTr)leftrightleft_timestampright_timestamps r_messages_match_scoped_identityr s tT "%& 88F uyy0 0 88I %))I"6 6XXk*Nii ,O!o&A00 rOexact_counts_stampedcfddlm}|jd}d}|Z|D]R}t|tr |jd|k7s t ||s4|j|r|xs|}Ld||<d}T|ry|D]7}t|ts|j|r&t ||s3d||<9y)aMStamp ``_db_persisted`` on every unstamped scoped twin of ``source`` in ``targets``. Exact-timestamp twins are preferred: when the source carries a timestamp and any exact twin was stamped (or, with ``exact_counts_stamped``, merely exists), the broad scoped pass is skipped so a content-equal old duplicate is left alone.rr#rFNT)r%r$rr&r(r)targetssourcerr$source_timestamp exact_hitrs r_stamp_scoped_twinsr s >zz+.I# Fvt,::k*.>>6vvFzz./%=)= +/F' (I   0 vt $JJ34/?+/F' ( 0rO0_pending_context_engine_compression_notificationc tdd5ddlm}|jj |j ||dddt |jdd}t|sy ||d |t |d dxsd t |d dy#1swYUxYw#t$rtjddYy wxYw)zDNotify the active context engine after a durable compression commit.z*relay segment rotation notification failedTrr) relay_runtime) profile_keyrrNrFr_rrr)rrrrz4context engine on_session_start (compression) failed) r r4rSESSION_COORDINATORnotify_session_compactedcurrent_profile_keyr2rwrrrr)r4rrrcallbacks r+_notify_context_engine_compression_completer s > N '))BB%99;gu C  u//1CTJH H   M.UJ5>#E+A4H      KVZ [ s3B-'B!B! CCctttdr tddfd }t t|y)zCStage exactly one existing hook call for an outer host transaction.N-a compression notification is already pendingc tS)Nrr)r)r4rrsr_notifyz?_queue_context_engine_compression_notification.._notify s: .  rOr4)rr2$_PENDING_CONTEXT_ENGINE_NOTIFICATIONrr)r4rrrs``` r._queue_context_engine_compression_notificationr s5CTJKJKK  E7ArOct|td}t|td|r t|syt |S)zCEmit or discard a deferred notification; repeated calls are no-ops.NF)r2rrrrV)r4 committedpendings r0finalize_context_engine_compression_notificationr s7eA4HG E7> HW-  ?rOc&eZdZdZddZddddZy) _CompactionLifecyclezOwns the one-shot terminal edge of the compaction status lifecycle. ``commit_status`` is rebound to "committed" only on success and read at ``complete()`` time, so abort paths keep the terminal edge suppressed.c<||_||_d|_d|_y)NFr)rstatus_emitted _done_emittedr)rr4rs rrz_CompactionLifecycle.__init__ s! ,"&rOFforce_terminalc|jryd|_|jr(|jdk(s|rt|jyyy)NTr)rrrr5r)rrs rcompletez_CompactionLifecycle.complete sF    !   D$6$6+$E !$++ .JX rON)r4rrrVr1r2)rrVr1r2)r7r8r9r:rrr<rOrrr s0' 27/rOrcreZdZdZ d dZed dZd dZd dZd dZ d dZ d dZ y ) _CompressionLeaseaThe per-attempt durable compression lock plus its lifecycle plumbing. ``holder`` is None when no durable lock is owned (legacy DB, no session db); ``watermark`` is MAX(id) of active rows at lease start (None = archive everything, no concurrent-tail preservation this cycle).c||_||_||_||_||_||_||_d|_d|_d|_ d|_ tj|_ d|_yr)rrsidttl_refresh_intervalr _lifecycler watermark _refresher _releasedrr_release_guard_lock_setup_entered)rr4rrrrefresh_intervalrrrds rrz_CompressionLease.__init__ sl !1)#%) (,DH'nn.$) rOc.|jjS)zSTrue when the routine compaction start status was shown (heartbeats may follow it).)rrrs rrz _CompressionLease.status_emitted1 s---rOcr|jy|jj|_|jSr)rr&rrs rr&z"_CompressionLease.begin_lock_setup6 s4    %#'#5#5#F#F#H '''rOcx|jr |jyd|_|jjyr)rrr(rs rr(z#_CompressionLease.finish_lock_setup< s3''4+=+=+E #(  ,,.rOc$|jyt|j|j|j|j|j }|j 5|js|j|_ dddy#1swYyxYwr) rrrrrrrrrr)r candidates rstart_refresherz!_CompressionLease.start_refresherB sp ;;  2477DHHdkkSWS[S[]a]s]st   4>>"+//"3 4 4 4s "BBc^|j5|jr dddyd|_t|jdd|jk(rd|j_|j .td5|j jddd|j\|jrP|jrDtd5|jj|j|jddddddy#1swYzxYw#1swYxYw#1swYyxYw)zStop this holder's refresher and release only its durable lock. Holder-qualified and idempotent: safe for the host after a timeout because a newer holder's lease can never be deleted by this stale release.NT_active_compression_lock_holderz*compression lock refresher stop failed: %sz#compression lock release failed: %s) rrr2rrrrr rrrrelease_compression_lockrs rrelease_holder_onlyz%_CompressionLease.release_holder_onlyL s L~~ L L"DNt{{$EtLPTP[P[[>B ;*JK+OO((*+ww"txxDKKCDLGG44TXXt{{KL L L++LL L LsAD#AD#7D 7D# 1D:D# D D#D D##D,cT |jj |j |j%|jj |j|j y#|j wxYw# |j%|jj |j|j w#|j wxYwxYw# |j |j%|jj |j|j w#|j wxYw# |j%|jj |j|j w#|j wxYwxYwxYw)z?Finish lifecycle cleanup and release the OLD session lock once.N)rrrrr.r(rs rr z_CompressionLease.release] sJ - OO $ $ & -((*-))5**GGH`H`a**,D**, -))5**GGH`H`a**,D**, -((*-))5**GGH`H`a**,D**, -))5**GGH`H`a**,D**,s{C!B1A00BC1C 8C CC!F'#E 41D6%F'6EF' F$ 1F>F$F! !F$$F'N)r4rrrrrGrrrrrrrrdrr1r2r4r3) r7r8r9r:rr;rr&r(rrr r<rOrrr s}k))!$)+.)5:)NQ)6)CW) )(..( / 4L" -rOrc|y t|ry|j}t|s dt dfS|dfS#t$r}d|fcYd}~Sd}~wwxYw)zReturn ``(try_acquire_compression_lock, lookup_error)`` for ``lock_db``. ``(None, None)`` = no db or legacy SessionDB without the lock API (fail open); ``(None, exc)`` = lookup itself failed (caller fails closed).Nrz0compression lock API is present but not callable)rrrrrz)r  try_acquirers r_resolve_lock_apirl si ,W 5::  K YQRRR   Sys 9 9 AA A Acd| t||}t||||jdd|fS)zVSit-out return for lease acquisition: prompt, aborted telemetry, terminal status edge.NTr)r=r?r)r4rdr<attempt_started_atrprompts r _abort_leaser} s= ~(?#E+=}M d+ <rOc ||j|j|j}|rd |jj |j|_|4t jt5|jddd|S |S|S#1swY|SxYw#t$r3}tjd|j|d|_Yd}~|Sd}~wwxYw#t$r}td5|jj|j|jdddn #1swYnxYwd|_tjd|jt|j |Yd}~yd}~wwxYw)aAcquire the durable lock for ``lease.holder`` and capture the start watermark. Watermark = MAX(id) of active rows at START: appends aren't blocked during summary; later rows are concurrent tail that archive_and_compact re-sequences. Capture is safety-additive (fallback archives everything), so its failure never aborts. An acquire that raises is not version skew: fail closed and release holder-qualified best-effort (safe if never acquired).r Nu}compression watermark capture failed for session=%s (%s) — concurrent appends this cycle will be archived with the snapshotz8compression lock cleanup after failed acquire failed: %sulcompression lock acquisition raised unexpectedly for session=%s (%s: %s) — skipping compression this cycleF)rrrrget_active_message_watermarkrrrAttributeErrorrrrrr rrr7)leaserrracquired_wm_err _lock_errs r_try_acquire_durable_lockr" sP uyy%,,EIIN  '"'(("G"G "R +#,,^<D$AACD,xD  '9:?))W#'  '  P Q G HH - -eii F G G G  z IItI// s+CAB 3BB CCCBB CB C)(CCCC E?( E:31D-$ E:-D6 2AE::E?cd}tjt5|jj |j }dddt jd|j |d|_|xsd|_ t|dd|j k7rD|j |_ tjt5|jddddt||}tjt5t|jdr|jj!|dddt#||||d|S#1swY xYw#1swYxYw#1swY2xYw) zNAnother path holds the lock: publish the lock-skip signal, warn once, sit out.Nu~compression skipped: another path is compressing session=%s (holder=%s) — returning messages unchanged to avoid session forkT"_last_compression_lock_warning_siduw⚠ Skipping concurrent compression — another path is already compressing this session. Will retry after it finishes._begin_compression_telemetry)rlock_contended)rrrrrrrrrrEr2r$ _emit_warningr=hasattrrwr%r)r4rrdr<r{rexisting _existing_sps r_sit_out_lock_contentionr+ sL H   Y 'C8877 BC NN MNSiiYaEL.6-=E*u:DAUYYN38990   +    %   +5.AL   Y '` 5++-K L  $ $ A AQ^ A _` y.:LN^`l mm-CC   ``s#&E E3E$ EE!$E-c ft|dd}|jxsd}d|_t|\}} d} t j t t5tt|ddxsd} dddt|||| t|dd||} ||rt|| _ | 5d| _ tjd|t| j| d } n|7d| _ t|d d|k7r||_tjd |d } nW| j#s:tj%d |jxsdd |_t)||||dSt+| ||} | s | j-t/|| ||||S| j| j|_|s|j3| j4rXtj%d|jxsdd |_t7||} t9||d| j;d| fS| dfS#1swYxYw)aTake the per-session compression lock; ``(None, prompt)`` means sit out. Two AIAgents sharing a session_id (e.g. background review fork) would both rotate and orphan a child. Keyed on the OLD id (what rivals read from SessionEntry). Loser sits out: messages unchanged, caller sees no-op. Only structural absence of the lock API (version skew) fails open; once resolved, any exception fails closed since unlocked runs can fork lineage.rNrDgr@_compression_lock_ttl_seconds"_compression_lock_refresh_interval)rrrrrrrdugcompression lock lookup raised unexpectedly for session=%s (%s: %s) — skipping compression this cycleF _last_compression_lock_error_siducompression lock subsystem unavailable for session=%s — proceeding without lock. This usually means a stale in-memory module after an update; restart the process (or `hermes update`) to resync.TzBCompression commit cancelled before lock acquisition (session=%s).rcommit_fence_cancelledzBCompression commit cancelled before summary dispatch (session=%s).)r2rrErrrrzrrrrrrrrr7r/r&rTrjrr"r(r+rr+rr=r?r )r4rrrdr<r{r_lock_db _lock_sid_try_acquire_lock_lock_lookup_error _lock_ttlr_lock_acquiredr*s r_acquire_compression_leaser7 sUumT2H  &BI.2E*,=h,G))I   Y 3['%)H%PYTYZ [  ( y (LdSbn E  /6  ) EL NNy4 23<<>P #N  & ELu@$G9T9B6l "N))+ XZ_ZjZjZtnt38/#E9nFXZrss6u>OQ]^N  # # %+uiHZ  ||05 -  # (T(TUZUnUn(o KKTV[VfVfVpjp /4E +25.IL +E3EG_ ` MMO% % $;o[[s H&&H0cr|j |jsy t|j|j}|syt||j|j}|jt||}|/tj d|j|j||fStj d|j||fS#t$r]}tj d|jt |j||j|t||fcYd}~Sd}~wwxYw)a5Sit out (or adopt the live child) when the parent was already rotated. A late contender can take the parent lock after the winner released it and rotated; holding the lock does not prove this agent still owns a live parent. Returns the ``compress_context`` result to hand back, or None to proceed.Nzecompression session ownership lookup failed for session=%s (%s: %s) - skipping compression this cyclezEML-%!}*Ls8}*L   + x >>x^fguhu^v>wL x  f IIs8}c.&9 #EHHeii8N ~t ,^1Ds8}1T KK_afajajlopxly N # x xs F--F6cd}t|dd}t|}|rt|dd}| t|stdt t |t}|stdt |j||dt } t| tr t| }|S|rRt!j"t 5|j|| } t| tr t| }ddd|S|S#t $r}td|d}~wwxYw#t $rB}tjd t|jtd td |d}~wwxYw#1swY|SxYw)aNProvider ``on_pre_compress()`` insights to surface in the summary ("" if none). Raw messages stay the API v1 provider contract; normalized evidence goes only to API v2+ checkpoint providers inside MemoryManager.on_pre_compress(). Raises :class:`CompressionCheckpointUnavailable` when a required checkpoint cannot be taken.rDrNrz.no active provider implements checkpoint API vz provider capability probe failedz3active provider does not implement checkpoint API vT)evidence_messagesrequire_checkpointcheckpoint_api_versionz,Required pre-compress checkpoint failed (%s)zprovider checkpoint API vz failed)rH)r2rrrrrVrron_pre_compressrrrr7r&rGrrr) r4rzcheckpoint_requiredrrrHr compatibler _maybe_ctxs r_pre_compress_memory_contextrOd s NU$5t+ S%&HIs R S y NNI4PS9K]K] ^%(ABeAffm&noux x y  E s< D4D/E+ D DD E(&=E##E(+E5cB|jj}t||||||}|jred|vrat |jdt |jj }t |dd|k7r||_tjd|||fS)z>Bind ``compress()`` and only the kwargs its signature accepts.)rrrrrerr'_last_memory_context_unsupported_engineNzfcontext engine %s does not accept memory_context; continuing without provider-supplied summary context) rwrFrrHr2rr7rQrr) r4r{rrrrercompress_kwargs engine_names r_resolve_compress_callrT s **33K3M{RWhv'O"2/"Ie66UE]E]@^@g@gh 5CT Jk Yz'_run_summary_dispatch.. srOcjSr)r)rrsrrZz'_run_summary_dispatch.. s l.G.GrOcjtduxrjxsduxr jSr)rVrr)rrhard_cancel_eventsr_compression_cancel_requestedz<_run_summary_dispatch.._compression_cancel_requested s@ d * I/@/G/G/I HD(F\-F-F  rOuUCompression cancelled before summary dispatch (session=%s) — skipping summary work.r) cancel_checkr4)rfrVrWrXrrrrwrrrrrTrrrr rr)r4rzrrRrrrr]rVrWrX_progress_hook_host_stream_deadliner^_attempt_ctx_tokenrs ` ` r_run_summary_dispatchrc shg4@4L\00S_N@L?WL;;]a -  $ $&GI[  8;; %d chars): builder output changed since the stored snapshot (update, config change, or memory/skills growth)r)r:_invalidate_system_promptrXrrrr;agent.system_promptryr2rrTrryr{)r4r<cached_system_promptrebuilt_system_promptnew_system_promptryrs r"_rebuild_system_prompt_at_boundaryr& s 66 ##% '."66~F',AEY,Y:NNE7A!%Rkl ;POE7  +#*%1RTY"Z^b"b&,,hnhshsC ]  *FC0D,EsK\G]  59E 1 ?   ept   s C C.-C.ct|}t|}||kDrQddlm}||||} | >t| } | |kr.tj d|j xsd|d| d| }| }||kDrtj d|j xsd|d|dtjt5d |j_ dddtjt5|jd dddt||} t||d td d 5|jj!dddt#|j|d| fS|dfS#1swYxYw#1swY|xYw#1swY?xYw)aNAnti-growth guard at the COMMIT SITE (in-place commits before the gateway can inspect). Compares like-for-like rough estimates; on growth tries one mechanical salvage pass, else treats the attempt as a refused no-op. Returns ``(compressed, None)`` to proceed or ``(None, prompt)`` when refused (caller releases the lease).r)salvage_grown_transcript)budgetNzTCompression salvage recovered a shrinking transcript (session=%s, ~%s -> ~%s tokens)rr-zCompression refused: compressed transcript would be larger than the original (session=%s, ~%s -> ~%s tokens); keeping the original transcript unchangedTu⚠️ Compression refused: the generated summary would have GROWN the conversation instead of shrinking it. No messages were dropped — conversation continues unchanged. would_growz+could not record rejected-compaction striker)rr%rrrTrrrrrrw!_last_compress_refused_would_growr'r=r?r record_rejected_compactionrC) r4rzrr<rr _rough_in _rough_outr _salvaged _salv_estr*s r#_salvage_or_refuse_grown_transcriptrU s/x8I/ ;JI F,Xz)T  6yAI9$ j$$.9Q-YqM' & I ABGBRBRB\V\m!n    + NIME $ $ F N   +    _   /unE '/A<PCd S B  $ $ ? ? A  B $E$<$<>NO\!! t % N N   B Bs$5E)(E5(F)E25E>F ct|dd}t|sy ddlm}||xsi}|j dduxr||j d S#t $rYywxYw)zTrue when the parent row was ended by a non-automatic reason. Fails OPEN: an unreadable row must not turn a cheap guard into a new way to lose compression.rNFr)is_automatic_end_reasonrr)r2rhermes_state_commonrrr)rrreaderrrows r_parent_deliberately_endedr srZ 5F F ?Z &Bwwz"$.e7NswwWcOd7e3ee s>A A&%A&ctd5ddlm}|||jddddtd5ddlm}|||jdddtd 5dd lm}|||jdddd|syd}td 5|jj|}ddd |jj|j||;td 5|jj|j|dddyy#1swYxYw#1swYxYw#1swYxYw#1swYxYw#t$r }tjd |Yd}~yd}~wwxYw#1swYyxYw)aMigrate /goal, /heartbeat, /loop state and the title from the parent to the child. Each lookup is a flat per-session read with no parent walk, so state would silently die at the boundary. The title is carried unchanged (renumbering per rotation made one session look like many); its provenance is read BEFORE the transfer clears the ancestor's row, then restored so an inherited auto-title stays upgradeable. z)Could not migrate goal on compression: %sr)migrate_goal_to_sessionr_rNz.Could not migrate heartbeat on compression: %s)migrate_heartbeat_to_sessionz)Could not migrate loop on compression: %s)migrate_loop_to_sessionz#Could not read title provenance: %sz,Could not propagate title on compression: %sz(Could not propagate title provenance: %s)r hermes_cli.goalsrrhermes_cli.heartbeatrhermes_cli.loopsrrget_session_title_sourceset_session_titlerrrset_session_title_source)r4r old_titlerrr_srces r_carry_session_state_to_childr s = >X =0@0@W X B CGE$^U5E5EFG = >X<0@0@WX  D 7 8J  99.IJ ++E,<,E99E>F cd}tjt5|jj |}ddd|r|j dr|dSddlm}|t|ddS#1swY:xYw)zThe parent row's persisted source: a compression child is the same conversation, so a ``--source tool``, ``oneshot`` or inherited ``kanban`` label must not degrade to the bare ``agent.platform`` (#112550).Nrr)_session_source_for_agentr) rrrrrr run_agentrr2)r4rparentrs r_compression_child_sourcer swF   Y 'B""../@AB &**X&h3 $WUJ%E FF BBs A11A:cpt|dd}t|trd|cxkrt|krnn|d|nd}t |j |rt d|d} tjt5|j j|j} dddtjt5|j||dddd} tjt5ddl m} | } ddd| dk(rd} |j j|j} t!} ddlm}|j j'|| t)|||j*|j,||t|d d| |j.|j.du|j.du|j0| |j2nd| |d vr`t5d t7|Dd}t|t8r4d ||<t|dd}t|t:r||urt=||d |D]}t|t8sd ||<| |_ d|_tA|jd |_!tE||| y#1swYxYw#1swYxYw#1swYxYw)aRotate the session: flush the parent, publish the child, re-point the agent. Flushes current-turn msgs to the OLD session, passing the durable prefix (messages[:persist idx]) so preflight, which runs before rows are marker-stamped, can't re-append them.r>Nrz"Compression parent already ended: r?)get_active_profile_namerr#working_directory)rrrrx model_configrrzcwd profile_namecompression_lock_holderrequire_compression_leaserequire_lease_refreshlease_ttl_secondsrwatermark_ceiling>rrc38K|]}t|s|ywrr)rr+s rrz._publish_rotated_compaction.. s)dK`abKc!)dsT_session_messagesr)#r2r&rryrrrrrrrrrAhermes_cli.profilesrget_session_titlemint_session_idr%r$publish_compression_childrrx_session_init_model_configrrrnextrr(r'r_db_flush_scan_prefixr{rr)r4rzrrrrcompressed_user_turn_outcome current_idxpersisted_history_foreign_tail_ceiling_profile_for_childrrrr$_compressed_anchor_sourcer_handoff_messages r_publish_rotated_compactionr s%!1 CdWZ[cWdCd+jn "%"3"3^D??OPQQ!   Y 'a % 1 1 N NuO_O_ `a   Y '^ ++HK\+]^    Y '7?467Y&!!!33E4D4DEI$&N= //(>(?u{{55EVak E. 5DV %  \`H`#ll$6%))&;&G5??T/0 $'==%))dXh5G)dfj$k! / 6>B %&: ; '/BD I +T27HPX7X$$57Pgkl&: & -59 1 2:&E"&EE,,- $E!%C_aa^^ 77s$;&JJ9J+JJ(+J5ct|jdd}|r.t|dd|k7r||_|jd|dyyt|jdd}t|jdd}||f}|rIt|dd|k7r8||_t j d ||xsd |jd |d yyy) zPSurface a failed summary, or a recovered-but-broken aux compression model, once.rdN!_last_compression_summary_warningu ⚠ Compression summary failed: z%. Inserted a fallback context marker.rpro_last_aux_fallback_warning_keyzLConfigured compression model %r failed (%s); recovered using the main model. unknown erroru"ℹ Configured compression model 'zn' failed, so Hermes summarised with your main model instead. Check auxiliary.compression.model in your config.)r2rwrr'rrr)r4 summary_error_aux_fail_model _aux_fail_err_aux_keys r_warn_summary_or_aux_fallbackr sE446KTRM 5=t D U6CE 3   "B=/Qv w x V "%":":<[]ab 8 8:Y[_` #]3 wu.NPTUYaa3;E 0 NN^!A/    4_4EFbb  b?rOrDrskillscvtjt5ddlm}||ddd|r0tjt5ddlm}||ddd|sytjt5ddlm}||dddy#1swYoxYw#1swYIxYw#1swYyxYw)aAdvance the file-read (and skill_view) repeat-read dedup to a fresh generation after a boundary. The mtime map is kept: the first read of each unchanged key returns full content compaction may have omitted; later reads return stubs, and stub-hit counters restart at the same boundary (#84857). The computer_use screenshot dedup is session-keyed and forgets its last frame for the same reason. r)reset_file_dedupN)reset_screenshot_dedup)reset_skill_view_dedup) rrrtools.file_tools_read_trackingrtools.computer_use.toolrtools.skills_toolr)task_idrrrrrs r_reset_read_dedup_cachesr. s   Y '"C!"   + / F ": . /    Y '(<w'(("" / / ((s#B B#?B/B #B,/B8c |} | xs|jxsd} | rO|rMtdd5t|dd}ttt |ddx}r ||| ddd|r4t | s|r'|rt nt}|||jxsd| td 5t | s|r9|jr-|jj|jxsd| d d ddd|j}|j}|d k\r*|jd|d}||_ |j|t|ddrRtd5|jd|j xsd|j| xsd||jdddd||_||_t'||xsd|j(xsd}||_d|_d|_d|_t3|d|r4tt |dd}t|r ||| | nd|_t7| |jxsd|S#1swYxYw#1swYfxYw#1swYxYw)zPost-commit bookkeeping: notify engines/providers/hooks, re-arm usage tracking. Returns the rough post-compression token estimate (diagnostics only).rDzGfailed to clear archived compression parent's activity labels (ignored)TrrNclear_session_activity_labelsrz2memory manager on_session_switch (compression): %sFr_rru⚠️ Session compressed u> times — accuracy may degrade. Consider /new to start fresh.event_callbackz,event_callback error on session:compress: %szsession:compress)rrrin_placer[)rtoolsrGrrecord_completed_compaction) used_fallbackfeasibility_skip)r)rr r2rrrVrrrrrwr[ log_prefixrrrrrirjrrlast_compression_rough_tokenslast_prompt_tokenslast_completion_tokens%awaiting_real_usage_after_compressionrr`r)r4rrrrcompacted_in_placesession_commit_succeeded!defer_context_engine_notificationcompression_made_progresscompression_used_fallbackcompression_feasibility_skipr_old_sid_boundary_parent _labels_db _clear_labelsnotifyr~_cc_cc_msg_compressed_estrecord_boundarys r_finish_compaction_boundaryrB sH95#3#39r, _jn o 4  t| j||sdnd}|(|s&t@jCd|j xsd|nt@jCd|tEdd 5|j>jGtHd|dddn #1swYnxYwYd}~d}~wwxYw)aAPersist the compacted transcript: memory extraction, anti-growth guard, then the in-place archive or the parent->child rotation. Failures roll the live list back and arm the split-failure cooldown; a refused (would-grow) candidate returns ``refused_prompt`` so the caller hands back the input unchanged. FrNr_compaction_tail)r<rr)rrr!r)&PROACTIVE_PRUNE_REARM_MODEL_CONFIG_KEYstamp_db_persisted_markersc3>K|]}t|vsdyw)r9N)r)rr+_tail_tagged_idss rrz%_commit_compaction..)s"VBqEEUx9UiL%ha$$+Q lnopCdS ((MM37MaS5Q   ]2 sUF4F/F/, F/9:F44C)F4/F44 J9=B8J45$J" J4"J+ 'J44J9cbeZdZUdZded<dZded<dZded<dZd ed <d Zd ed <dZ ded<y) _SummaryPhasezPOutcome of the summary phase; ``abort_prompt`` set means hand ``messages`` back.r'rzNrrOptional[list]r Optional[int]r{rr pre_msg_countr abort_prompt) r7r8r9r:rrrr{rrr<rOrrrs=ZNJ266#'M='M3"&L-&rOrc t|} dd}dfd } |j|s.t|||}||}t|} d}t||_t |||}t ||||||\}}t j|}t|| |jjt||||| | j| } |d t3||||| S#t$r | j|jnc#t $rW}t#|||d|j%t'|| j(dt+|j,d}~wwxYwt#||t/|| | j(|| }|d |j%t'|| j(|rt0nd t3|t5||  cY|d St $rK}|d|j%t'|| j(dt+|j,d}~wwxYw#|d wxYw)aAdopt a grown durable parent, gather memory context and run the summarizer. A hard cancel restores the compressor snapshot + live list, records a stall backoff while the lease is still held, and aborts; any other failure releases the lease and re-raises.Nc2j|dyyr)r)r_activity_heartbeats r_stop_heartbeatz+_run_summary_phase.._stop_heartbeats"  *  $ $T *"&  +rOr)r{rrrre)rrr)rrrr]z#context compression rollback failedz rollback:rrrsrzr{zcontext compression cancelledexplicit_interrupt)rzrrcontext compression failedz exception:)rzrrr{rr)ryrrFr>rOrTr|r}rrrrcrr restore_compressorrwrrAr r?rsrr7rrrr=)r4rzrrrLr{rrrerrr]r<r;rrr#_adopted_parentrrrRr _rollback_exc_stall_backoff _compress_excr"s @r_run_summary_phaser,sgMMCG"&' 89 9%QO** #H ! 36h-/5eXGZ['= Kues+( $ _'+mmH&=#;  AUAU %' + 8[/ &11EV F 78 jNi#= A )m   & &u'?'? @  'x1L M A B MMO +E73E3ESWXeSfSoSoRpGq r   #8-HI;  9K9KV^'  78 ' 7%%>(G_s h=TUZ\j=kll 78 45 'w/A/AZPTUbPcPlPlOmCno  78sWB8C)) I3DI E/AE**E//A7I&I0I8AH>>II IcTeZdZUdZded<ded<ded<dZd ed <dZd ed <dd Zy)rzIPer-attempt ownership state threaded through the compress_context phases.r(rrrrrsNr5rOptional[dict[str, Any]]rctt||j|j|j|jy)zPRoll the compressor back to this attempt's snapshot (durable cooldown included).rN)rrrrr)rr~s rr'z_Attempt.restore_compressors-)  dFiFi#'#>#>SWSbSb rOr~rr1r2)r7r8r9r:rrrr'r<rOrrrs1SNO59"N97;4; rOct|j}t|j}|r%tt |t dr t dd|_d|_d|_ d|_ tj}tjj}t!j"t$5||_||j(xsd|rdndd|j_dddt-|||S#1swYxYw)aSnapshot + claim the compressor, reset per-attempt agent signals, seed telemetry. The claim stops a late-unwinding sibling (stall-fallback overlap) from restoring its snapshot over ours or clearing our cancellation consult. Signals are cleared at the VERY TOP, before codex/breaker early-returns, so a stale value cannot make a later no-op look like lock contention; ``_last_compression_attempt_in_place=None`` means aborted/no boundary for ``conversation_history_after_compression()``.NrTrDmanualr)r%rtrigger_source)rrwrrr2rrrhrirErjrrr1r2r3rrrr&rrvr)r4rdefer_notificationrrrsr%s r_begin_compression_attemptr5s2%2J2JKH*5+C+CDJhwu6Z\`'abJKK/3E,/3E,-1E*,0E(!J!!J   Y ' (2%$E4D4D4J*/hV@   < Hj* 55   s 9/C==Dc |E|jt|dds)|j|j|t ||fS t ||||||||j SS#||j wwxYw)zOCodex owns the real thread: run its own compact under the commit fence bracket.Nrr{rr)rr2r'rwr=&_compress_context_via_codex_app_serverr)r4rzr<rrr;r{rrs r_route_codex_compactionr9s  (A(A'%QlnrBs(t""5#;#;<0GGG)5 8^=RYaf   #  & & ( $< #  & & ( $s A--Bc tjd|jxsd||r|dnd|j|t}|s&t |j d||||j|}|r|j|t|t|S)zXLog the attempt, emit the (engine-customisable) compacting status, return the lifecycle.zPcontext compression started: session=%s messages=%d tokens=~%s model=%s focus=%rrr-rprF)phasedefault_messager{ message_countrxr) rrTrrxCOMPACTION_STATUSrrwrrrV)r4r=r{rrstatuss r_announce_compression_startr@+s KKZ\a\l\l\vpv}-*)U[[ZeF 4  $ $J^k'u{{   6" tF| 44rOr)r{rrrrerrrc t||} tdddu} tdddk(r | r tdt||| | ||| S|st |r|t |fSt |} ttd d} t| ||| }td ds td_ t| |||| j\}}|||fS|jt!|||}||St#j$| j&\| _| _| j(dur|j-|t |fS|s,t |dr|j-|t |fStdd}t/||| | ||||| |||  }|j0|j2|j0fS|j2|j4}}|j6}|j8|j:} }d} fddD\}}}t=|||| j>| jr2|t |f |j-|r| jASS| | jC|}|s| jEj$tG||tHjKdjLxsdd_'tQ| | j||}t |}tS| j|rtTnd||f |j-|r| jASStWtY|t[||}t]|}t_||| |||||||  }|j`2||j`f |j-|r| jASS|j4}|jb}te|||jf| |jh|jj||jl||| } tHjKdjLxsd| t || d|dvrdnd|_7tq| j|jn||d vrd!nd|jr"||f |j-|r| jASS#t$r|jd wxYw#|r| jAwwxYw#|r| jAwwxYw#|r| jAwwxYw#|r| jAwwxYw# |j-|r| jAww#|r| jAwwxYwxYw)#u\Compress conversation context and split the session in SQLite. ``force`` (manual /compress) clears the summary-failure cooldown; ``bypass_cooldown`` (provider-proven overflow) skips it once, breakers still apply. ``commit_fence`` stops a timed-out worker mutating session state. Returns ``(messages, system_prompt)``; on abort input is unchanged, NOT split. Args: agent: The owning :class:`AIAgent`. messages: Current message history (will be summarised). system_message: Current system prompt; used when compression needs a rebuilt cached prompt. approx_tokens: Pre-compression token estimate, logged for ops. task_id: Tool task scope (used for clearing file-read dedup state). focus_topic: Optional focus string for guided compression — the summariser will prioritise preserving information related to this topic. Inspired by Claude Code's ``/compact ``. force: If True, bypass any active summary-failure cooldown. Set by the manual ``/compress`` slash command so users can retry immediately after an auto-compress abort. Auto-compress callers use the default ``False``. bypass_cooldown: If True, the automatic breaker gates ignore ONLY the summary-failure cooldown for this attempt (#100661). Set by the provider-proven overflow recovery path: the provider already rejected the request, so deferring until the cooldown lapses wedges the session. Unlike ``force`` it does not clear the cooldown, and the ineffective/structural breakers still apply; a failed attempt records its cooldown normally. defer_context_engine_notification: Delay the existing context-engine hook until a manual host commits its outer history transaction. commit_fence: Optional cooperative fence for executor callers that may time out. It prevents a late worker from mutating session state after its caller has moved on. )rr4rFTrNcodex_app_serverzpcodex_app_server owns the authoritative thread and does not expose a truthful pre-compaction transcript boundary)rrr;r{rrcompression_in_place)r=r{rrr]r)rrrdr<r{rrr) rrrLr{rrrerrr]r<r;c3^K|]$}ttj|d&ywr)rVr2rw)rrr4s rrz#compress_context..s/a  114? @a s*-)rarh_last_feasibility_skip)rrzBCompression commit cancelled before session mutation (session=%s).rr$r0)rrrr<rrrr;) rrrrrrrrrrz^context compression done: session=%s messages=%d->%d rough_tokens=~%s awaiting_real_usage=truer->rrrrr>rrsession_split_failed)rsrrrr!):r5r2rr9rhr=ryrVr@r[rrr]r7rsr(r<rrwrrrr r,rrzrrr{rrrrrr'rArrTrrjrr?rrrwrrrrrrrrrrrrr!)!r4rzr<r{rrrrerrrr;rL_pre_msg_countrrdr _abort_prompt_adopted_hard_cancel_eventr;rr_commit_fence_entered_compression_made_progress_compression_used_fallback_compression_feasibility_skipr*r*rrcommitrrs!` rcompress_contextrP>s6)ePqrG "%)JERVZZuj$'+== %C ' 8^,PWgt5   7O0GGG]NGE#94@AH, ^=VainI 5>5+;+;jH"'"C"C$)$7$79L9L>M!I-a ta ]"$>@]  :x)DY`YkYk&11 4UNKKt - MMO$**,%y  #$0$=$=>P$Q !(**5+C+CD*85PQ XZ_ZjZjZtnt38/!B ASAS^f"/" 7unM /7--7E3Kc -N - MMO$**,%S &e,E:.'GR\']$>unU# 8Z(%[l)Hd(CSm    ,V2226 - MMO$**,%;&& ** 5 :1BSYShSh&2K2K%+%D%D.O&,&:&:Vp)FPW    l    &JO\]K^ (+hhKnw  , g00 @W@Wfr5AEf5f1lp$66 ,, - MMO$**,%}    d  3  |%**,%$**,%$**,%$**,% - MMO$**,%$**,%sv* SAUS!7B/U'S9 AU*TCUT)S!S69TT&)T>U?U'U?'U<<U?c2t|dd}t|dd}t|sy |d} |r(t dt |jd xsdSdS#t$rtj ddYywxYw#ttf$rYywxYw) zGSeconds left on this session's compaction-failure cooldown (0 = clear).rwNrrTrz'codex compaction cooldown lookup failedrremaining_seconds) r2rrrrrrrrzr)r4r~rrOs r$_codex_compaction_cooldown_remainingrSs 4d;J Z!JD QF F t$INs3eii(;<CDEWTWW  > N z "s( A)BB BBBBcddlm}t|dd}t|dd}t|syt dd5|||dddy#1swYyxYw) zArm the shared compression-failure cooldown after a failed codex compaction. The codex path returns the transcript unchanged, so without a cooldown the still-over-threshold session would retry every turn.r)!_SUMMARY_FAILURE_COOLDOWN_SECONDSrwNrz(codex compaction cooldown persist failedTr)r%rUr2rr )r4rrUr~rs r _record_codex_compaction_failurerVs\K 4d;Jz#I4PH H  xsd$d%tj d&|t| d'dxsd$t| d(dxsd$t||}tA|||fS#1swYxYw#t $r| j#dwxYw#1swYixYw#1swY-xYw#1swYxYw))zRoute compaction to Codex app-server for Codex-owned threads. Rewriting the local transcript would not shrink the Codex thread, so Codex compacts its own thread and Hermes' transcript is left unchanged.rNrr-rp codex_app_server_auto_compactionnative>offhermesrYr[zmode=z force=falserzfailure cooldown active for z.0fs_codex_sessionzno active codex threadzKcodex app-server compaction skipped: %s (session=%s messages=%d tokens=~%s)zFcodex app-server compaction started: session=%s messages=%d tokens=~%sT)rr& interruptedFrr should_retireu(⚠ Codex app-server compaction failed: zcompaction interruptedz#codex compaction bookkeeping failedr)#_record_codex_app_server_compaction_record_codex_app_server_usage)r{rupdate_from_responserrDrz>codex app-server compaction done: session=%s thread=%s turn=%s thread_idturn_id)!r2rGrJrSrrTryr=rrrrr>rrcompact_threadrrrVcloser]r'rrVr agent.codex_runtimer`rar(rwrrr5)r4rzr<r{rr_sid_tokens auto_mode skip_reason_cooldown_remaining codex_sessionr"rAfailedr`raexisting_prompts rr8r8sI 5, - 7D&3q!GGE#ExP\T\]cceI33 K Y(*i[ 5 C5I  "89LS8QQRSKE#3T:M}4.  Y[fhl M7 0GGG KKXZ^`cdl`movw   Y '. ,-.7RVW]]_--/'&-7Y767TX;Y ZFV9Ihiv.   + "    ! "#   + [   "J6<<. Y Z [ )GFGT4R4nVn0op0GGG 7$ GMk+E6^bc 5++-C D *5&8 L MW1A1A1GRPUV KKH$ T*0b'&)T2R2XVX.e^DO% _ $$K..   !=>   " " [ [ MMs<0K&*K3LL;6L,&K03LLL),L5i@z.pngz.gifz.webp.jpgz.bmp)z image/pngz image/gifz image/webp image/jpegz image/jpgz image/bmpc|jdrB|tddjdddj}|jdr|S|S)z?``image/*`` mime from a ``data:`` URL header, else ``default``.data:N;r9rimage/)rqrysplitrH)headerrr s r_data_url_mimerxosT !3w<>*00a8;AAC    )  NrOc2 ddl}ddl}|jd\}}}|r|jdsyddlm}|j |j|j|5}|jcdddS#1swYyxYw#t$rYywxYw)z```(width, height)`` of a base64 data URL; None when Pillow is missing or the payload is corrupt.rNr-rs)Image) base64io partitionrqPILrzopenBytesIO b64decodesizer)data_urlr{r|rRdata_drz_imgs r_decode_pixelsrxs ))#. 1fX009 ZZ 6#3#3F#;< = 99    s40B 5B ( A>4 B >BB B BBct}t|tr|jdsyt ||kDrdnd}|t |}|t ||kryd} |jd\}}}t|} ddl } | j|} tjdtj| d d } | j| | j!|t#| j$| || } t'j(t*5t#| j$j-d ddd| syt | }|dk(r.t | t |kxr|duxst ||k}n(|t ||k}nt | t |k}|r| d fSdS#1swYzxYw#t'j(t*5t#| j$j-d dddw#1swYwxYwxYw#t*$r&}t.j1d|d|dufcYd}~Sd}~wwxYw)aReturn ``(resized_url, unshrinkable)`` for a data URL. ``resized_url`` is None when no rewrite applied. ``unshrinkable`` is True only when the image violated a constraint and resizing failed to satisfy that same constraint, so the caller knows a retry is pointless. The accept gate MUST use the axis that triggered the shrink: a pixel downscale can re-encode to MORE bytes (PNG non-monotonic); a byte-only reject wedges.rsrbytesN dimensionr-rhermes_shrink_rpF)prefixsuffixdelete) mime_typemax_base64_bytes max_dimensionT) missing_okru.image-shrink recovery: re-encode failed — %s)_IMAGE_SHRINK_TARGET_BYTESr&rGrqryrrr}rxr{rtempfileNamedTemporaryFile_IMAGE_SUFFIX_BY_MIMErwriterfrrrrrunlinkrr)urlr resize_fn target_bytes triggered_bydimsrwrRdatamime_b64rltmpresizednew_dimsokrs r_shrink_data_urlrs .L c3 s~~g'>!#h574Lc" <3t9 5" ".--,4f%nnT"))#,A,E,EdF,S\a  7 IIcN IIKSXX$]jG$$Y/ 7SXX%%%6 7!'* 7 "WC(ah$.>.`#h-S`B`B  !X-/BWC(B#%7<7! 7 7$$Y/ 7SXX%%%6 7 7 7" .GM\---.suA!H>AG>H&F6= HA+H4H6F?;HH&H  H H HH I #I>I I c"t|tr|jddk7ry|jd}t|tr|syt|jdxsdj }d|j dr|ndd |S) uKAnthropic ``{"type": "base64", ...}`` image source → data URL, else None.rr{Nr media_typerqrsruz;base64,)r&r(rrGrHrq)rrrs r_source_to_data_urlrs fd #vzz&'9X'E ::f D dC VZZ -=>DDFJ !6!6x!@:lSS[\`[a bbrOcR|jd\}}}i|dt||dS)zReturn a NEW source dict carrying the re-encoded payload. Copy-on-write: parts may be shared with the persistent history, so mutating in place would store the degraded image; the caller replaces the part.r-r{)rrr)r}rx)rrrwrRrs r_write_data_url_to_sourcers4((-OFAt [f [hnV6LVZ [[rOi@)rc|sy ddlmd}d}dfd }|D]j}t |t s|jd}t |ts7d}t|D]\} } t | t s| jd } d} | d k(rN| jd } |t| xsd \}}|rt | t ri| d t| |i} ny| d vrt| jd}t |t r,||jdd \}}|r7i| di|d|ii} n(t |tr||\}}|r i| d|i} n| | t|}| || <|dz }|s|dz }|f||d<mtdz }|rtjd|||rtj d||y|dkDS#t$r }tj d|Yd}~yd}~wwxYw)aRe-encode oversized native image parts to recover from image-too-large errors. Mutates ``api_messages`` in place. Returns True if any part was replaced, False if nothing to shrink or Pillow could not help. Targets data-URL parts over 4 MB or ``max_dimension`` (Anthropic's per-side pixel cap, parsed from the rejection by the caller); http(s) image URLs are left untouched.Fr)_resize_image_for_visionu6image-shrink recovery: vision_tools unavailable — %sNrc t|S)N)rr)r)rrrs r_shrinkz3try_shrink_image_parts_in_messages.._shrinks=LdeerOrrimagerrD> image_url input_imagerr9izGimage-shrink recovery: re-encoded %d image part(s) to fit under %.0f MBuimage-shrink recovery: %d oversized image part(s) could not be shrunk under %.0f MB — not retrying (would re-send rejected payload))rrr1tuple)tools.vision_toolsrrrrr&r(rr'rrrrGrrT) api_messagesrr changed_countunshrinkable_oversizedrrr new_contentpart_idxrqptype replacementrr unshrinkable image_value target_mbrs ` @r"try_shrink_image_parts_in_messagesrsI ?Mf+)#t$ '')$'4( $( '0 ,NHddD)HHV$EK(+(/0CF0K0Qr(R%z&$7"`T"`85NvW^5_"`K66"hh{3 k40,3KOOE24N,O)G\&\&\{<[{<[ESZ<[&\  S1,3K,@)G\&D&D{G&D &&"&w-K(3 H%" &!+&A ,B  "(C NW+)X+k:I ]_lnwx  UVl   1 G OQTUsG G2G--G2) r>r3rrIrNr[rar^rfrPrceZdZdZy)!CompressionExecutorSaturatedErrorz@All compression pool slots are occupied; submission was refused.Nrr<rOrrr+sJrOr)rrGrrV)r*rr1r)r4rr1r2)rK str | Noner1rVr4)r~rr1dict[str, Any])r~rr1r)r~rr1r)r~rrrr1rV)r~rrrr1r2r0)r~rr1rV)r~rrrr1rV)r~rrrrrr1r2) r~rrrrr5rr.r1r2) r~rrrrr5rr.rrr1r2)r~rrrr1z/tuple[Optional[bool], Optional[dict[str, Any]]])rGrrHrr1rVrr3)rhOptional[dict]r1zTuple[float, float])rrrrsrrpzOptional[float]r1rV)r4rrzrr{rr1rG) r4rrrrrsrrzrr{rr1rV)r1r)rrVr1r')r4rr1r)r4rrrr1r5)r4Callable[[CompressionCommitFence], Tuple[list, str]]rzr'rrrprrrr(Optional[Callable[[float, float], None]]r&Optional[Callable[[bool, bool], None]]rrr.Optional[Callable[[], CompressionCommitFence]]rrVr1Optional[Tuple[list, str]])rr(rrrzr'rrrprrrrrrrrrrrr1r) rGrrrrirrjrrrr1zTuple[bool, Any]) rGrrjrrrrrr1r)rrr1rV) rGrrrrrVrjrr1r2)rrrzr'rrrprrrrz/Optional[Callable[[float, float, float], None]]rrrrrrrrrrVrrrz>Optional[Callable[[CompressionCommitFence], Tuple[list, str]]]rrVr1Tuple[list, str])r4rr1rG)rrGr1r)r rr1rV)r~rrrVr1r2)rrrrGr1rV)r4rrsrrrGrrGrrr!r0r1r2)r4rr<rGr1rG)r4rrsrrrr1r2)rzr'rrr1r2)r~rrr(r1r2)r4rr1rV)r4rrMrVr1z/Optional[Tuple[Any, Optional[threading.local]]])r4rrTrVr1r2)r4rrerVrrVr1rV)r4rr~rr1r2)rrGr1r2)r4rrrrrGr1Optional[List[Dict[str, Any]]])rrrrGr1r2)r4rr1r)rrrrrrrrVrrGrerVr1r()rzrr1zlist[dict[str, Any]])r4rrrGr1r2) r4rr)rGr*rr+rGr,rGr1r2)r4rr)rGr,rGr1rV)r4rr`rr1r2)r4rrzr'rkrr1r)rrr1rG)rrr1rV)r1zTuple[str, str])rrr1r)rzr'r1rV)rrr1r)rrrrr1rV)rr(rrr1r2)rr'r1rG)rr(rr(r1r2)rzr'rr(r1r)rr'rr'r1r)rrrrr1rV)rr'rr(rrVr1r2)r4rrrGrrGr1rV)r4rrrGrrGr1r2)r4rrrVr1rV)r rr1zTuple[Any, Optional[Exception]])r4rrdrr<rGrrrrGrrr1Tuple[None, str])rrrrrrrr1rV)r4rrrrdrr<rGr{rrrr1r)r4rrrrrdrr<rGr{rrrr1z1Tuple[Optional[_CompressionLease], Optional[str]]) r4rrrrzr'r<rGr1r)r4rrrrzr'r1r)r4rrzr'rLrVr1rG)r4rr{rrrrrVrrGrerVr1z)Tuple[Callable[..., Any], dict[str, Any]])r4rrzr'rzCallable[..., Any]rRrrrrrrr]rr1r')r4rrr'r1r2)r4rrzr'rr'r<rGrrrr(r1z$Tuple[Optional[list], Optional[str]])r4rrrGrrr1r2)r4rrrGr1rG)r4rrzr'rr'rrGrrrrGrrGr1r2)rrGrrGrrVr1r2)r4rrr'rrGrrrrVrrVrrVrrVrrVrrVrrVrrGr1r)r4rrrrzr'rr'rrrrr1rV)r4rrzr'rr'rrVrrrrGr<rGrrGrrrrVr;rr1r)r4rrzr'rrrrVrLrVr{rrrrrVrerVrrrr]rr<rGr;rr1r)r4rrrVr4rVr1r)r4rrzr'r<rGrrrr;rr{rrrGrrVr1r) r4rr=rr{rrrrrVr1r)r4rrzr'r<rGr{rrrGrrrrVrerVrrVrrrr1r)r4rr1r)r4rrrGr1r2)r4rrzr'r<rr{rrrGrrVr1r)rq)rwrGrrGr1rG)rrGr1zOptional[tuple])rrGrrrrr1r)rrr1r)rr(rrGr1r()rr'rrr1rV)r: __future__rconcurrent.futuresrBr contextvarsr| dataclassesr r5loggingrrxrrr1rrpathlibrtypingrrrr r r r rfr agent.context_enginerragent.memory_providerrrLrragent.session_activityrragent.usage_anchorrhermes_state_idsrr getLoggerr7rcontextmanagerr frozensetAGENT_COMPRESSION_TIMEOUTAGENT_COMPRESSION_COOLDOWNrrrIr>rr3r.r5#PRE_API_COMPRESSION_STATUS_TEMPLATE%PREFLIGHT_COMPRESSION_STATUS_TEMPLATEIDLE_COMPACTION_STATUS_TEMPLATE+COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATE*COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE(COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE1COMPRESSION_RETRY_CONTEXT_REDUCED_STATUS_TEMPLATE)CONTEXT_OVERFLOW_BLOCKED_WARNING_TEMPLATEformat"ROUTINE_COMPRESSION_STATUS_SAMPLESrNrXr{rrrr ContextVarrrrrrrrrrrrrrrrrcrdrrXrZrrrJrOrMrNrPrSr\rorur}rrrrrrrrrrrrrrrrrrrrrr rr=r?rArCrHrPrUrYr[r^rhrkrdr{rrrrrrrrrr9r>r[r^rarfrmr|rrr{r~rrrrrrrrrrrrrrrrrrrrrrrrrr"r+r7r<rFrOrTrcrwrrrrrrrrrr dataclassrrrr,rr5r9r@rPrSrVr8rrrxrrrrr__all__rr<rOrrs#    FFF@]E^T/>   8 $ /4YY%.113E3`3`a%!#%0788rs!))A(BCCDQs=y$i&c Z,.m*+n(R21*24J'..f.=)00&0Q#**V*L/66faUV6W.55Rr5J,3363P5<>+?Uk>T>T*D? ; " a L.Y .G 00-0>L0]u0 0<dh7;ae-------R`--4--Q^-- --`#.#.'5#.4#.LTTp#((-% #6""0).."2&*" ,/(F"#)9>>+* * "Lsw5CH`o >> !AOT`c  8&RR #CG?C\`@Dej %C%OS%%7<%UZ%@%= %WZ % > % _c %  %PG& G&PG&\`G&G&7<G&UZG&@G&TzG& G&&T G&  G&T .9>IN^cD$ $"$27$Lt$$N / /./DH/SX/ /2CG?CBF.24hl@DVZ#(a,Ca,OSa,a,7<a,UZa,@a,= a, @ a, , a, FI a, bf a,>a,Ta,!a,a,HR|R1! ?& [D X\ Xpjn&*  $ 58 HK \f #   Dg  . ]1K KK4K" 6; : Ggk(0":* (; ;;47;#;| a>m27UU)6UERU[_UU*.U U.g)g)T.44n'K K!K03KCFKVYK K\PYRx 2 2& DDH 2@& N35;8+0. $&r"4&$$cdB"D  V[0@(Z$4 B//,Q-Q-h&15   / AD Z_   -  Dn n(n5In[^n n6;nn>G G!AGNbGG(5GKPG7GT" "("48"JM""B,^%P( ("/(>K(TX(jm((/(*8 88-?8R`828HK8`c8 8vGlT,^: ::,0:EH:^c::*:z OD GCD CDCD,0CDHKCDTeCDCD7:CD CDL4ACSW(([ [ [8;[MZ[fj[[8<[ae[ $[AE[ei[ [  [|M MM+/MNRMM16M M`      H HH,0H?CHL]HH,/HORH"0HAEHPXH HV '''O OO*;OGKObfO O/<OEIO\`O3OHKO]`O O  Od    "6B) ))03)Ff) )&3)>A)JN))"5 5"%56C5R_5hl55(X\4u!U59 @- @-@-03@-GT@- @-+8@-HL@-@-GK@-3 @-  @-F" ;bfED% D%D%0=D%Q^D% D%%)D%D%R-fGSYhn  2.jc\TXL^ K KrO