߲j@ >UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZddlmZmZddlmZddlmZmZmZmZmZddlmZej6eZd Zd Zd Z d Z!d Z"dZ#dZ$d Z%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3ddd d!d"dZ4id#d#d$d#d%d#d&d#d'd'd(d'd)d'd*d'd+d'd,d,d-d,d.d,d/d,d0d,d1d1d2d1d3d1d1d1d4d4d4d4d4d5Z5e Gd6d7Z6dyd8Z7dzd9Z8e Gd:d;Z9dd<d{d=Z:e Gd>d?Z;d|d@ZdB<e j~Z@iZAdCe>dD<dEZBdFZCd}dGZDd~dHZEddIZFddJZGddKZHddLZIddMZJddNZKddOZLdPdQddRZMddSZNddTZOddUZPejdVejZSddWZTddXZUddYZVddZZWdd[ZXdd\ZYdd]ZZdddddd^ dd_Z[dd`Z\daZ]dbZ^dcZ_dddZ`ddeZaddfZbdddgddhZcddiddjZdddkZedlZfGdmdnZgdoZhdpZidqdrdsdtduZjedPddv ddwZkgdxZly)uPersistent session goals — the Ralph loop for Hermes. A goal is a free-form objective that stays active across turns; after each turn an auxiliary-model judge decides whether it is satisfied. The continuation prompt is a normal user message appended via ``run_conversation`` (no system-prompt mutation or toolset swap — prompt caching stays intact). Judge failures are fail-OPEN (``continue``); the turn budget is the backstop. ) annotationsN) dataclassfieldasdict)datetimetimezone)Path)AnyDictListOptionalTuple)noninteractive_git_envg>@i,ii a[Continuing toward your standing goal] Goal: {goal} Continue working toward this goal. Take the next concrete step. If you believe the goal is complete, state so explicitly and stop. If you are blocked and need input from the user, say so clearly and stop.a[Continuing toward your standing goal] Goal: {goal} Completion contract: {contract_block} Continue working toward the outcome above. Take the next concrete step. Stay within the stated boundaries and do not violate the constraints. Before claiming the goal is done, satisfy the Verification criterion and show the concrete evidence (command output, file contents, test result). If you hit the stated stop condition or are otherwise blocked and need user input, say so clearly and stop.a{[Continuing toward your standing goal] Goal: {goal} Additional criteria the user added mid-loop: {subgoals_block} Continue working toward the goal AND all additional criteria. Take the next concrete step. If you believe the goal and every additional criterion are complete, state so explicitly and stop. If you are blocked and need input from the user, say so clearly and stop.u[Continuing toward your standing goal — a quality gate failed] Goal: {goal} The quality gate command below must pass before this goal can be declared done, and it just failed (attempt {attempt}/{max_retries}): $ {command} Exit code: {exit_code} Output (tail): ``` {output} ``` Fix the underlying problem so this gate passes, then re-run it to confirm. Do not declare the goal complete while any gate fails. If the gate itself is wrong or cannot pass, say so clearly and stop.un You are a strict judge evaluating whether an autonomous agent has achieved a user's stated goal. You receive the goal text, the agent's most recent response, and — when present — a list of background processes the agent has running. Decide one of four verdicts. DONE — the goal is fully satisfied: - The response explicitly confirms the goal was completed, OR - The response clearly shows the final deliverable was produced. DONE requires the deliverable to actually exist. If the response only explains why the goal cannot be reached, the verdict is BLOCKED, not DONE. BLOCKED — the goal cannot be satisfied as stated: - The response explains the goal is genuinely unachievable (impossible, out of scope, no valid path to the deliverable), or refuses to fabricate a deliverable that cannot exist, OR - The response explains progress is blocked and the next step needs user input to proceed. Return BLOCKED with the reason describing what is blocking. BLOCKED is a refusal, not a completion — never return BLOCKED for a goal that was achieved. When the block is an error the agent hit (an HTTP status, an API, sign-in or token failure), quote the error text verbatim in the reason and attribute it only to a provider, service or credential the response itself names. Never infer one the response does not name — an unnamed 401 belongs to the model provider the agent was calling, not to some other service's token. WAIT — the goal is NOT done, but the next step is to wait for async work to finish rather than act again. Choose this ONLY when the agent's progress is genuinely gated on something running on its own: - A background process listed below is still running AND the response shows the agent is waiting on its result (e.g. a CI poller, build, test run, deploy). If the process has a session id, return it in ``wait_on_session`` — that releases when the process exits OR its watch_patterns trigger fires (use this for a long-lived watcher that signals mid-run and may never exit). Otherwise return its pid in ``wait_on_pid`` (releases on exit only). - The agent says it is rate-limited / backing off / must wait a fixed period — return seconds in ``wait_for_seconds``. - The agent has delegated subagents still running (stated below as active delegations) and the response says it is waiting on them with nothing else dispatchable — return ``wait_for_seconds`` between 600 and 1800. Their results wake the agent on their own; re-poking it now only produces a status recap. Picking WAIT parks the loop without burning a turn; it resumes automatically when the pid exits or the time elapses. Do NOT pick WAIT just because work remains — only when re-poking now would be pure busy-work because the agent can't progress until the async thing finishes. CONTINUE — not done, and there is a concrete next step the agent can take right now. This is the default when in doubt. Reply ONLY with a single JSON object on one line. Shapes: {"verdict": "done", "reason": ""} {"verdict": "blocked", "reason": ""} {"verdict": "continue", "reason": ""} {"verdict": "wait", "wait_on_session": "", "reason": ""} {"verdict": "wait", "wait_on_pid": , "reason": ""} {"verdict": "wait", "wait_for_seconds": , "reason": ""} The legacy shape {"done": , "reason": "..."} is still accepted (true=done, false=continue).zActive delegations: the agent has {count} delegated subagent batch(es) still running; their results are delivered to it automatically when they finish. znBackground processes the agent currently has running (it may be waiting on one of these): {background_lines} uGoal: {goal} Agent's most recent response: {response} {background_block}Current time: {current_time} Is the goal satisfied — done, blocked, continue, or wait?uGoal: {goal} Additional criteria the user added mid-loop (all must also be satisfied for the goal to be DONE): {subgoals_block} Agent's most recent response: {response} {background_block}Current time: {current_time} Decision: For each numbered criterion above, find concrete evidence in the agent's response that the criterion is satisfied. Do not accept generic phrases like 'all requirements met' or 'implying it was done' — require specific evidence (a file contents excerpt, an output line, a command result). If ANY criterion lacks specific evidence in the response, the goal is NOT done — return CONTINUE (or WAIT if blocked on a listed background process). Is the goal AND every additional criterion satisfied?uXGoal: {goal} Completion contract (the authoritative definition of done): {contract_block} Agent's most recent response: {response} {background_block}Current time: {current_time} Decision rules: - The goal is DONE only when the Verification criterion is satisfied AND the response shows concrete evidence of it (a command result, file contents excerpt, test/benchmark output) — not a claim like 'done' or 'all tests pass' without evidence. - If any stated Constraint was violated, the goal is NOT done — CONTINUE. - If the response shows the agent is waiting on a listed background process to satisfy the Verification criterion (e.g. CI is the verification and it's still running), return WAIT on that process instead of re-poking — re-poking now would be pure busy-work. - If the response explains the work is genuinely unachievable or hits the stated Stop condition and needs user input, the goal is NOT done — return BLOCKED with the reason describing the block. - Otherwise the goal is NOT done — CONTINUE. Is the goal satisfied per its completion contract — done, blocked, continue, or wait?aYou turn a user's plain-language objective into a structured completion contract for an autonomous coding agent. The contract has five fields: - outcome: the single end state that must be true when done - verification: the specific test / command / artifact that PROVES the outcome (must be concrete and checkable) - constraints: what must NOT change or regress - boundaries: which files, dirs, tools, or systems are in scope - stop_when: the condition under which the agent should stop and ask for human input instead of pushing on Infer sensible, specific values from the objective and any project context implied by it. Prefer concrete verification (a named test command, a build, a benchmark) over vague phrases. Keep each field to one or two sentences. If a field genuinely cannot be inferred, use an empty string for it. Reply ONLY with a single JSON object on one line: {"outcome": "...", "verification": "...", "constraints": "...", "boundaries": "...", "stop_when": "..."})outcome verification constraints boundaries stop_whenOutcome Verification Constraints BoundarieszStop when blockedrgoaldonez done whenrverifyz verified byevidenceproofr constraintpreservezmust notz do not changerboundaryscoper)allowedfilesz stop whenrblockedzstop if blockedz give up whenceZdZUdZdZded<dZded<dZded<dZded<dZ ded<dd Z dd Z e dd Z dd Zy ) GoalContractzMOptional structured completion contract; empty fields are omitted everywhere.strrrrrrc6tfdtD S)Nc3RK|]}t|j ywN)getattrstrip.0fselfs 5/home/ubuntu/.hermes/hermes-agent/hermes_cli/goals.py z(GoalContract.is_empty..'s!JAwtQ'--/Js$')any_CONTRACT_FIELDSr6s`r7is_emptyzGoalContract.is_empty&sJ9IJJJJcJtDcic]}|t||c}Scc}wr0)r:r1)r6r5s r7to_dictzGoalContract.to_dict)s"-=>74##>>>s c t|ts|S|ditDcic]/}|t|j |xsdj 1c}Scc}w)Nr,) isinstancedictr:r-getr2)clsdatar5s r7 from_dictzGoalContract.from_dict,sP$%5LSAQRAaTXXa[.B/5577RSSRs4A c@djfdtDS)uFNon-empty fields as a labelled block; empty contract → empty string. c3K|]F}t|jsdt|dt|jHyw)- : N)r1r2_CONTRACT_LABELSr3s r7r8z,GoalContract.render_block..4s^GTUmtuy{|m}nDnDnF2.q12"WT15E5K5K5M4NOGs A,A)joinr:r;s`r7 render_blockzGoalContract.render_block2s%yyGYiGG Gr=Nreturnbool)rQzDict[str, str])rFOptional[Dict[str, Any]]rQz'GoalContract'rQr-)__name__ __module__ __qualname____doc__r__annotations__rrrrr<r? classmethodrGrOrAr=r7r+r+s^WGSL#KJIsK?TT Gr=r+c |s dtfSg}tDcic]}|g}}|jD]}|j}|sd|vr{|j d\}}}t j |jj} | 3|jr#|| j|j|j|tdi|jD cic]%\}} |dj| j'c} }} dj|j| fScc}wcc} }w)uSplit user-typed goal text into a headline + contract from inline ``field: value`` lines. A headline without an explicit ``outcome:`` IS the outcome — it is not duplicated into the contract block (the goal text already carries it), so outcome stays empty in that case. r,: rA) r+r: splitlinesr2 partition_CONTRACT_ALIASESrDlowerappenditemsrN) textheadline_partsr5fieldsraw_linelineprefix_valuekeyvcontracts r7parse_contractro7s, <>!! "N3C#DaArE#DF#DOO% $~~  $;#~~c2 FAu#'' (<(<(>?C5;;=s ""5;;=1d# $R&,,.Q$!Qq#((1+"3"3"55QRH 88N # ) ) +X 55$ERs E7*E cHdjdt|dDS)NrIc32K|]\}}d|d|yw)z- Extra criterion rLNrAr4irds r7r8z)_render_extra_criteria..Qs"b'!T)!Btf5bstart)rN enumerate)subgoalss r7_render_extra_criteriarzPs 99bYx_`Eab bbr=c|eZdZUdZded<eZded<eZded<dZ ded<d Z d ed <d Z ded <ddZ e ddZy )GoalGatezA deterministic shell command that must pass before a goal can be done. Gates run at turn boundary BEFORE the LLM judge; a failing gate short-circuits judging and its bounded output becomes the continuation prompt. r-commandinttimeout_seconds max_retriesrattemptsN Optional[int]last_exit_coder,last_output_tailct|Sr0)rr;s r7r?zGoalGate.to_dictds d|r=c t|ts |dS|t|jdxsdt |jdxst t |jdxst t |jdxsd|jdt |dndt|jd xsd S) Nr,)r}r}rrrrrr)r}rrrrr)rBrCr-rDr~DEFAULT_GATE_TIMEOUT_SECONDSDEFAULT_GATE_MAX_RETRIES)rErFs r7rGzGoalGate.from_dictgs$%r? "+1r2): ; [?[\DHH]3O7OP*-23;?88DT;U;aC%5 67gk *.s-wTUuv:a-a188GY3OOws3)3Fz [gate timed out after zs]z[gate could not run: rL]) subprocessrunr}maxr~rstdoutstderr returncode_GATE_OUTPUT_TAIL_CHARSTimeoutExpiredrN ExceptiontyperU)gaterproccombinedexcouts r7run_gaterus3O~~ LLTw_h3t33453;$ KK%2$++4$+++=SUV!#T__h@W?W?X6YYY  $ $qggwZ]ZdZdfifpfpYqwwb3#;D ?gk88$45!++DHHZ,@A040A0GR*+a&3quuY/?/E2+F+L+L+N""1% ! !  \yN s&H7&H< I,IAI cX|jduxr|jj Sr0)rnr<r;s r7 has_contractzGoalState.has_contracts&}}D(I1G1G1I-IIr=c\djdt|jdDS)z?Numbered ``- N. text`` block; empty when there are no subgoals.rIc32K|]\}}d|d|ywrKz. NrArrs r7r8z2GoalState.render_subgoals_block..s![ga2aS4&)[rtrurv)rNrxryr;s r7render_subgoals_blockzGoalState.render_subgoals_blocks#yy[4==XY9Z[[[r=cXd|_d|_d|_d|_d|_d|_y)Nrr)rrrrrrr;s r7 clear_waitzGoalState.clear_waits2""& &'#" r=rT)rr-rQz 'GoalState'rPrQNone)"rUrVrWrXrYrrrrrrrrrrrrrryrrrrrrr+rnrrrZrrrrrAr=r7rrs 5 IFCJ&Is&JL%"&L-&!%K%#'M='&''+,"C+5Hi5%)NM((, ,M5#$C#$(NM(M5"<@Hl@!$7E>7<  0J\!r=rc d|S)Nzgoal:rA) session_ids r7 _meta_keyrs :, r=r _DB_CACHEzDict[str, threading.Event]_DB_BOOTSTRAP_INFLIGHTg?g?c> t|}t5||t vr |t |<d}t j|dddd| t||jy#t$r"}tjd|d}Yd}~~d}~wwxYw#1swYUxYw)zDConstruct SessionDB off-loop and populate the cache (worker thread).z/GoalManager: background SessionDB() raised (%s)N) _acquire_session_dbrloggerdebug_DB_BOOTSTRAP_LOCKrrpop_release_session_dbset)homerdbrs r7_bootstrap_session_dbrs  & / >d)3 IdOB""4. /  ~BHHJ  FL //s" A%,B% B.B  BBcZ ddlm}t|}t j|}|:t|r/t5t j||urt |=dddd}||S tjd}|rt5t j|}| |cdddStj|}t}|Ptj x}t|<tj"t$||fddj't(}dddj+t j|S t-|}t5t j|}|t/||cdddS|t |<ddd|S#t$r }tj d|Yd}~yd}~wwxYw#1swYlxYw#t$rd}Y`wxYw#1swYxYw#t$r }tj d |Yd}~yd}~wwxYw#1swY|SxYw) asCached SessionDB per HERMES_HOME (profile switches pick the right DB); None on any failure. Never constructs SessionDB on an event-loop thread: a cache miss there kicks a one-shot background bootstrap and waits a bounded grace window (the kick call waits ``_DB_BOOTSTRAP_INIT_WAIT_S`` so a healthy cold init completes and the first write isn't dropped). r)get_hermes_homez,GoalManager: SessionDB bootstrap failed (%s)NTFzgoals-sessiondb-bootstrap)targetargsnamedaemonz$GoalManager: SessionDB() raised (%s))hermes_constantsrr-rrrrrD_registry_tore_downrasyncioget_running_loop RuntimeErrorr_DB_BOOTSTRAP_LOOP_WAIT_S threadingEventThreadrrw_DB_BOOTSTRAP_INIT_WAIT_Swaitrr) rrrcachedon_loop_threadrrrexistings r7_get_session_dbrs4?$% ]]4 F 1&9  $}}T"f,dO $    "  1]]4(F! 1 1 *--d3D,D|6?oo6GG-d3  (=T4LWr{AGGI0 1 $}}T""  & ==&    #   $  Ie  CSI $ $  1 1  ;SA IsrFG .G G(/A-G( G4$H  H  G&GG G G%$G%(G14 H=HH H*c6ddlm}|t|dz S)uThe registry's shared handle for ``home/state.db``. A bare ``SessionDB()`` here was a SECOND writer per profile beside the gateway's registry handle — its own token-writer thread and close-time checkpoint (the #90837 corruption shape), doubled under multiplexing.r)acquirezstate.db)hermes_state_registryrr )rrs r7rrCs. 4: * ++r=c@ddlm} ||y#t$rYywxYw)Nr)release_or_close)rrr)rrs r7rrKs$6     s  c t|ddduS)aTrue once the registry force-closed *db* (``close_all`` / ``close_all_under`` clear the shared-owned flag at teardown); every handle cached here was acquired through the registry, so a cleared flag means the connection is gone and the cache entry is stale._shared_registry_ownedTF)r1)rs r7rrSs 2/ 6% ??r=c4tjd|||y)uWARN on a dropped state write — the reply already told the user the state was set. One shared message keeps goal, loop and heartbeat logs greppable as one bug class.up%s: %s for %s not persisted — session DB unavailable (bootstrap window exceeded, in-memory state still active)N)rwarning)managerkindrs r7_warn_dropped_writer Zs NN Dzr=c<|syt}|y |jt|}|sy t j|S#t$r }tj d|Yd}~yd}~wwxYw#t$r!}tjd||Yd}~yd}~wwxYw)z4Load the goal for a session, or None if none exists.Nz GoalManager: get_meta failed: %sz3GoalManager: could not parse stored goal for %s: %s) rget_metarrrrrrr )rrrrs r7 load_goalrds   B zkk)J/0 ""3''  7= LjZ]^s.AA1 A.A))A.1 B:BBc|syt}|tdd|y |jt||j y#t $r }t jd|Yd}~yd}~wwxYw)z5Persist a goal to SessionDB. No-op if DB unavailable.N GoalManagerrz GoalManager: set_meta failed: %s)rr set_metarrrrr)rstaterrs r7 save_goalrysd   B zM6:>> Ij)5==?; > 7==>s)A A2A--A2cFt|}|yd|_t||y)zDMark a goal cleared in the DB (preserved for audit, status=cleared).Ncleared)rrr)rrs r7 clear_goalrs% j !E }EL j% r=r,reasonc*|r|r||k(ry t|}||jdk(ryt|yt||t|tj d|||xsdy#t $r }tj d|Yd}~yd}~wwxYw)utCarry a persistent /goal from a parent session to its continuation. Best-effort, never raises (a failure here must not block compression). Returns True when a goal was migrated. Context compression rotates ``session_id`` to a fresh child session, but ``load_goal`` does a flat ``goal:`` lookup with no parent-lineage walk — so an active goal silently dies at the compaction boundary (#33618). Copy the goal onto the new session and archive the old row as ``cleared`` so exactly one active goal row exists per logical conversation (avoids the "two active goals" hazard of a pure copy). FNrz(GoalManager: migrated goal %s -> %s (%s)rotationTz&GoalManager: goal migration failed: %s)rrrrrrr)old_session_idnew_session_idrrrs r7migrate_goal_to_sessionrs >^3S.) =ELLI5 ^ $ 0.%(>" ?Q_agaukuv  =sCs!A) A)3A)) B2B  Bc8|syt||kr|S|d|dzS)Nr,u… [truncated])len)rdlimits r7 _truncater"s* t9%4K4<:K+KKr=c|r|dkry ddlm}t|t|S#t$rYnwxYw ddl}t|j t|S#t$rYywxYw)zLiveness via ``gateway.status._pid_exists`` (psutil + ctypes/POSIX fallback). Never uses ``os.kill(pid, 0)``: on Windows that routes to CTRL_C_EVENT and hard-kills the target's console group (bpo-14484).rF) _pid_existsN)gateway.statusr$rRr~rpsutil pid_exists)pidr$r&s r7 _pid_aliver)sr #( .KC)**    F%%c#h/00 s* 66&A!! A-,A-ch|sy ddlm}t|j|S#t$rYywxYw)zTrue while the process_registry session is running and its trigger hasn't fired. Fail-safe: any import/registry error yields False so a stale barrier can never wedge the loop.Frprocess_registry)tools.process_registryr,rRis_session_waitingr)rr,s r7_session_waitingr/s; ;$77 CDD s % 11z\{.*?\}c ddlm}||jdxsijdij||}|dkDr|S |S#t$rY|SwxYw)zResolve ``auxiliary.goal_judge.``; non-positive/garbage falls back to ``default`` rather than crashing the loop. ``load_config()`` is cached on (mtime, size) so this is cheap.r) load_config auxiliary goal_judge)hermes_cli.configr1rDr)rldefaultcastr1rks r7_goal_judge_settingr7ss 1km'' 4:?? bQUUVY[bcd 19L  N   N sA A AAc,tdttS)N max_tokens)r7DEFAULT_JUDGE_MAX_TOKENSr~rAr=r7_goal_judge_max_tokensr;s |-Es KKr=c,tdttS)Nr)r7DEFAULT_JUDGE_TIMEOUTrrAr=r7_goal_judge_timeoutr>s y*? GGr=c|sy|j}|jdr/|jd}|jd}|dk7r||dzd} tj|}t|tr|SdS#t $rRt j|}|sYy tj|jd}n#t $rYYywxYwYnwxYw)zRBest-effort: strip code fences, parse the blob, else pull the first ``{...}`` out.Nz````rIrrur) r2 startswithfindrrr_JSON_OBJECT_REsearchgrouprBrC)rrdnlrFmatchs r7_extract_json_objectrHs  99;D uzz# YYt_ 8Q=D zz$dD)43t3 &&t, ::ekk!n-D    s6A>> C!$CC CCCCCc8 |syt| ddt|dddfSt jdxsdj xsd } jd }t |tr|j j }nR jd }t |tr |j j d vn t|}|rd nd}|d vrd}|dk7r||ddfSd fd } jdxs$ jdxs jd}t |tr&|j rd|dd|j ifS|ddd}|d|dd|ifS|ddd} | d|dd| ifSd|dddfS)aParse the judge's reply, fail-open. Returns ``(verdict, reason, parse_failed, wait_directive)``. ``parse_failed`` flags non-JSON output so callers can auto-pause after N in a row. ``wait_directive`` is ``{"session_id"}`` / ``{"pid"}`` / ``{"seconds"}`` for a ``wait`` verdict; a wait with no target is downgraded to ``continue``. Accepts ``{"verdict": ...}`` and the legacy ``{"done": }`` shape. )continuezjudge returned empty responseTNNrJzjudge reply was not JSON: Trr,zno reason providedverdictr>1yesrtrue>rrr)rJrFc|D]-} j|t|nd}|dkDs+|cSy#ttf$rYBwxYw)Nr)rDr~ TypeError ValueError)keysrivrFs r7 _first_intz)_parse_judge_response.._first_int!s_ A %)XXa[%\g@hi"8":G D ||A&&..4"4 s&A AA)rryrlrnactive_delegationscT|jsy|jsy| t} ddlm}ddlm}|xsgD cgc]&} | s| js| j(} } tt|d t|tt||dkDrtj| nd ztj t"j$ j'j)d } |T|j+sD|j-} | r| dt/| } t1jd dt| di| }n\| rEdj3dt5| dD}t7jd dt|d i| }nt9jd i| } t;|t<||}tE|\}}}}tj?d|t|d|rd|nd ||||dfS#t $r } tjd| Yd} ~ yd} ~ wwxYwcc} w#|$r*} tj?d| dd| dddfcYd} ~ Sd} ~ wt $r=} tj?d| ddtA| jBdddfcYd} ~ Sd} ~ wwxYw)!aGAsk the auxiliary model whether the goal is satisfied. Returns ``(verdict, reason, parse_failed, wait_directive, transport_failed)``; verdict is done / blocked / continue / wait / skipped. ``parse_failed`` means unusable output; transport errors set ``transport_failed`` instead and fail-open to ``continue``. )skippedz empty goalFNF)rJz$empty response (nothing to evaluate)FNFNrr~)AuxiliaryClientUnavailablez.goal judge: auxiliary client import failed: %s)rJzauxiliary client unavailableFNFi)countr,)tzz%Y-%m-%d %H:%M:%S %Z)rresponsebackground_block current_timerIcontract_blocki c32K|]\}}d|d|ywrrArrs r7r8zjudge_goal..s!"f4Rs"TF#3"frtrurvsubgoals_blockuMgoal judge: auxiliary client unavailable (%s) — falling through to continuerJz)goal_judge auxiliary client unavailable: FTu@goal judge: API call failed (%s) — falling through to continuez judge error: z"goal judge: verdict=%s reason=%s%srcz wait=rA)#r2r>agent.auxiliary_clientr~agent.auxiliary_unavailablerrrrrCr"_JUDGE_RESPONSE_SNIPPET_CHARSrs JUDGE_DELEGATIONS_BLOCK_TEMPLATErkrnowrutc astimezonestrftimer<rOrz(JUDGE_USER_PROMPT_WITH_CONTRACT_TEMPLATErNrx(JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATEJUDGE_USER_PROMPT_TEMPLATErJUDGE_SYSTEM_PROMPTinforrUr`)r last_responserryrlrnrr~rrrclean_subgoalscommonrpromptrrrLr parse_failedwait_directives r7 judge_goalrfs ::<:    U%'N3J+3.bMAQ1779aggiMNM  tT "=*GH12FGPbefPf + 2 29K 2 Llnp\\X\\2==?HHI_` FH$5$5$7!..0  ./r2H2X1YZN9@@zPYZhjnPozsyz "f9^cdCe"ff9@@zPYZhjnPozsyz+22 KK4gyQT?U-;&()E FL.% ??O N EsKMN N* &`  cehiFseLeUY[___ S VX[\]49+=+=*>?dRRSsY HH/ H/H/1H4 H, H''H,4J'9IJ' J'*2J"J'"J'c r|sy ddlm}m}t||ddt |S#t $rYywxYw)zDLive async delegation batches spawned by this session (fail-safe 0).r) _LIVE_STATES_session_recordsr,)tools.async_delegationrrr r-r)rrrs r7count_active_delegationsrs= I#L"b#j/JKK s $* 66zV[Goal set] Continue with the goal you were just given; there is no need to re-read it.g?c~|}t|trdjd|D}djt|xsdj djt|xsdj }}t |t k\r(||vr$t |tt |zk\rtS|S)zaThe goal text, or ``GOAL_ALREADY_SEEN_KICK`` when ``last_user_message`` is essentially that text.r]c3tK|]0}t|tst|jdd2yw)rdr,N)rBrCr-rD)r4bs r7r8z#goal_kick_prompt..s+ZajQRTXFY3quuVR01Zs8 8r,) rBrrNr-splitr _GOAL_REPASTE_MIN_CHARS_GOAL_REPASTE_MIN_SHAREGOAL_ALREADY_SEEN_KICK)rlast_user_messagerw goal_norm last_norms r7goal_kick_promptrsG'4 ((Z7ZZ88C O$9$9$;byI I11  "  N5IF F%% Kr=ct|xsgD]:}t|ts|jddk(s)|jdcSy)zZContent of the newest ``role == "user"`` message in an OpenAI-shaped history, else ``""``.rvrxrwr,)reversedrBrCrD)historymsgs r7last_user_message_contentrsG 2&& c4 SWWV_%>779% %& r=c|sy t}|y|jt|dd}t|S#t$rYywxYw)zNewest user message of ``session_id`` from the SessionDB (gateway/TUI surfaces have no live history object at slash-command time); ``""`` on any error.r,rT)r!latest)r get_messagesr-rr)rrrowss r7last_user_message_from_dbrsT    :s:bF(.. s :': AA) owner_task_idc ddlm}|j|xsg}|Dcgc]*}t |ts|jddk7s)|,}}|rM|Dcgc]B}t|jdxs|jd xsd t|k(sA|D}}|S#t$r"}tj d|gcYd}~Sd}~wwxYwcc}wcc}w) aFail-safe snapshot of RUNNING ``process_registry`` sessions for the judge; ``[]`` on any error so the loop degrades to its pre-wait-barrier behavior. ``owner_task_id`` restricts the snapshot to processes the goal's OWN session spawned. The registry's ``task_id`` is the container key, which collapses to one value for every agent in the process, so without this filter a fan-out parent's judge saw every subagent's pollers and parked the goal on a grandchild's ``proc_*`` session (one run: 7 of 7 root verdicts were WAIT on child-owned processes; parked 3 h 22 min at the end while nothing of its own was running).rr+)task_idz&gather_background_processes failed: %sNrrbrrr,) r-r, list_sessionsrrrrBrCrDr-)rrr,sessionsrrrunnings r7gather_background_processesrs;#11'1BHb#ZQjD&9aeeHoQY>YqZGZ%uQUU?-C-]quuYGW-][])^befsbt)t1uu N  =sC [us:B$CC CACC$ C-C C C)rc |xsdj}|sy| t} ddlm} t|tdt|d|}t|}t|ts!t j d t|d ytj|}|j!rdS|S#t$r }t j d|Yd}~yd}~wwxYw#t$r }t jd|Yd}~yd}~wwxYw) zExpand a plain-language objective into a completion contract via the ``goal_judge`` auxiliary task (a side LLM call, not a conversation turn). None when unavailable or unparseable.r,Nrrz.goal draft: auxiliary client import failed: %sz Objective: rz goal draft: API call failed (%s)z"goal draft: reply was not JSON: %rrK)r2r>rr~rrrrDRAFT_CONTRACT_SYSTEM_PROMPTr"rrHrBrCr+rGr<) objectiverr~rrrFrns r7draft_contractrsb'')I &'3 "8-I\ZcdmosZtYuKvxA  $D dD ! 99S#;NO%%d+H$$&44H4  EsK  6<s.B0C0 C9CC D%DDc||||||dS)N)rshould_continuecontinuation_promptrLrr}rA)rrrrLrr}s r7 _decisionrsY_&W FFr=z~/.hermes/config.yaml: auxiliary: goal_judge: provider: {provider} model: {model} Then /goal resume to continue.ceZdZdZedd4dZed5dZd6dZd6dZ d6dZ d7dZ d5d Z d8d Z d8d Zd9d Zd:d Zdddd;dZddZddd?dZd@dZd9dZdAdZdBdZdCdZdDdZdEdZd7dZddddFdZdDd ZdEd!Zd7d"Z dGd#Z!dHd$Z"dIdJd%Z#dIdKd&Z$dId'd(dLd)Z%d6d*Z&d6d+Z'dMd,Z(d'd-dNd.Z)dIdOd/Z*ddd'd0 dPd1Z+dQd2Z,d7d3Z-y)Rra?Per-session goal state + continuation decisions. The CLI and gateway each hold one per live session. ``evaluate_after_turn`` calls the judge and returns the decision dict that drives the next turn; ``next_continuation_prompt`` is the canonical user-role message to feed back into ``run_conversation``. )default_max_turnscb||_t|xst|_t ||_yr0)rr~rrr_state)r6rrs r7__init__zGoalManager.__init__1s)$!$%6%K:K!L+4Z+@ r=c|jSr0)rr;s r7rzGoalManager.state8s {{r=cT|jduxr|jjdk(S)Nrrrr;s r7 is_activezGoalManager.is_active<s%{{$&I4;;+=+=+IIr=cR|jduxr|jjdvS)N>rpausedrr;s r7has_goalzGoalManager.has_goal?s&{{$&U4;;+=+=AU+UUr=cV|jduxr|jjSr0)rrr;s r7rzGoalManager.has_contractBs#{{$&E4;;+C+C+EEr=cJ|j}||jdk(ry|jd|jd}|jr5dt |jdt |jdk7rdnd nd }|j rd nd }|jr5dt |jd t |jdk7rdnd nd }||||}|jd k(r6|jrEt|jr0d |jxsd|jd|d|jS|jrEt|jr0d |jxsd|jd|d|jS|jrvtj|jkrUt!|jtjz }|jxs|d}d|d|d|d|jSd|d|jS|jdk(r1|j"rd|j"nd } d|| d|jS|jdk(rd|d|jSd|jd|d|jS)Nrz*No active goal. Set one with /goal ./z turnsz, z subgoalrurr,z , contractz gateru⏳ Goal (parked on session ): pid u⏳ Goal (parked us — u⊙ Goal (active, ru — u⏸ Goal (paused, ru✓ Goal done (zGoal ()rrrrryr rrrr/rrrr)rtimer~r) r6rturnssubcongatmeta remainingwrextras r7 status_linezGoalManager.status_lineEs KK 9I-?<<.!++f5UVU_U_3qzz?#83qzz?a3GCR+PQeg"//1lrLMGG3qww<.S\Q->cB%GHY[cU3%( 88x ##(89M9M(N-a.>.>.cHQMaMaLbBc-ddfgkfllopqpvpvowxxJq/?/?$@-a.>.>.[DIYIYHZB[-\\^_c^ddghihnhngopp499;#@$))+ => %%8I;a*9+VB4r$s166(SS'vS9 9 88x 12eAOO,-bE'veWCx@ @ 88v $TF#affX6 6zD6QVVH55r=cZt|j|j|jSr0)rrrr;s r7_savezGoalManager._saveas$//4;;/{{r=ch|j|js td|jS)Nno active goal)rrrr;s r7 _require_goalzGoalManager._require_goales* ;; dmmo/0 0{{r=cz|j|jjdk7r td|jS)Nrzno active goal to park)rrrr;s r7_require_activezGoalManager._require_activejs3 ;; $++"4"4"@78 8{{r=chd|j_||j_|jyNr)rrrrr6rs r7 _pause_statezGoalManager._pause_stateos#% $* ! r=cD|j|tddd|||S)NrF)rr)r6rrLrr}s r7_pause_decisionzGoalManager._pause_decisionts% -(5$IIr=N)rrnc |xsdj}|s tdt|ddtjd|r t |n |j ||n t |_|jS)Nr,zgoal text is emptyrrr)rrrrrrrn) r2rRrrr~rr+rr)r6rrrns r7rzGoalManager.setxsl !!#12 2h1[^(1c)nt7M7M!)!5X<>  zz|r=cv|jy|xs t|j_|jS)z=Attach or replace the completion contract on the active goal.N)rr+rnr)r6rns r7 set_contractzGoalManager.set_contracts. ;; '9<> zz|r=c|jsyd|j_||j_|jj|j Sr)rrrrrrs r7pausezGoalManager.pauses@{{% $* !  zz|r=T) reset_budgetc|jsyd|j_d|j_|jj|rd|j_|j S)Nrr)rrrrrr)r6rs r7resumezGoalManager.resumesO{{% $( !  %&DKK "zz|r=cn|jyd|j_|jd|_y)Nr)rrrr;s r7clearzGoalManager.clears+ ;;  &   r=c|jsyd|j_d|j_||j_|j y)Nr)rrrrrrs r7 mark_donezGoalManager.mark_dones9{{ # #)  "(  r=c|j}|xsdj}|s td|jj ||j |S)zNAppend a user-added criterion; raises ``RuntimeError`` without ``has_goal()``.r,zsubgoal text is empty)rr2rRryrbr)r6rdrs r7 add_subgoalzGoalManager.add_subgoalsQ""$ !!#45 5 d#  r=ct|j|}t|dz }|dks|t|k\rt dt|d|j |}|j |S)Nrurzindex out of range (1..))r1rr~r  IndexErrorrr)r6attr index_1basedrcidxremoveds r7 _pop_itemzGoalManager._pop_itemsl**,d3,!# 7cSZ'6s5zl!DE E))C. r=c|j}tt||}t||g|j |Sr0)rr r1setattrr)r6rrprevs r7 _clear_itemszGoalManager._clear_itemss;""$75$'(tR   r=c&|jd|S)z to add criteria))rrr;s r7render_subgoalszGoalManager.render_subgoalss( ;; %{{002m6mmr=)rrc|j}|xsdj}|s tdt||r t |nt |r t |nt }|jj||j|S)zNAppend a quality-gate command; raises ``RuntimeError`` without ``has_goal()``.r,zgate command is empty)r}rr) rr2rRr|r~rrrrbr)r6r}rrrrs r7add_gatezGoalManager.add_gatesz""$=b'')45 54CC0Ie,7K(=U   4   r=c:|jd|jS)z to require one)rurvr,ru ✓ passingu ✗ failing (exit z , attempt rrrKz. $ rI) rrrxrrrrbr}rN)r6rmrsrrs r7 render_gateszGoalManager.render_gatess ;; %{{  Wdkk//q9 :DAqF1$'!!-.q/?/?.@ 1::,VWXYXeXeWffgh LL2aSQYYKx8 9  :yyr=cV|j}| |jsy|jD]n}t|\}}}||_||_|rd|_+|xj dz c_|j |j kDr^|jd|j dz d|jdd|jd|j d|jd |d cS|jtj|j|j||j |j |xsd }td d|dd|d|jd|jd|jd|j d|j d|j cS|jy)aRun quality gates in order; return a decision dict on failure. Every eligible boundary re-executes a failed gate. A git HEAD+porcelain fingerprint used to replay the recorded failure when "nothing changed", but porcelain sees neither the contents of an untracked or already-modified file nor inputs outside the repo, so a repaired input was replayed as still-failing until retry exhaustion paused the goal (#110649). The retry cap below still bounds a genuinely stuck red suite. Nrruzquality gate exhausted z retries: $ gate_failedzgate exhausted retries: $ u5⏸ Goal paused — quality gate still failing after z (exit z>). Fix it manually or /goal gate remove it, then /goal resume.z (no output))rr} exit_codeattemptroutputrTzgate failed (exit z): $ u✗ Quality gate failed (rz turns, attempt )rrrrrrrrr}r(CONTINUATION_PROMPT_GATE_FAILED_TEMPLATErkrrrr)r6rrpassedr$rprs r7 _check_gateszGoalManager._check_gatess  = KK D&.tn #FIt"+D $(D ! !  MMQ M}}t///++-dmma.?-@ T\\N[!%? ~#NK''( T\\NC&K()* JJL=DDZZTXTaTa ,,T5J]EF$ $YKuT\\NC+E,<,<+=Qu>OP==/4+;+;* >#<= =zz&z55r=c|jt|xsdj}|s td|j ||S)zPark on a process_registry session's OWN trigger: exit OR ``watch_patterns`` match. The right barrier for a long-lived watcher/poller that signals mid-run and may never exit.r,z%session_id must be a non-empty string)r)rr-r2rRr,)r6rrs r7rVzGoalManager.wait_on_sessionDsJ )r*002 DE Ezz&Zz@@r=r)on_delegationsc |jt|}|dkr td|j|t j|zt dt|S)aPark until ``seconds`` from now (backoff/cooldown waits with no process to track). With ``on_delegations`` the wait is FOR those live delegation batches: it also lifts as soon as fewer are live (a batch result came back), so the loop re-judges with the result in hand instead of sleeping out a 20-minute timer (independent review: results arrived with 1,199 s left on the timer and nothing re-judged).rz"seconds must be a positive integer)rr)rr~rRr,rr)r6r[rr0s r7rZzGoalManager.wait_for_secondsMs\ g, a<AB Bzz& g0E^abcehiwex^yzzzr=c|j}|$|j|j |jsy|j |j y)zVClear any active wait barrier (pid / session / time). Returns True if one was cleared.FT)rrrrrr)r6rs r7 stop_waitingzGoalManager.stop_waitingYsG KK 9))1a6J6J6R[\[j[j  r=c|j}|y|jt|j}n|jt |j}nf|j rYt j |j k}|r7|jdkDr(t|j}||jkrd}ny|r|jrw|j dk(rht j |jz tkDr@tjd|j|jxs |jtd}|s|j|S)aTrue iff a barrier is set AND not yet satisfied. A satisfied barrier is cleared here (lazy auto-clear) so the next evaluation resumes normal judging. A pid/session barrier also expires after ``_MAX_BARRIER_WAIT_S``: a watcher or poller that never exits would otherwise park the goal indefinitely (one run sat 3 h 22 min on a poller that outlived the work it was polling).Frrz:goal %s: wait barrier on %s exceeded %ds; resuming judging)rrr/rr)rrrrrr_MAX_BARRIER_WAIT_Srrr3)r6rstilllives r7 is_waitingzGoalManager.is_waitingbs KK 9   +$Q%9%9:E    )q//0E __IIK!//1E11A5/@!222!E Q__C)?DIIKRSRaRaDadwDw KKT)=)=)QAQAQSf hE     r=c ,|jd|j}nS|jd|j}n7tdt|jt j z d}|j xs|}tdddd|d|d |S) Nrrrz s remainingrFwaitingu⏳ Goal parked — waiting on rL)rrrr~rrrr)r6rtgtrs r7_waiting_decisionzGoalManager._waiting_decisions  # # /U5567C  ! ! ---./CC 3 3diik ABCDKPC%%,5$ 6EdehdiiklrksCtuur=rc |jdr-d|jt|d|j}ni|jdr0t |d} d|j ||j }n(|jt |d|| |dd }td d dd |d|d|S#t$rtjd|YywxYw)zJudge said WAIT: set the barrier and park. The counted turn stands (the judge ran) but no continuation fires; the loop resumes once the barrier clears. ``None`` = the barrier is unobservable here, so the caller continues instead.rrrr(rz@goal judge: wait_on_pid %s is not alive on this host; continuingNr[)rr0rrFru'⏳ Goal parked (judge) — waiting on rL) rDrVr-rr~r.rrRrrrZr)r6rrrr;r(s r7_apply_wait_directivez!GoalManager._apply_wait_directives   l +T11#n\6R2S\b1cvvwxC    &nU+,C T\\#f\=LLMN  ! !#nY&?"@`r ! s#I./q1C5$Bijminnpqwpx@yzz   ^`cd  s B>>C C c |jd|jd|jd||d|jd|jd|dS)Nzturn budget exhausted (rru⏸ Goal paused — z turns usedz9. Use /goal resume to keep going, or /goal clear to stop.)rrr)r6rrLrnotes r7 _budget_pausezGoalManager._budget_pausesf##%e&6&6%7q8I KWV\"5#3#3"4Aeoo5FkRVQWXF F  r=)user_initiatedrlrc |j}||jdk7rt|r |jnddddddS|jr|j |S|xj dz c_t j |_|j}|Q|jdr>|j |jk\r%|j|d |jd dd S|St|j||jxsd||jr |j nd| \}}} } } ||_||_| r|j&dznd|_| r|j(dznd|_|dk(r| r|j+| ||} | | S|dk(r|j-d|d|d|dS|dk(r*d|_|j/tdddd|d|S|j(|j&}} | t0k\r4|j-d| dd|d| dt2j5ddzS|t6k\r4|j-d|d d|d!|d"t2j5d#d$zS|j |jk\r|j|d|S|j/tdd%|j9d|d&|j d'|jd(|S))uRun gates + judge and update state. Return a decision dict (``status``, ``should_continue``, ``continuation_prompt``, ``verdict``, ``reason``, ``message``). Both real user prompts and our own continuations increment ``turns_used`` — both consume model budget.NrFinactiverr,rurr#rz" (a quality gate is still failing))rA)ryrlrnrrrr=r)zjudged unachievable: u*🚫 Goal judged unachievable — paused: z8 Re-scope with /goal set, or override with /goal resume.ru✓ Goal achieved: zjudge API unreachable zH turns in a row (check auxiliary.goal_judge provider/key in config.yaml)rJu/⏸ Goal paused — judge API returned errors (z. turns). Check the goal_judge provider/key in deepseekzdeepseek-flash)providermodelz(judge model returned unparseable output z turns in a rowu%⏸ Goal paused — the judge model (zZ turns) isn't returning the required JSON verdict. Route the judge to a stricter model in openrouterzgoogle/gemini-3-flash-previewTu↻ Continuing toward goal (rr)rrrr8r<rrrr)rDrrBrrryrrnrrrrr?rr*DEFAULT_MAX_CONSECUTIVE_TRANSPORT_FAILURES_JUDGE_CONFIG_HINTrk&DEFAULT_MAX_CONSECUTIVE_PARSE_FAILURESnext_continuation_prompt)r6rrCrlrr gate_decisionrLrrrtransport_failedparkedn_txn_parses r7evaluate_after_turnzGoalManager.evaluate_after_turnsQ  =ELLH4UU\\eT:Wgikl l ?? ))%0 0 A!YY[))+  $  !238H8HEOO8[))% @Q@QRZ\^@_gK)LL JT JJ 0F$]q','9'9';U^^ZlK G~7G%"T`5+K+Ka+Oef([ku/S/SVW/Wqr, f //[m/nF! i '''x0)V^>^g = =''(.vwFA$Guv$++ZGW+XY  < <'':7)?SU_ag7yA::$++\Ih+ij    u .%%eZ@ @  dD99;Z*5+;+;*> ZZ446Nzz$2#326LQZZ6X5Y!Z=DD!&&aoDp p ::=DD!&&abaxaxazD{ {+222??r=c|jy|jjr$|jjjSdS)z>Public helper for the /goal show + /goal draft slash commands.ru^(no completion contract — set one with /goal draft or inline field: value lines))rrrnrOr;s r7render_contractzGoalManager.render_contract sC ;; %6:kk6N6N6Pt{{##002 n l nr=)rr-rr~)rQOptional[GoalState]rPrT)rQr)rr-rQr) rr-rLr-rr-r}r-rQr)rr-rrrnOptional[GoalContract]rQr)rnr+rQrZ)z user-paused)rr-rQrZ)rrRrQrZr)rdr-rQr-)rr-r r~)rr-rQr~)r r~rQr-rQr~)r}r-rrrrrQr|)rQrS)rr-rQr)r,)r(r~rr-rQr)rr-rr-rQr)r[r~rr-r0r~rQr)rrrQr)rrrr-rr~rQrS) rrrLr-rr-rAr-rQr) rr-rCrRrlOptional[List[Dict[str, Any]]]rr~rQr)rQr).rUrVrWrXrrpropertyrrrrrrrrrrrrrrrrrr rrrrrrrr!r)r,r.rVrZr3r8r<r?rBrSrMrYrAr=r7rr)sZEVAJVF68   J<@dh .28-nJNlp =* .d 6A {XY {@vop{, =A?C"#T  T 59T <T  T   T l @nr=ru[Continuing toward this kanban task — judge says it is not done yet] Reason: {reason} Take the next concrete step toward completing the task. When the work is genuinely finished, call kanban_complete with a summary. If it is a code change that needs same-card review before counting as done, call kanban_request_review with a summary instead. If you are blocked and need human input, call kanban_block with a reason. Do not stop without calling one of them.a^[The work looks complete, but the task is still open] Reason: {reason} If the task is genuinely done, call kanban_complete now with a short summary of what you did. If it is a code change awaiting same-card review, call kanban_request_review with that summary instead. If something still blocks completion, call kanban_block with the reason instead.)completed_by_workerzworker completed the taskz8task {task_id} completed by worker after {turns} turn(s))blocked_by_workerzworker blocked the taskz6task {task_id} blocked by worker after {turns} turn(s))review_requested_by_workerzworker requested reviewzDtask {task_id} handed off for review by worker after {turns} turn(s))changes_requested_by_reviewerzreviewer requested changeszBreviewer returned task {task_id} for changes after {turns} turn(s))rr)reviewchanges_requested)rfirst_responselogc d3fd d4fd }d5fd } t|xst}|dkrt}|xsd} dd} |} tj | }|+|\}}}d |j |z| ||S| dvrd|d| d| d d| Sddlm}m}m }|rd n |d|} t|| \}}}}}| || |dk(rd}dd|d|dt|d|dk(r#d|d|d || d!d"|S|d#k(rF| r!d|d$|d%|d&| d'd(Stj t|d)*}d} n tj t|d)*}|k\r6d|d+d|d,|d-d|d.t|d/| d'd0S ||xsd} dz #t$r} d| d | d d cYd } ~ Sd } ~ wwxYw#| ||wwxYw#t$r5} d1| d | d d2t| jcYd } ~ Sd } ~ wwxYw)6aDrive a kanban worker through a Ralph-style goal loop. Each iteration: stop if the worker already terminated the task (``kanban_complete`` / ``kanban_block`` / review hand-off); otherwise judge the latest response against ``goal_text`` (the card's title + body) and feed a continuation or finalize nudge. A WAIT verdict is treated as CONTINUE (workers finish via kanban tools, not by parking). c< |yy#t$rYywxYwr0r)rrfs r7_logz"run_kanban_goal_loop.._logNs- ? C   s  c\ |y#t$r}d|dYd}~yd}~wwxYw)Nz#kanban goal loop: block_fn failed (rri)r}rrjblock_fns r7_blockz$run_kanban_goal_loop.._blockUs5 ? W  ? 6se1= > > ?s + &+c||dS)N)rrrrA)rrrs r7_resultz%run_kanban_goal_loop.._result[s"*OOr=rur,FTz'kanban goal loop: status check failed (z ); stoppingstoppedzstatus check failedNzkanban goal loop: )rr)rreadyzkanban goal loop: task z status=z ; stoppingzstatus=r)get_affinity_scopereset_affinity_scopeset_affinity_scopezkanban:rrJzkanban goal loop: turn rz verdict=z reason=rcr)z judged unachievable; blockingz-Goal-mode judge ruled the goal unachievable: blocked_unachievablezjudge verdict blocked: rz0 judged done but worker won't finalize; blockingzfGoal-mode worker's output looked complete but it never called kanban_complete after a finalize nudge (z).blocked_budgetzjudged done, never finalizedrrz exhausted z turns; blockingz,Goal-mode worker exhausted its turn budget (z3) without completing the task. Last judge verdict: rzturn budget exhaustedz#kanban goal loop: run_turn failed (zrun_turn error: )rr-rQr)r}r-rQr)rr-rr-rQr)r~rr_KANBAN_TERMINAL_STATUSESrDrkagent.portal_tagsrrrsrtrr"KANBAN_GOAL_FINALIZE_TEMPLATE!KANBAN_GOAL_CONTINUATION_TEMPLATErrU)r goal_textrun_turntask_status_fnrlrrerfrmrornudged_to_finalizerrterminalrrlog_fmtrrrsrtaffinity_tokenrL _parse_failed_wait_transport_failedrrjrs ` ` @@r7run_kanban_goal_loopr;sK&? PI2!23I1}% "(bMJ  =#%F -008  '/ $GVW %wj(YY Z7F+ + - - *7)8F:ZP Q9x&89 9 cb!3!5;MPWX_W`Na;b 5GQR[]jGk DGV]E3D)$^4 f  G &zl!I;iyPXYbciknYoXp qr i  *7)3QR S B6(K L15LVH3UV V f !.wi7ghiFFLXRQ/1OPP2996SVAW9XF!% 6==YvWZE[=\F  " *7);zl!I;Vfg h @  +-DE E O$V,2M a G  = :3%{K L9&;< < =*)$^4*P O 6se;G H9(8c9K9K8L&MN N OsHG- H H(- H6H HH H%( I&1*I!I&!I&)rr+r|rrorrrWrVrUrrrrrzryrrrrrrr)rdr-rQzTuple[str, GoalContract])ryrrQr-)rr|rrrQzTuple[bool, int, str])rr-rQr-)rr-rzthreading.EventrQr)rQz Optional[Any])rr-rrP)r r-r r-rr-rQr)rr-rQrZ)rr-rrrQr)rr-rQr)rr-rr-rr-rQrR)rdr-r!r~rQr-)r(r~rQrR)rr-rQrR)rlr-r\)rQr)rr-rQrS)rr-rQz/Tuple[str, str, bool, Optional[Dict[str, Any]]])rlr]rQr-)rr-rr-rOptional[float]rQr-)rr-rr-rrryzOptional[List[str]]rlr]rnr[rr~rQz5Tuple[str, str, bool, Optional[Dict[str, Any]], bool])rrrQr~)rr-rr rQr-)rr rQr )rrrQr r0)rrrrrQzList[Dict[str, Any]])rr-rrrQr[) rrRrrrLr-rr-r}r-rQr) rr-r{r-rr~rer-rQr)mrX __future__rrrloggingosrerrr dataclassesrrrrrpathlibr typingr r r r rhermes_cli._subprocess_compatr getLoggerrUrrr=r:rrLrJrrr5rrWrUrVr'rrrjrrrrr:rMr`r+rorzr|rrrrrYLockrrrrrrrrrr rrrrr"r)r/compileDOTALLrCr7r;r>rHr`rsrrrrrrrrrrrrrKrrzryrwr__all__rAr=r7rs#   00'33@   8 $   $*+&./* #P +++ D)"9,~L!0 B<)(^)4/4Y.-@  y  ) -3Y @KY N $,n >K^  !( = #/ @J=    /  ,  !+L  ;B< l;;"K  GG G262c      <6:O, L!L! L!b  >#Y^^%5727 !  "=@, @* >!XZ>L ( "**Z3 LH4./\dU< ( $$(;?'+A@ A@A@ A@ " A@ 9 A@%A@A@;A@H"r  ae,BF5DF % ininb"D }yP_  ' n nnnnnb r=