i UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZmZmZhdZhdZd Zd Zd Zd Zd ZdZddZddZe GddZe GddZe GddZe GddZ dZ!e"Z#de$d<ddd!Z%ddd"Z&dd%Z'ej(dd&Z)dd(Z*dd)Z+dddd*dddd+d,dddd- ddAZ,ddCZ-ddFZ.dddd,ddGddLZ/ddNZ0ddQZ1ddRZ2ddSZ3ddTZ4ddUZ5ddWZ6ddYZ7dd[Z8dd]Z9 ddd^ddcZ:ddddddddiZ;ddjZeddnddqZ?eddnddrZ@ddsZAddddtddvZBddwddyZCddzZDdd{ZEdd}ZFddZGdZHdZIe GddZJddZKddddZLddddZMddZNddZOeHdddZPddZQddZRded,deHdddZSddZTddZUddeHdddddZVddZWddZXddZYdddddZZ dddZ[ddddZ\dddddZ]ddddZ^ddddZ_ddddZ`ddZaddddZbddZcddZdddœddńZeddDŽZfddȄZgddɄZhdS(aySQLite-backed Kanban board for multi-profile collaboration. The board lives at ``$HERMES_HOME/kanban.db`` (profile-agnostic on purpose: multiple profiles on the same machine all see the same board, which IS the coordination primitive). Schema is intentionally small: tasks, task_links, task_comments, task_events. The ``workspace_kind`` field decouples coordination from git worktrees so that research / ops / digital-twin workloads work alongside coding workloads. See ``docs/hermes-kanban-v1-spec.pdf`` for the full design specification. Concurrency strategy: WAL mode + ``BEGIN IMMEDIATE`` for write transactions + compare-and-swap (CAS) updates on ``tasks.status`` and ``tasks.claim_lock``. SQLite serializes writers via its WAL lock, so at most one claimer can win any given task. Losers observe zero affected rows and move on -- no retry loops, no distributed-lock machinery. ) annotationsN) dataclassfield)Path)AnyIterableOptional>donetodoreadytriageblockedrunningarchived>dirscratchworktreei ii ireturnrc(ddlm}|dz S)z?Return the path to ``kanban.db`` inside the active HERMES_HOME.rget_hermes_homez kanban.dbhermes_constantsrrs 9/home/ubuntu/.hermes/hermes-agent/hermes_cli/kanban_db.pykanban_db_pathr@s'000000 ?  { **c.ddlm}|dz dz S)zDReturn the directory under which ``scratch`` workspaces are created.rrkanban workspacesrrs rworkspaces_rootr"Fs,000000 ?  x ', 66rc\eZdZUdZded<ded<ded<ded<ded<d ed <ded <d ed <d ed<d ed<ded<ded<ded<d ed<ded<dZded<dZded<dZd ed<dZd ed<dZ ded<dZ d ed<dZ d ed<dZ d ed<dZ ded<dZded <dZd!ed"<ed(d'ZdS))Taskz1In-memory view of a row from the ``tasks`` table.stridtitle Optional[str]bodyassigneestatusintpriority created_by created_at Optional[int] started_at completed_atworkspace_kindworkspace_path claim_lock claim_expirestenantNresultidempotency_keyrspawn_failures worker_pidlast_spawn_errormax_runtime_secondslast_heartbeat_atcurrent_run_idworkflow_template_idcurrent_step_keyzOptional[list]skillsrow sqlite3.Rowr'Task'cVt|}d}d|vrW|drO tj|d}t |t r d|D}n#t $rd}YnwxYw|did|dd|dd|dd|dd|dd|dd |d d |d d |d d |d d |d d|dd|dd|ddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dndd|S)NrBc0g|]}|t|S)r%).0ss r z!Task.from_row..|s##@#@#@qa#@CFF#@#@#@rr&r'r)r*r+r-r.r/r1r2r3r4r5r6r7r8r9r:rr;r<r=r>r?r@rArH)setkeysjsonloads isinstancelist Exception)clsrCrM skills_valueparseds rfrom_rowz Task.from_rowss 388::'+ t  H  $CM22fd++A#@#@F#@#@#@L $ $ $#  $s% % % 4yy% g,,% V% __ % x== % __ % <((% <((% <((% ^,,% /00% /00% <((% o..% %-$4$43x==$% %-$4$43x==$!% "7H46O6OC 122UY#% $5E4L4L3/00RS%% &-9D,@,@s<((d'% (9Kd8R8RS!344X\)% ,/Dt.K.K)**QU-% 2-@4,G,G'((T3% 8*:T)A)A$%%t9% >0F/M/M*++SW?% D,>+E+E&''4E% H r?r@rArB classmethodrVrHrrr$r$Ps;; GGGJJJKKKMMMOOO!!!!     F    %)O))))N $J$$$$&*****)-----'+++++$(N((((*.....&***** "F!!!!0 0 0 [0 0 0 rr$ceZdZUdZded<ded<ded<ded<ded <ded <d ed <d ed <d ed<d ed<ded<d ed<ded<ded<ded<ded<eddZdS)RunurIn-memory view of a ``task_runs`` row. A run is one attempt to execute a task — created on claim, closed on complete/block/crash/timeout/spawn_failure/reclaim. Multiple runs per task when retries happen. Carries the claim machinery, PID, heartbeat, and the structured handoff summary that downstream workers read via ``build_worker_context``. r,r&r%task_idr(profilestep_keyr+r5r0r6r;r=r>r1ended_atoutcomesummaryOptional[dict]metadataerrorrCrDr'Run'c  |drtj|dnd}n#t$rd}YnwxYw|didt|dd|dd|dd|dd|dd|dd|dd |d d |d d |d d t|d d |d t|d ndd|dd|dd|d|dS)Nrfr&r_r`rar+r5r6r;r=r>r1rbrcrdrgrH)rNrOrRr,)rSrCmetas rrVz Run.from_rows 25j/K4:c*o...tDD   DDD s   3t9~~~  NN  NN __  x==  <((  o.. <(( !$$9 : : ""566 3|,--- /2*o.Ic#j/***t  NN  NN T g,,!  s $' 66N)rCrDrrh)rWrXrYrZr[r\rVrHrrr^r^s GGGLLLKKK    &&&&$$$$OOO   [   rr^cBeZdZUded<ded<ded<ded<ded<dS) Commentr,r&r%r_authorr)r/N)rWrXrYr[rHrrrlrls= GGGLLLKKK IIIOOOOOrrlcPeZdZUded<ded<ded<ded<ded<d Zd ed <d S) Eventr,r&r%r_kindrepayloadr/Nr0run_id)rWrXrYr[rrrHrrrorosS GGGLLL IIIOOO F      rroaY CREATE TABLE IF NOT EXISTS tasks ( id TEXT PRIMARY KEY, title TEXT NOT NULL, body TEXT, assignee TEXT, status TEXT NOT NULL, priority INTEGER DEFAULT 0, created_by TEXT, created_at INTEGER NOT NULL, started_at INTEGER, completed_at INTEGER, workspace_kind TEXT NOT NULL DEFAULT 'scratch', workspace_path TEXT, claim_lock TEXT, claim_expires INTEGER, tenant TEXT, result TEXT, idempotency_key TEXT, spawn_failures INTEGER NOT NULL DEFAULT 0, worker_pid INTEGER, last_spawn_error TEXT, max_runtime_seconds INTEGER, last_heartbeat_at INTEGER, -- Pointer into task_runs for the currently-active run (NULL if no -- run is in-flight). Denormalised for cheap reads. current_run_id INTEGER, -- Forward-compat for v2 workflow routing. In v1 the kernel writes -- these when the task is opted into a template but otherwise ignores -- them; the dispatcher doesn't consult them for routing yet. workflow_template_id TEXT, current_step_key TEXT, -- Force-loaded skills for the worker on this task, stored as JSON. -- Appended to the dispatcher's built-in `--skills kanban-worker`. -- NULL or empty array = no extras. skills TEXT ); CREATE TABLE IF NOT EXISTS task_links ( parent_id TEXT NOT NULL, child_id TEXT NOT NULL, PRIMARY KEY (parent_id, child_id) ); CREATE TABLE IF NOT EXISTS task_comments ( id INTEGER PRIMARY KEY AUTOINCREMENT, task_id TEXT NOT NULL, author TEXT NOT NULL, body TEXT NOT NULL, created_at INTEGER NOT NULL ); CREATE TABLE IF NOT EXISTS task_events ( id INTEGER PRIMARY KEY AUTOINCREMENT, task_id TEXT NOT NULL, run_id INTEGER, kind TEXT NOT NULL, payload TEXT, created_at INTEGER NOT NULL ); -- Historical attempt record. Each time the dispatcher claims a task, a -- new row is created here; claim state, PID, heartbeat, runtime cap, -- and structured summary all live on the run, not the task. Multiple -- rows per task id when the task was retried after crash/timeout/block. -- v2 of the kanban schema will use ``step_key`` to drive per-stage -- workflow routing; in v1 the column is nullable and unused (kernel -- ignores it). CREATE TABLE IF NOT EXISTS task_runs ( id INTEGER PRIMARY KEY AUTOINCREMENT, task_id TEXT NOT NULL, profile TEXT, step_key TEXT, status TEXT NOT NULL, -- status: running | done | blocked | crashed | timed_out | failed | released claim_lock TEXT, claim_expires INTEGER, worker_pid INTEGER, max_runtime_seconds INTEGER, last_heartbeat_at INTEGER, started_at INTEGER NOT NULL, ended_at INTEGER, outcome TEXT, -- outcome: completed | blocked | crashed | timed_out | spawn_failed | -- gave_up | reclaimed | (null while still running) summary TEXT, metadata TEXT, error TEXT ); -- Subscription from a gateway source (platform + chat + thread) to a -- task. The gateway's kanban-notifier watcher tails task_events and -- pushes ``completed`` / ``blocked`` / ``spawn_auto_blocked`` events to -- the original requester so human-in-the-loop workflows close the loop. CREATE TABLE IF NOT EXISTS kanban_notify_subs ( task_id TEXT NOT NULL, platform TEXT NOT NULL, chat_id TEXT NOT NULL, thread_id TEXT NOT NULL DEFAULT '', user_id TEXT, created_at INTEGER NOT NULL, last_event_id INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (task_id, platform, chat_id, thread_id) ); CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status ON tasks(assignee, status); CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status); CREATE INDEX IF NOT EXISTS idx_tasks_tenant ON tasks(tenant); CREATE INDEX IF NOT EXISTS idx_tasks_idempotency ON tasks(idempotency_key); CREATE INDEX IF NOT EXISTS idx_links_child ON task_links(child_id); CREATE INDEX IF NOT EXISTS idx_links_parent ON task_links(parent_id); CREATE INDEX IF NOT EXISTS idx_comments_task ON task_comments(task_id, created_at); CREATE INDEX IF NOT EXISTS idx_events_task ON task_events(task_id, created_at); CREATE INDEX IF NOT EXISTS idx_events_run ON task_events(run_id, id); CREATE INDEX IF NOT EXISTS idx_runs_task ON task_runs(task_id, started_at); CREATE INDEX IF NOT EXISTS idx_runs_status ON task_runs(status); CREATE INDEX IF NOT EXISTS idx_notify_task ON kanban_notify_subs(task_id); zset[str]_INITIALIZED_PATHSdb_pathOptional[Path]sqlite3.Connectionc$|p t}|jddt|}|t v}t jt|dd}t j|_ | d| d| d|rC| tt|t ||S) aOpen (and initialize if needed) the kanban DB. WAL mode is enabled on every connection; it's a no-op after the first time but keeps the code robust if the DB file is ever re-created. The first connection to a given path auto-runs :func:`init_db` so fresh installs and test harnesses that construct `connect()` directly don't have to remember a separate init step. Subsequent connections skip the schema check via a module-level path cache. Tparentsexist_okNr)isolation_leveltimeoutzPRAGMA journal_mode=WALzPRAGMA synchronous=NORMALzPRAGMA foreign_keys=ON)rparentmkdirr%resolverssqlite3connectRow row_factoryexecute executescript SCHEMA_SQL_migrate_add_optional_columnsadd)rtpathresolved needs_initconns rrrss  &n&&DKdT2224<<>>""H!33J ?3t99dB G G GD{DLL*+++LL,---LL)***) :&&&%d+++x((( KrcH|p t}|jddt|}t |tjt|5 dddn #1swxYwY|S)uCreate the schema if it doesn't exist; return the path used. Kept as a public entry point so CLI ``hermes kanban init`` and the daemon have something explicit to call. Unlike :func:`connect`'s first-time auto-init (which caches by path), ``init_db`` always re-runs the migration pass. Callers that know the on-disk schema may have drifted — tests that write legacy event kinds directly, external tools that upgrade an old DB file — can call this to force re-migration. TrxN) rr}r~r%rrsdiscard contextlibclosingr)rtrrs rinit_dbrs  &n&&DKdT2224<<>>""Hx(((  GDMM * *                  Ks BBBrNonec Vd|dD}d|vr|dd|vr|dd|vr*|d|d d |vr|d d |vr|d d|vr|dd|vr|dd|vr|dd|vr|dd|vr|dd|vr|dd|vr|dd|dD}d|vr*|d|d |d!d"u}|r-t|5|d#}|D]}|d$pt t j}|d%|d&|d'|d(|d)|d |d|d|f}|d*|j|d&f}|jd+kr;|d,t t j|jf d"d"d"n #1swxYwYd-} | D]\} } |d.| | fd"S)/zAdd columns that were introduced after v1 release to legacy DBs. Called by ``init_db`` so opening an old DB is always safe. ch|] }|d SnamerHrIrCs r z0_migrate_add_optional_columns..s L L LCCK L L LrzPRAGMA table_info(tasks)r7z(ALTER TABLE tasks ADD COLUMN tenant TEXTr8z(ALTER TABLE tasks ADD COLUMN result TEXTr9z1ALTER TABLE tasks ADD COLUMN idempotency_key TEXTzJCREATE INDEX IF NOT EXISTS idx_tasks_idempotency ON tasks(idempotency_key)r:zFALTER TABLE tasks ADD COLUMN spawn_failures INTEGER NOT NULL DEFAULT 0r;z/ALTER TABLE tasks ADD COLUMN worker_pid INTEGERr<z2ALTER TABLE tasks ADD COLUMN last_spawn_error TEXTr=z8ALTER TABLE tasks ADD COLUMN max_runtime_seconds INTEGERr>z6ALTER TABLE tasks ADD COLUMN last_heartbeat_at INTEGERr?z3ALTER TABLE tasks ADD COLUMN current_run_id INTEGERr@z6ALTER TABLE tasks ADD COLUMN workflow_template_id TEXTrAz2ALTER TABLE tasks ADD COLUMN current_step_key TEXTrBz(ALTER TABLE tasks ADD COLUMN skills TEXTch|] }|d SrrHrs rrz0_migrate_add_optional_columns..sUUUss6{UUUrzPRAGMA table_info(task_events)rrz1ALTER TABLE task_events ADD COLUMN run_id INTEGERzDCREATE INDEX IF NOT EXISTS idx_events_run ON task_events(run_id, id)zFSELECT name FROM sqlite_master WHERE type='table' AND name='task_runs'NzSELECT id, assignee, claim_lock, claim_expires, worker_pid, max_runtime_seconds, last_heartbeat_at, started_at FROM tasks WHERE status = 'running' AND current_run_id IS NULLr1aV INSERT INTO task_runs ( task_id, profile, status, claim_lock, claim_expires, worker_pid, max_runtime_seconds, last_heartbeat_at, started_at ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?) r&r*r5r6zKUPDATE tasks SET current_run_id = ? WHERE id = ? AND current_run_id IS NULLz_UPDATE task_runs SET status = 'reclaimed', outcome = 'reclaimed', ended_at = ? WHERE id = ?))r promoted)r- reprioritized)spawn_auto_blockedgave_upz.UPDATE task_events SET kind = ? WHERE kind = ?)rfetchone write_txnfetchallr,time lastrowidrowcount) rcolsev_cols runs_existinflightrCstartedcurupd_EVENT_RENAMESoldnews rrrs  M L4<<0J#K#K L L LDt ?@@@t ?@@@$$ HIII  (   t## T   4 FGGG%% IJJJD(( OPPP$&& MNNNt## JKKKT)) MNNN%% IJJJt ?@@@VUdll3S&T&TUUUGw HIII  )   PhjjJ* t__) ) ||F hjj   " " l+?s49;;/?/?llD 3z?C 4EO,c,.?12C8K4L *ll>]CI. <1$$LL'TY[[))3=9 ;" ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ^N #  S < #J      s)DK<<LLc#K|d |V|ddS#t$r|dwxYw)aContext manager for an IMMEDIATE write transaction. Use for any multi-statement write (creating a task + link, claiming a task + recording an event, etc.). A claim CAS inside this context is atomic -- at most one concurrent writer can succeed. zBEGIN IMMEDIATECOMMITROLLBACKN)rrR)rs rrr su LL"### X  Z    s 4!Ar%c0dtjdzS)aGenerate a short, URL-safe task id. 4 hex bytes = ~4.3B possibilities. At 10k tasks the collision probability is ~1.2e-5; at 100k it's ~1.2e-3. Previously we used 2 hex bytes (65k possibilities) which hit the birthday paradox hard: ~5% collision probability at 1k tasks, ~50% at 10k. Callers that care about idempotency should pass ``idempotency_key`` to :func:`create_task` rather than rely on id uniqueness. t_)secrets token_hexrHrr _new_task_idr6s '#A&& &&rcddl} |pd}n#t$rd}YnwxYw|dtjS)z:Return a ``host:pid`` string that identifies this claimer.rNunknown:)socket gethostnamerRosgetpid)rhosts r _claimer_idrCsfMMM!!##0y  " "RY[[ " ""s  ,,rrHF) r)r*r.r3r4r7r-ryr r9r=rBr'r)r(r*r.r3r4r7r-r,ry Iterable[str]r boolr9r=r0rBOptional[Iterable[str]]c |r|std|tvr'tdttd|t d| D} d}| g}t }| D]o}|st |}|s)d|vrtd|d||vrE||||p|}| r3| d | f }|r|d Sttj }td D]}t} t|5| rd }nd }| rt!|| }|r%tdd|| dddt%| zzdz| }t)d|Drd}| r9| r7t!|| }|r%tdd|| d|||||||||||| | rt| nd|t+j|ndf| D]}| d||ft/||d||t1| ||rt1|ndddddn #1swxYwY|cS#t2j$r |dkrYwxYwt7d)uCreate a new task and optionally link it under parent tasks. Returns the new task id. Status is ``ready`` when there are no parents (or all parents already ``done``), otherwise ``todo``. If ``triage=True``, status is forced to ``triage`` regardless of parents — a specifier/triager is expected to promote the task to ``todo`` once the spec is fleshed out. If ``idempotency_key`` is provided and a non-archived task with the same key already exists, returns the existing task's id instead of creating a duplicate. Useful for retried webhooks / automation that should not double-write. ``max_runtime_seconds`` caps how long a worker may run before the dispatcher SIGTERMs (then SIGKILLs after a grace window) and re-queues the task. ``None`` means no cap (default). ``skills`` is an optional list of skill names to force-load into the worker when dispatched. Stored as JSON; the dispatcher passes each name to ``hermes --skills ...`` alongside the built-in ``kanban-worker``. Use this to pin a task to a specialist skill (e.g. ``skills=["translation"]`` so the worker loads the translation skill regardless of the profile's default config). ztitle is requiredzworkspace_kind must be one of z, got c3K|]}||V dSNrHrIps r zcreate_task..s',,!!,A,,,,,,rN,z!skill name cannot contain comma: zA (pass a list of separate names instead of a comma-joined string)zhSELECT id FROM tasks WHERE idempotency_key = ? AND status != 'archived' ORDER BY created_at DESC LIMIT 1r&r r zunknown parent task(s): , z&SELECT status FROM tasks WHERE id IN (?)c3.K|]}|ddkVdSr+r NrHrIrs rrzcreate_task..s+CCq{f4CCCCCCrr ag INSERT INTO tasks ( id, title, body, assignee, status, priority, created_by, created_at, workspace_kind, workspace_path, tenant, idempotency_key, max_runtime_seconds, skills ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) DINSERT OR IGNORE INTO task_links (parent_id, child_id) VALUES (?, ?)created)r*r+ryr7rBr unreachable)strip ValueErrorVALID_WORKSPACE_KINDSsortedtuplerLr%rappendrrr,rrangerr_find_missing_parentsjoinlenranyrNdumps _append_eventrQrIntegrityError RuntimeError)rr'r)r*r.r3r4r7r-ryr r9r=rB skills_listcleanedseenrJrrCnowattemptr_initial_statusmissingrowspids r create_taskrQsR . .,---222 &V4I-J-J & &! & &   ,,w,,,,,G(,K  ! !A q66<<>>D d{{ XXXXt|| HHTNNN NN4  ll /    (**  t9  dikk  C88LL..J 4C C 4%-NN%,N 4"7g"F"F"^",-\ RYHZHZ-\-\"]"]]#|| "%((3W+=">">?ADE#  #(**  CCdCCCCC4-3NZgZ3D'BBGZ()XDIIgDVDV)X)XYYY    & "&&'4GQ/000T3>3J ;///PT2#CLL^g$,"0#'=="(7B"L${"3"3"3    qC C C C C C C C C C C C C C C HNNN%   !|| H   } % %%s7-L/.s%%%1qw%%%rcg|]}|v| SrHrH)rIrpresents rrKz)_find_missing_parents.. s# 3 3 3!!7"2"2A"2"2"2r)rQrrrr)rry placeholdersrrs @rrrs7mmG  88C#g,,.//L <<<\<<<  hjj &%%%%G 3 3 3 3w 3 3 33rr_Optional[Task]c|d|f}|rt|ndS)Nz SELECT * FROM tasks WHERE id = ?)rrr$rVrr_rCs rget_taskr s@ ,,9G: F F O O Q QC!$ .4==   $.r)r*r+r7include_archivedlimitr+rr list[Task]cd}g}||dz }|||G|tvr$tdtt|dz }||||dz }|||s |dkr|dz }|dz }|r|d t |z }|||}d |DS) NzSELECT * FROM tasks WHERE 1=1z AND assignee = ?zstatus must be one of z AND status = ?z AND tenant = ?rz AND status != 'archived'z' ORDER BY priority DESC, created_at ASCz LIMIT cBg|]}t|SrH)r$rVrs rrKzlist_tasks..-s$ + + +DMM!   + + +r)rVALID_STATUSESrrr,rr) rr*r+r7rrqueryparamsrs r list_tasksrs ,EF $$ h   ' 'Nf^6L6LNNOO O "" f  "" f -* 4 4 ,, 66E ( '3u::''' <<v & & / / 1 1D + +d + + ++rr`cpt|5|d|f}|s ddddS|d|ddkrtd|d|d ||ft ||d d |i dddd S#1swxYwYdS) zAssign or reassign a task. Returns True on success. Refuses to reassign a task that's currently running (claim_lock set). Reassign after the current run completes if needed. z1SELECT status, claim_lock FROM tasks WHERE id = ?NFr5r+rzcannot reassign zS: currently running (claimed). Wait for completion or reclaim the stale lock first.z*UPDATE tasks SET assignee = ? WHERE id = ?assignedr*T)rrrrr)rr_r`rCs r assign_taskr0sN 4  ll ?'  (**           |  (S]i-G-GG7GGG  AGWCUVVVdGZ*g1FGGG                  s-B+ AB++B/2B/ parent_idchild_idc 2||krtdt|5t|||g}|r%tdd|t |||rtd|d|d|d||f|d|fd }|d kr|d |ft||d ||d ddddS#1swxYwYdS)Nza task cannot depend on itselfzunknown task(s): rzlinking z -> z would create a cyclerz%SELECT status FROM tasks WHERE id = ?r+r zBUPDATE tasks SET status = 'todo' WHERE id = ? AND status = 'ready'linkedr}child)rrrr _would_cyclerrr)rrrr parent_statuss r link_tasksr JsH9::: 4  'y(.CDD  GE71C1CEEFF F i 2 2 I9II(III  R  !    3i\  (**X  F " " LLT      (H 8 4 4   +                  sCD  DDc,t}|g}|r|}||krdS||vr#|||d|f}|d|D|dS)zReturn True if adding parent->child creates a cycle. A cycle exists iff ``parent_id`` is already a descendant of ``child_id`` via existing parent->child links. We walk downward from ``child_id`` and check whether we reach ``parent_id``. Tz3SELECT child_id FROM task_links WHERE parent_id = ?c3&K|] }|dV dS)rNrHrs rrz_would_cycle..{s&11qQz]111111rF)rLpoprrrextend)rrrrstacknoders rr r hs 55D JE  2yy{{ 9  4 4<<  || AD7  (**   11D111111  2 5rc t|5|d||f}|jrt||d||d|jdkcdddS#1swxYwYdS)Nz;DELETE FROM task_links WHERE parent_id = ? AND child_id = ?unlinkedr r)rrrr)rrrrs r unlink_tasksrs 4   ll I  !   <  h $x88   |a                   s?AA #A cl|d|f}d|DS)NFSELECT parent_id FROM task_links WHERE child_id = ? ORDER BY parent_idcg|] }|d SrrHrs rrKzparent_ids..s ) ) )qAkN ) ) )rrrrr_rs r parent_idsrsA <<P    hjj  * )D ) ) ))rcl|d|f}d|DS)NzESELECT child_id FROM task_links WHERE parent_id = ? ORDER BY child_idcg|] }|d S)rrHrs rrKzchild_ids..s ( ( (aAjM ( ( (rrrs r child_idsr sA <<O    hjj  ) (4 ( ( ((rlist[tuple[str, Optional[str]]]cl|d|f}d|DS)zDReturn ``(parent_id, result)`` for every done parent of ``task_id``.z SELECT t.id AS id, t.result AS result FROM tasks t JOIN task_links l ON l.parent_id = t.id WHERE l.child_id = ? AND t.status = 'done' ORDER BY t.completed_at ASC c.g|]}|d|dfS)r&r8rHrs rrKz"parent_results..s% 1 1 1qQtWak " 1 1 1rrrs rparent_resultsr$sE <<     hjj  2 1D 1 1 11rrmc |r|std|r|stdttj}t |5|d|fstd||d||||f}t||d|t|dt|j pdcdddS#1swxYwYdS) Nzcomment body is requiredzcomment author is requiredz SELECT 1 FROM tasks WHERE id = ? unknown task zQINSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?) commented)rmrr) rrr,rrrrrrr)rr_rmr)rrs r add_commentr(s} 5tzz||53444 775666 dikk  C 4 ' '|| .   (** 86W6677 7ll " fllnndjjllC 8   dG[VCPTII2V2VWWW3=%A&& ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 's:B1D88D<?D< list[Comment]cl|d|f}d|DS)NzESELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at ASCc rg|]4}t|d|d|d|d|d5S)r&r_rmr)r/)r&r_rmr)r/)rlrs rrKz!list_comments..s\     wiLX;6       rrrs r list_commentsr,sN <<O    hjj       r list[Event]c|d|f}g}|D]} |drtj|dnd}n#t$rd}YnwxYw|t |d|d|d||dd|vr|dt|dnd|S) NzKSELECT * FROM task_events WHERE task_id = ? ORDER BY created_at ASC, id ASCrqr&r_rpr/rrr&r_rprqr/rr) rrrNrOrRrrorMr,)rr_routrrqs r list_eventsr1s <<U    hjj  C    23I,Hdj9...DGG   GGG  T7) vY\?,4,@,@Qx[E\AhK(((bf      Js$A A%$A%rrrprqrerrcttj}|rtj|dnd}|d|||||fdS)a2Record an event row. Called from within an already-open txn. ``run_id`` is optional: pass the current run id so UIs can group events by attempt. For events that aren't scoped to a single run (task created/edited/archived, dependency promotion) leave it None and the row carries NULL. F ensure_asciiNz[INSERT INTO task_events (task_id, run_id, kind, payload, created_at) VALUES (?, ?, ?, ?, ?))r,rrNrr)rr_rprqrrrpls rrrsh dikk  C4; EG% 0 0 0 0BLL ! &$C(r)rdrgrfr+rcrdrgrfc vttj}|d|f}|r|dsdSt|d} |d|p|||||rt j|dnd|| f|d|f| S)aClose the currently-active run for ``task_id`` and clear the pointer. ``outcome`` is the semantic result (completed / blocked / crashed / timed_out / spawn_failed / gave_up / reclaimed). ``status`` is the run-row status (usually just ``outcome``, but callers can pass it explicitly). Returns the closed run_id or ``None`` if no active run existed (e.g. a CLI user calling ``hermes kanban complete`` on a task that was never claimed). -SELECT current_run_id FROM tasks WHERE id = ?r?Na UPDATE task_runs SET status = ?, outcome = ?, summary = ?, error = ?, metadata = ?, ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND ended_at IS NULL Fr4z3UPDATE tasks SET current_run_id = NULL WHERE id = ?)r,rrrrNr) rr_rcrdrgrfr+rrCrrs r_end_runr9s& dikk  C ,,7'  hjj c*+t %& ' 'FLL   g   8@ JDJxe 4 4 4 4d   2 LL=z Mrc|d|f}|r|drt|dndS)Nr8r?)rrr,rs r_current_run_idr;@sS ,,7'  hjj*- P5E1F P3s#$ % % %DPr)rdrgrfc`ttj}|d|f}|r|dnd}|r|dnd} |d||| |||||rt j|dnd||f } t| jpdS) aInsert a zero-duration, already-closed run row. Used when a terminal transition happens on a task that was never claimed (CLI user calling ``hermes kanban complete --summary X``, or dashboard "mark done" on a ready task). Without this, the handoff fields (summary / metadata / error) would be silently dropped: ``_end_run`` is a no-op because there's no current run. The synthetic run has ``started_at == ended_at == now`` so it shows up in attempt history as "instant" and doesn't skew elapsed stats. Caller is responsible for leaving ``current_run_id`` NULL (or for clearing it elsewhere in the same txn) since this function does NOT touch the tasks row. z9SELECT assignee, current_step_key FROM tasks WHERE id = ?r*NrAz INSERT INTO task_runs ( task_id, profile, step_key, status, outcome, summary, error, metadata, started_at, ended_at ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) Fr4r)r,rrrrNrr) rr_rcrdrgrfrtrowr`rars r_synthesize_ended_runr>Gs0 dikk  C <<C    hjj #'0d:DG+/9t&''TH ,,  Wh W U8@ JDJxe 4 4 4 4d     C" s}! " ""rcd}t|5|d}|D]z}|d}|d|f}td|Dr.|d|ft ||dd|d z }{ dddn #1swxYwY|S) zPromote ``todo`` tasks to ``ready`` when all parents are ``done``. Returns the number of tasks promoted. Safe to call inside or outside an existing transaction; it opens its own IMMEDIATE txn. rz*SELECT id FROM tasks WHERE status = 'todo'r&zYSELECT t.status FROM tasks t JOIN task_links l ON l.parent_id = t.id WHERE l.child_id = ?c3.K|]}|ddkVdSrrHrs rrz"recompute_ready..s+::Q1X;&(::::::rzBUPDATE tasks SET status = 'ready' WHERE id = ? AND status = 'todo'rNr)rrrallr)rr todo_rowsrCr_rys rrecompute_readyrC~s> H 4LL 8  (**   C$iGll'  hjj  ::':::::  XJdGZ>>>A   & OsB%CC C) ttl_secondsclaimerrDrEc Pttj}|p t}|t|z}t|5|d|f}|r3|dr+|d|t|df|d||||f}|jdkr ddddS|d|f} |d|| r| d nd| r| d nd||| r| d nd|f} | j} |d | |ft||d ||| d| t||cdddS#1swxYwYdS)zAtomically transition ``ready -> running``. Returns the claimed ``Task`` on success, ``None`` if the task was already claimed (or is not in ``ready`` status). zBSELECT current_run_id FROM tasks WHERE id = ? AND status = 'ready'r?av UPDATE task_runs SET status = 'reclaimed', outcome = 'reclaimed', summary = COALESCE(summary, 'invariant recovery on re-claim'), ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND ended_at IS NULL a? UPDATE tasks SET status = 'running', claim_lock = ?, claim_expires = ?, started_at = COALESCE(started_at, ?) WHERE id = ? AND status = 'ready' AND claim_lock IS NULL rNzNSELECT assignee, max_runtime_seconds, current_step_key FROM tasks WHERE id = ?z INSERT INTO task_runs ( task_id, profile, step_key, status, claim_lock, claim_expires, max_runtime_seconds, started_at ) VALUES (?, ?, ?, 'running', ?, ?, ?, ?) r*rAr=z0UPDATE tasks SET current_run_id = ? WHERE id = ?claimed)lockexpiresrrr2) r,rrrrrrrrr) rr_rDrErrHrIstalerr=run_currrs r claim_taskrLs dikk  C  #kmmDC $$$G 4G'G'  P J   (**   U+,  LLc% 01223   ll 7C )    <1  GG'G'G'G'G'G'G'G'L|| & J   (** ,, $(2Z  d,0:'((d/3=*++   $" > W      '9g @ @    g&&OG'G'G'G'G'G'G'G'G'G'G'G'G'G'G'G'G'G'sBF$B*FF"Fcttjt|z}|p t}t|5|d|||f}|jdkr8t ||}||d||f ddddS ddddS#1swxYwYdS)zExtend a running claim. Returns True if we still own it. Workers that know they'll exceed 15 minutes should call this every few minutes to keep ownership. zYUPDATE tasks SET claim_expires = ? WHERE id = ? AND status = 'running' AND claim_lock = ?rNz3UPDATE task_runs SET claim_expires = ? WHERE id = ?TF)r,rrrrrr;)rr_rDrErIrHrrrs rheartbeat_claimrNs<$)++[!1!11G  #kmmD 4ll E gt $   <1  $T733F! If%sAB;-B;;B?B?c ttj}d}t|5|d|f}|D]i}|d|dft ||dddd|d}t ||ddd |di| |d z }j d d d n #1swxYwY|S) zReset any ``running`` task whose claim has expired. Returns the number of stale claims reclaimed. Safe to call often. rzmSELECT id, claim_lock FROM tasks WHERE status = 'running' AND claim_expires IS NOT NULL AND claim_expires < ?UPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND status = 'running'r& reclaimedz stale_lock=r5)rcr+rg stale_lockr2rN)r,rrrrr9r)rrrQrJrCrrs rrelease_stale_claimsrSsb dikk  CI 4  [ F   (**    C LL6T     c$i#K7C $577F c$is<01     NII#  0 sBCCC)r8rdrfr8c \ttj}t|5|d|||f}|jdkr ddddSt ||dd||n||}||s|s|rt ||d||n||}||n|pd }|r4|d dd nd }t||d|rt|nd |pdd | dddn #1swxYwYt|dS)uTransition ``running|ready -> done`` and record ``result``. Accepts a task that's merely ``ready`` too, so a manual CLI completion (``hermes kanban complete ``) works without requiring a claim/start/complete sequence. ``summary`` and ``metadata`` are stored on the closing run (if any) and surfaced to downstream children via :func:`build_worker_context`. When ``summary`` is omitted we fall back to ``result`` so single-run callers don't have to pass both. ``metadata`` is a free-form dict (e.g. ``{"changed_files": [...], "tests_run": [...]}``) — workers are encouraged to use it for structured handoff facts. ah UPDATE tasks SET status = 'done', result = ?, completed_at = ?, claim_lock = NULL, claim_expires= NULL, worker_pid = NULL WHERE id = ? AND status IN ('running', 'ready', 'blocked') rNF completedr )rcr+rdrf)rcrdrfri) result_lenrdr2T) r,rrrrr9r>r splitlinesrrrC) rr_r8rdrfrrrr ev_summarys r complete_taskrZ9s* dikk  C 4/ / ll S' "    <1  !/ / / / / / / / " '&2GG     >w>(>f>*g##*#6F! F")!4gg&GR AKSZ%%''2244Q7==QS  ';-3:c&kkk%-       Q/ / / / / / / / / / / / / / / bD 4s&D#B#DDD)reasonr[c:t|5|d|f}|jdkr ddddSt||dd|}||rt ||d|}t ||dd|i|  dddd S#1swxYwYdS) z"Transition ``running -> blocked``.a UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires= NULL, worker_pid = NULL WHERE id = ? AND status IN ('running', 'ready') rNFrrcr+rd)rcrdr[r2T)rrrr9r>r)rr_r[rrrs r block_taskr^s= 4ll J    <1   'i    >f>*g!F dGY60B6RRRR;s$BABBBc ttj}t|5|d|f}|r3|dr+|d|t|df|d|f}|jdkr ddddSt ||dd dddd S#1swxYwYdS) uTransition ``blocked -> ready``. Defensively closes any stale ``current_run_id`` pointer before flipping status. In the common path (``block_task`` closed the run already) this is a no-op. If a future or external write left the pointer dangling, the leaked run is closed as ``reclaimed`` inside the same txn so the runs invariant (``current_run_id IS NULL`` ⇔ run row in terminal state) holds for the rest of this function's lifetime. zDSELECT current_run_id FROM tasks WHERE id = ? AND status = 'blocked'r?au UPDATE task_runs SET status = 'reclaimed', outcome = 'reclaimed', summary = COALESCE(summary, 'invariant recovery on unblock'), ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND ended_at IS NULL z\UPDATE tasks SET status = 'ready', current_run_id = NULL WHERE id = ? AND status = 'blocked'rNF unblockedT)r,rrrrrr)rr_rrJrs r unblock_taskrasl dikk  C 4 R J   (**   U+,  LLc% 01223   ll 2 J   <1  /0 dG[$7773sBC?CC#&C#ct|5|d|f}|jdkr ddddSt||ddd}t ||dd| dddd S#1swxYwYdS) NzUPDATE tasks SET status = 'archived', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND status != 'archived'rFrQz#task archived with run still activer]rr2T)rrrr9r)rr_rrrs r archive_taskrcs  4ll 4J    <1   ' 9    dGZfEEEE%s$A7)A77A;>A;taskc|jpd}|dkr|jr[t|j}|s t d|jd|jdnt|jz }|dd|S|dkr|jst d|jdt|j}|s t d|jd|jd |dd|S|d kr|jstj d z |jz St|j}|s t d|jd |jd |St d|)ujResolve (and create if needed) the workspace for a task. - ``scratch``: a fresh dir under ``$HERMES_HOME/kanban/workspaces//``. - ``dir:``: the path stored in ``workspace_path``. Created if missing. MUST be absolute — relative paths are rejected to prevent confused-deputy traversal where ``../../../tmp/attacker`` resolves against the dispatcher's CWD instead of a meaningful root. Users who want a HERMES_HOME-relative workspace should compute the absolute path themselves. - ``worktree``: a git worktree at ``workspace_path``. Not created automatically in v1 -- the kanban-worker skill documents ``git worktree add`` as a worker-side step. Returns the intended path. Persist the resolved path back to the task row via ``set_workspace_path`` so subsequent runs reuse the same directory. rtask z! has non-absolute workspace_path z"; workspace paths must be absoluteTrxrz- has workspace_kind=dir but no workspace_pathzR; use an absolute path (relative paths are ambiguous against the dispatcher's CWD)rz .worktreesz has non-absolute worktree path z; use an absolute pathzunknown workspace_kind: ) r3r4r expanduser is_absoluterr&r"r~cwd)rdrprs rresolve_workspacerjsB"   +)D y   ,T())4466A==??  QDGQQ*QQQ   !!DG+A t,,, u}}" NNNN  $ % % 0 0 2 2}} OOO&OOO  t,,, z" 78:: ,tw6 6 $ % % 0 0 2 2}} AAA&AAA  666 7 77rr Path | strct|5|dt||fddddS#1swxYwYdS)Nz0UPDATE tasks SET workspace_path = ? WHERE id = ?)rrr%)rr_rs rset_workspace_pathrm)s 4   > YY                      s&AA Ai ceZdZUdZdZded<dZded<eeZ ded< eeZ d ed <eeZ d ed < eeZ d ed < eeZ d ed <dS)DispatchResultz&Outcome of a single ``dispatch`` pass.rr,rQr)default_factoryzlist[tuple[str, str, str]]spawnedrskipped_unassignedcrashed auto_blocked timed_outN)rWrXrYrZrQr[rrrQrrrsrtrurvrHrrrprpBs00IH*/%*E*E*EGEEEEB$)E$$?$?$?????t444G4444B#eD999L9999E 5666I6666BBrrprc>|r|dkrdS ttdr"tjt|dn)#t$rYdSt $rYdSt $rYdSwxYwtjdkr tdt|dd5}|D]E}| d r.d | d d d vrd d d dSnFd d d n #1swxYwYn#tt t f$rYnwxYwdS)uYReturn True if ``pid`` is still running on this host. Cross-platform: uses ``os.kill(pid, 0)`` on POSIX and ``OpenProcess`` on Windows. Returns False for falsy PIDs or on any OS error. **Zombie handling (Linux):** ``os.kill(pid, 0)`` succeeds against zombie processes (post-exit, pre-reap) because the process table entry still exists. A worker that exits without being reaped by its parent would stay "alive" to the dispatcher forever. Dispatcher workers are started via ``start_new_session=True`` + intentional Popen handle abandonment, so init reaps them quickly — but during the window between exit and reap, we'd otherwise see stale "alive" signals. On Linux we additionally peek at ``/proc//status`` and treat ``State: Z`` as dead. On other POSIX or on Windows the zombie check is a no-op. rFkillTlinuxz/proc/z/statusrzState:ZrrN) hasattrrrxr,ProcessLookupErrorPermissionErrorOSErrorsysplatformopen startswithsplitFileNotFoundError)rflines r _pid_aliverSs" #((u  2v   ! GCHHa uu tt uu |w 0s3xx000#66 !Dx00$**S!"4"4Q"777#(                          "?G<    D   4s_7A A* A* A*)A*>!D9C4 D%C4( D4C88D;C8<DDD)noterc~ttj}t|5|d||f}|jdkr ddddSt ||}||d||ft ||d|rd|ind|dddn #1swxYwYd S) aRecord a ``heartbeat`` event + touch ``last_heartbeat_at``. Called by long-running workers as a liveness signal orthogonal to the PID check. A worker that forks a long-lived child (train loop, video encode, web crawl) can have its Python still alive while the actual work process is stuck; periodic heartbeats catch that. Returns True on success, False if the task is not in a state that should be heartbeating (not running, or claim expired). zJUPDATE tasks SET last_heartbeat_at = ? WHERE id = ? AND status = 'running'rNFz7UPDATE task_runs SET last_heartbeat_at = ? WHERE id = ? heartbeatrr2T)r,rrrrr;r)rr_rrrrrs rheartbeat_workerrsB dikk  C 4  ll 2 'N   <1          !w//   LLIf      ';" ,VTNN                   & 4s%B2"AB22B69B6) signal_fncddl}g}ttj}tdddd}|d}|D]}|dpd}||s#|t|dz } | t|d krUt|d } |d } d } ||n"ttd r tj nd} | | | |j n#ttf$rYnwxYwtdD]'}t| sntjd(t| r, | | |jd} n#ttf$rYnwxYwt%|5|d| f}|jdkr| t| t|d | d}t)|| dddt| dt|d d|}t+|| d|||| dddn #1swxYwY|S)uRTerminate workers whose per-task ``max_runtime_seconds`` has elapsed. Sends SIGTERM, waits a short grace window, then SIGKILL. Emits a ``timed_out`` event and drops the task back to ``ready`` so the next dispatcher tick re-spawns it — unless the spawn-failure circuit breaker has already given up, in which case the task stays blocked where ``_record_spawn_failure`` parked it. Runs host-local: only tasks claimed by this host are candidates (same reasoning as ``detect_crashed_workers``). ``signal_fn`` is a test hook; defaults to ``os.kill`` on POSIX. rNrrzSELECT id, worker_pid, started_at, max_runtime_seconds, claim_lock FROM tasks WHERE status = 'running' AND max_runtime_seconds IS NOT NULL AND started_at IS NOT NULL AND worker_pid IS NOT NULLr5rVr1r=r;r&Frxrg?TzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, last_heartbeat_at = NULL WHERE id = ? AND status = 'running')relapsed_seconds limit_secondssigkillrvzelapsed z s > limit rJrcr+rgrfr2)signalr,rrrrrrr{rrxSIGTERMr|r~rrsleepSIGKILLrrr9rr)rrrrvr host_prefixrrCrHelapsedrtidkilledrx_rrqrrs renforce_max_runtimersH"MMMI dikk  C ]]((a003666K << B   hjj  :&:&< &B{++  C -... S2344 4 4 #l#$$$i%1yyr6** 4BGG    S&.))))&0    2YY  !#E 3# Dfn---!FF*G4Dt__ & &,,6 C|q  '*7||%(-B)C%D%D%  "#' _S\\__SEZA[=\=\___$  #{GF  %%%1 & & & & & & & & & & & & & & &2 s7D++D?>D? FF10F1B/I>>J J secondsct|5|d|t|nd|f}dddn #1swxYwY|jdkS)zKSet or clear the per-task max_runtime_seconds. Returns True on success.z5UPDATE tasks SET max_runtime_seconds = ? WHERE id = ?Nr)rrr,r)rr_rrs rset_max_runtimers 4  ll C$0S\\\dG D                 <1 s*AA  A c g}t|5|d}tdddd}|D]}|dpd}||s#t |dr9|d|d f}|jdkrt||d d d d t|dd t|d|dd }t||d d t|d|dd || |d  dddn #1swxYwY|S)uReclaim ``running`` tasks whose worker PID is no longer alive. Appends a ``crashed`` event and drops the task back to ``ready``. Different from ``release_stale_claims``: this checks liveness immediately rather than waiting for the claim TTL. Only considers tasks claimed by *this host* — PIDs from other hosts are meaningless here. The host-local check is enough because ``_default_spawn`` always runs the worker on the same host as the dispatcher (the whole design is single-host). z`SELECT id, worker_pid, claim_lock FROM tasks WHERE status = 'running' AND worker_pid IS NOT NULLrrrr5rVr;rPr&rtzpid z not alive)rrErr2N) rrrrrrrrr9r,rr)rrtrrrCrHrrrs rdetect_crashed_workersrsG 4"*"*|| B   (** %,,S!44Q7:::  * *C|$*D??;// #l+,, ,,6T C |q  !#d)%iCS%6!7!7CCC"3|#455#&|#4 #d)YL 122s ready where all parents are done. 4. For each ready task with an assignee, atomically claim and call ``spawn_fn(task, workspace_path) -> Optional[int]``. The return value (if any) is recorded as ``worker_pid`` so subsequent ticks can detect crashes before the TTL expires. Spawn failures are counted per-task. After ``failure_limit`` consecutive failures the task is auto-blocked with the last error as its reason — prevents the dispatcher from thrashing forever on an unfixable task. ``spawn_fn`` defaults to ``_default_spawn``. Tests pass a stub. zsSELECT id, assignee FROM tasks WHERE status = 'ready' AND claim_lock IS NULL ORDER BY priority DESC, created_at ASCrNr*r&rV)rDz workspace: rr)rprSrQrrtrrvrCrrrrsrrrrLrjrRrr&rurmr%_default_spawnrr,rr*)rrrDrrrr8 ready_rowsrrrCrG workspaceexcauto_spawnrs r dispatch_oncers4  F+D11F+D11FN*400F%d++FO 1hjj  G&7&7  W %9%9 E:   % , ,SY 7 7 7    N ! !3t9c*or"B C C C T3t9+FFF ?  )'22II   (gj"5"5"5+D 7#**7:666 HHHH  4S^^<<<%1~ 7&#i..11C <gj#c((;;; !$ 3 3 3 N ! !7:w/?/E2s9~~"V W W W qLGG 7 7 7(gj#c((+D 7#**7:666  7 Ms2 D E)#`` to ``.1`` if it exceeds ``max_bytes``. Single-generation rotation — one old file kept, newer one replaces it. Keeps disk usage bounded while still giving the user a chance to grab the prior run's output. Nz.1)existsstatst_size with_suffixsuffixunlinkr~rename)rrrotateds r_rotate_worker_logrs      F ==?? "i / / F&&x'=>> ~~ !       D           s?B%B%B%(A>=B%> B B% B  B%% B32B3rc Jddl}|jstd|jdd|j}t t j}|jr |j|d<|j|d<||d<|j|d <d d |jd d g}|jr)|jD]!}|r|d kr| d |g"| dd|gddl m }|dz dz }| dd||jdz } t| tt| d} ||t j|r|nd|j| |j|d} n1#t*$r$| t/dwxYw| jS)ajFire-and-forget ``hermes -p chat -q ...`` subprocess. Returns the spawned child's PID so the dispatcher can detect crashes before the claim TTL expires. The child's completion is still observed via the ``complete`` / ``block`` transitions the worker writes itself; the PID check is a safety net for crashes, OOM kills, and Ctrl+C. rNrfz has no assigneezwork kanban task HERMES_TENANTHERMES_KANBAN_TASKHERMES_KANBAN_WORKSPACEHERMES_PROFILEhermesz-pz--skillsz kanban-workerchatz-qrr logsTrx.logab)ristdinstdoutstderrenvstart_new_sessionzv`hermes` executable not found on PATH. Install Hermes Agent or activate its venv before running the kanban dispatcher.) subprocessr*rr&dictrenvironr7rBrrrr~rDEFAULT_LOG_ROTATE_BYTESrPopenrisdirDEVNULLSTDOUTrcloserr) rdrrpromptrcmdskrlog_dirrlog_fprocs rrrs+ =<::::;;; * * *F rz  C {+#{O $C%.C!" !MC  dm O C( {-+ - -B -bO++ J+,,,JJ f 100000o(*V3G MM$M...DG))))Hx!9::: 4 E  W]]955? 4$$"         ^     8Os %AE--.FgN@)intervalrr stop_eventon_tickrfloatcddl}ddl}|fd}||urGdD]D}t ||d} | / || |-#t tf$rY@wxYwEs tj t5} t| ||} dddn #1swxYwY| || n#t$rYnwxYwn(#t$rddl} | YnwxYw|dSdS)aORun the dispatcher in a loop until interrupted. Calls :func:`dispatch_once` every ``interval`` seconds. Exits cleanly on SIGINT / SIGTERM so ``hermes kanban daemon`` is systemd-friendly. ``stop_event`` (a :class:`threading.Event`) and ``on_tick`` (a callable receiving the :class:`DispatchResult`) are test hooks. rNc0dSr)rL)_signum_framers r_handlezrun_daemon.._handleusr)SIGINTr)rr)r|)r threadingrocurrent_thread main_threadgetattrrr~is_setrrrrrR traceback print_excwait) rrrrrrrrsig_namesigrresrs ` r run_daemonr`s3MMM__&&  !!Y%:%:%<%<<<-  H&(D11CMM#w////"G,D !!* "#GII.. $#'"/                "GCLLLL D " " "        ! ! ! ! ! " )))#!!*****sl%A<<BB) D C( D(C,,D/C,0D6 DD D DDD"D87D8c t||}|std|tfdCd}g}|d |jd |j|d |d |jpd |d|j|jr|d|j|d|j d|j pd|d |j rl|j rS|d|||j t|d dt||D}t|t kr-t|t z }|t d}|dz}nd}|}d}|r|d|r4|d|d|dkrdnd dt|dt#|D]e\} } || z} t%jdt%j| j} | jpd} | jp| j}|d| d |d!| d"| d# | jr<| j r#||| j| jr?| j r&|d$|| j| jrP t7j| jd%d&'}|d(||d)n#t:$rYnwxYw|d g|d*|f}d+|D}|rd%}|D]}t||}|r |jd,kr!d-t||D}| d.d&/|r|dnd} |s|d0d&}|d1|g}| D| jr=| j r$||| jn@|j!r$|||j!n|d2| W| jrP t7j| jd%d&'}|d(||d)n#t:$rYnwxYw|"||d |jr|d3|j|f}|r|d4|j|D]}t%jdt%jtG|d5} |d6pd $}|r|ddd7nd8}|d9|d:d |d;d!| d<||d tK||}t|tLkr(t|tLz }|tL d}nd}|}|r|d=|r4|d|d>|dkrdnd dt|d|D]}t%jdt%j|j'} |d?|j(d@| dA|||j tR|d dB*|+dBzS)Da2Return the full text a worker should read to understand its task. Order: 1. Task title (mandatory). 2. Task body (optional opening post, capped at 8 KB). 3. Prior attempts on THIS task (most recent ``_CTX_MAX_PRIOR_ATTEMPTS`` shown; older attempts collapsed into a one-line summary). Each attempt's ``summary`` / ``error`` / ``metadata`` capped at ``_CTX_MAX_FIELD_BYTES`` each. 4. Structured handoff results of every done parent task. Prefers ``run.summary`` / ``run.metadata`` when the parent was executed via a run; falls back to ``task.result`` for older data. Same per-field cap. 5. Cross-task role history for the assignee (most recent 5 completed runs on other tasks). 6. Comment thread (most recent ``_CTX_MAX_COMMENTS`` shown, older collapsed). All caps exist so worker prompts stay bounded even on pathological boards (retry-heavy tasks, comment storms). The per-field char cap prevents a single 1 MB summary from dominating context. r&rJr(rr,rr%c|sdS|}t||kr|S|d|dt||z dzS)z;Truncate a string to `limit` chars with a visible ellipsis.rVNu… [truncated, z chars omitted])rr)rJrs r_capz"build_worker_context.._capsY 2 GGII q66U??H%yMc!ffunMMMMMrz# Kanban task z: rVz Assignee: z (unassigned)z Status: z Tenant: z Workspace: z @ z (unresolved)z## Bodyc g|] }|j | Sr)rbrs rrKz(build_worker_context..sOOOq 8N8N8N8NrNrrz## Prior attempts on this taskz_(z earlier attemptz omitted; showing most recent z)_z%Y-%m-%d %H:%Mz (unknown)z ### Attempt u — z (rrz _error_: FT)r5 sort_keysz _metadata_: ``rcg|] }|d SrrHrs rrKz(build_worker_context..s666Q!K.666rr c(g|]}|jdk |S)rU)rcrs rrKz(build_worker_context.. s$PPP!qyK7O7OA7O7O7Orc|jSr)r1)rs rz&build_worker_context.. sALr)keyreversez## Parent task resultsz### z(no result recorded)zSELECT t.id, t.title, r.summary, r.ended_at FROM task_runs r JOIN tasks t ON r.task_id = t.id WHERE r.profile = ? AND r.task_id != ? AND r.outcome = 'completed' ORDER BY r.ended_at DESC LIMIT 5z## Recent work by @rbrdz (no summary)z- r&r'z): z## Comment threadz earlier commentz**z** (z): )rJr(rr,rr%),rr_CTX_MAX_FIELD_BYTESrr&r'r*r+r7r3r4r)r_CTX_MAX_BODY_BYTES list_runsr_CTX_MAX_PRIOR_ATTEMPTS enumeraterstrftime localtimer1r`rcrdrgrfrNrrRrrsortr8rr,rXr,_CTX_MAX_COMMENTSr/rm_CTX_MAX_COMMENT_BYTESrrstrip)rr_rdrlines all_prioromittedshownfirst_shown_idxoffsetrunidxtsr`rcmeta_str parent_rowsr wrote_headerrptruns body_lines role_rowsrCrJfirst all_comments omitted_cshown_ccs rbuild_worker_contextr$s . D' " "D 4222333,@NNNNNE LL9$'99TZ99::: LL LL?dm=~??@@@ LL+dk++,,, {1 /$+//000 LL^t2^^t7J7\n^^___ LL yTY__&& Y TT$)%899::: RPOIdG44OOOI 9~~///i..#::22334!A+  5666   LL?W??W\\ccr??03E ???   %U++  KFC!F*C/1O1OPPBk0[Gk/SZG LLMMM'MMWMMMMM N N N{ 0s{0022 0 TT#+..///y t}>> ? ? ?  R R]$dnSZ5I5I&J&J^)r0022==??&';!TcT ^ P#d)PP#g,PP"PPPPQQQQ LL    !w//L <,,, %%(99  11223   ()))   LLAYAAyA~~2AA03G AAA     A/ 1M1MNNB LL2ah22B222 3 3 3 LLaf&<== > > > LL     99U   " " $ $t ++s$>>M== N  N >U U Urci}|dD] }t|d||d<!i}|dD]:}t|d||di|d<;|d}tt j}|r |d|t|dz nd}||||d S) zPer-status + per-assignee counts, plus the oldest ``ready`` age in seconds (the clearest staleness signal for a router or HUD). zRSELECT status, COUNT(*) AS n FROM tasks WHERE status != 'archived' GROUP BY statusnr+SELECT assignee, status, COUNT(*) AS n FROM tasks WHERE status != 'archived' AND assignee IS NOT NULL GROUP BY assignee, statusr*z>SELECT MIN(created_at) AS ts FROM tasks WHERE status = 'ready'rN) by_status by_assigneeoldest_ready_age_secondsr)rr, setdefaultrr)rr(rCr) oldest_rowroldest_ready_ages r board_statsr.W s0!#I|| 511$'s3x== #h-  -/K|| $SS FIS]] s:33CMBBHhjj dikk  C  A$T*6 s:d#$$ $ $<@ "$4   rc@ttj}|jr|t|jz nd}|jr|t|jz nd}|jr0t|jt|jp|jz nd}|||dS)zEReturn age metrics for a single task. All values are seconds or None.N)created_age_secondsstarted_age_secondstime_to_complete_seconds)r,rr/r1r2)rdrage_since_createdage_since_startedtime_to_completes rtask_ager6{ s dikk  C6:oOc$/22224&*o?c$/""""4   'D T_%G!H!HHH"& 10$4  r) thread_iduser_idrchat_idr7r8c ttj}t|5|d||||pd||fddddS#1swxYwYdS)zRegister a gateway source that wants terminal-state notifications for ``task_id``. Idempotent on (task, platform, chat, thread).z INSERT OR IGNORE INTO kanban_notify_subs (task_id, platform, chat_id, thread_id, user_id, created_at) VALUES (?, ?, ?, ?, ?, ?) rVN)r,rrr)rr_rr9r7r8rs radd_notify_subr; s dikk  C 4     hb'3 G                      sAA #A  list[dict]c|*|d|f}n'|d}d|DS)Nz2SELECT * FROM kanban_notify_subs WHERE task_id = ?z SELECT * FROM kanban_notify_subsc,g|]}t|SrH)rrs rrKz$list_notify_subs.. s " " "DGG " " "rrrs rlist_notify_subsr? sf|| @7*  (** ||>??HHJJ " "T " " ""r)r7ct|5|d||||pdf}dddn #1swxYwY|jdkS)NzcDELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ?rVr)rrr)rr_rr9r7rs rremove_notify_subrA s 4  ll A hb 9                  last_event_id`` are returned. The subscription's cursor is NOT advanced here; call :func:`advance_notify_cursor` after the gateway has successfully delivered the notifications. zqSELECT last_event_id FROM kanban_notify_subs WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ?rVNr last_event_idz7SELECT * FROM task_events WHERE task_id = ? AND id > ? z AND kind IN (rrz) zORDER BY id ASCrqr&r_rpr/rrr/)rrr,rQrrrrrNrOrRrrorMmax)rr_rr9r7rBrCcursor kind_listqrrr0max_idrrqs runseen_events_for_subrK s ,, O (GY_"5  hjj   {"u _% & &F$.U $IAFO W?SXXcC NN&:;; ;d B BUW Y   !&)F! i   <<6 " " + + - -DC F  + + 23I,Hdj9...DGG   GGG  5w) 1V9,(0AFFHH(<(<8AXC( $$$^b      VS4\\** 3;s$D DD new_cursorc t|5|dt|||||pdfddddS#1swxYwYdS)NztUPDATE kanban_notify_subs SET last_event_id = ? WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ?rV)rrr,)rr_rr9r7rLs radvance_notify_cursorrN s 4    S __gx)/r J                     s+AA A i')older_than_secondsrOc ttjt|z }t|5|d|f}dddn #1swxYwYt|jpdS)zDelete task_events rows older than ``older_than_seconds`` for tasks in a terminal state (``done`` or ``archived``). Returns the number of rows deleted. Running / ready / blocked tasks keep their full event history.zwDELETE FROM task_events WHERE created_at < ? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'archived'))Nr)r,rrrr)rrOcutoffrs r gc_eventsrR s  $6 7 7 7F 4  ll J I                 s| q ! !!sA$$A(+A(crddlm}|dz dz }|sdStj|z }d}|D]]} |r6|j|kr||dz }N#t$rYZwxYw|S)zDelete worker log files older than ``older_than_seconds``. Returns the number of files removed. Kept separate from ``gc_events`` because log files live on disk, not in SQLite.rrr rr) rrrriterdiris_filerst_mtimerr~)rOrrrQremovedrs rgc_worker_logsrX s 100000o(*V3G >>  q Y[[- -FG __   yy{{ qvvxx0699 1     H  NsA B'' B43B4c:ddlm}|dz dz |dz S)zmReturn the path to a worker's log file. The file may not exist (task never spawned, or log already GC'd).rrr rrr)r_rs rworker_log_pathrZ6 s<100000 ?  x '& 0g3C3C3C CCr) tail_bytesr[ct|}|sdS ||ddS|j}t |d5}||kr|||z |}|}| ds-||kr||| }dddn #1swxYwY| ddS#t$rYdSwxYw)zRead the worker log for ``task_id``. Returns None if the file doesn't exist. If ``tail_bytes`` is set, only the last N bytes are returned (useful for the dashboard drawer which shouldn't page megabytes).Nzutf-8replace)encodingerrorsrb )r_) rZr read_textrrrseektellreadlineendswithreaddecoder~)r_r[rsizerprobepartialdatas rread_worker_logrm= su 7 # #D ;;==t  >>79>EE Eyy{{" $   j  tj())) **,,''.."16688t3C3CFF5MMM6688D               {{79{555 tts<D4)D4)BD D4DD4DD44 EEc tjdz dz }n#t$rgcYSwxYw|sgSg} t |D]H}|s|dz r||jIn#t$r|cYSwxYw|S)uXReturn the set of named profiles discovered on disk. Reads ``~/.hermes/profiles/`` directly so this module has no import dependency on ``hermes_cli.profiles`` (which pulls in a large chunk of the CLI startup path). Only returns directories that contain a ``config.yaml`` — a bare dir without config isn't a real profile. z.hermesprofilesz config.yaml) rhomerRis_dirrrTrUrrr~)rpnamesentrys rlist_profiles_on_diskrt_ sy{{Y&3   ;;== EDLLNN++ ) )E<<>>  %..00 ) UZ(((  )   Ls ++A*B22 CCc`tti|dD]:}t|d|di|d<;t tz}fd|DS)aReturn every assignee name known to the board or on disk. Each entry is ``{"name": str, "on_disk": bool, "counts": {status: n}}``. A name is included when it's a configured profile on disk OR when any non-archived task has it as the assignee. Used by: - ``hermes kanban assignees`` for the terminal. - The dashboard assignee dropdown (so a fresh profile appears in the picker even before it's been given any task). - Router-profile heuristics ("who's overloaded?") without scanning the whole board. r'r&r*r+cHg|]}||v|idS))ron_diskcounts)get)rIrrxrws rrKz#known_assignees.. sM     wjjr**     r)rLrtrr,r+rrM)rrCrrrxrws @@rknown_assigneesrzy s'))**G)+F|| $NN ADCH #j/2..s8}== 7S/// 0 0E          rT)include_activer{ list[Run]cd}|g}|s|dz }|dz }|||}d|DS)zReturn all runs for ``task_id`` in start order. ``include_active=True`` (default) includes the currently-running attempt if any. Set False to return only closed runs (useful for "how many prior attempts have there been?" checks). z)SELECT * FROM task_runs WHERE task_id = ?z AND ended_at IS NOT NULLz ORDER BY started_at ASC, id ASCcBg|]}t|SrH)r^rVrs rrKzlist_runs.. s" * * *CLLOO * * *rr)rr_r{rIrrs rrr sa 4A F ) (( ++A <<6 " " + + - -D * *T * * **r Optional[Run]c|dt|f}|rt|ndS)Nz$SELECT * FROM task_runs WHERE id = ?)rr,rr^rV)rrrrCs rget_runr sL ,,.V  hjj!$ -3<<   -rc|d|f}|rt|ndS)zEReturn the currently-open run for ``task_id`` (``ended_at IS NULL``).z_SELECT * FROM task_runs WHERE task_id = ? AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1Nrrr^rVrs r active_runr sK ,, +    hjj  !$ -3<<   -rc|d|f}|rt|ndS)zDReturn the most recent run regardless of outcome (active or closed).zSSELECT * FROM task_runs WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT 1Nrrs r latest_runr sK ,, 4    hjj  !$ -3<<   -r)rrr)rtrurrv)rtrurr)rrvrr)rrv)rr%)rrvr'r%r)r(r*r(r.r(r3r%r4r(r7r(r-r,ryrr rr9r(r=r0rBrrr%)rrvryrrr)rrvr_r%rr)rrvr*r(r+r(r7r(rrrr0rr)rrvr_r%r`r(rr)rrvrr%rr%rr)rrvrr%rr%rr)rrvr_r%rr)rrvr_r%rr!) rrvr_r%rmr%r)r%rr,)rrvr_r%rr))rrvr_r%rr-) rrvr_r%rpr%rqrerrr0rr)rrvr_r%rcr%rdr(rgr(rfrer+r(rr0)rrvr_r%rr0)rrvr_r%rcr%rdr(rgr(rfrerr,)rrvrr,) rrvr_r%rDr,rEr(rr) rrvr_r%rDr,rEr(rr) rrvr_r%r8r(rdr(rfrerr)rrvr_r%r[r(rr)rrvr_r%rr)rdr$rr)rrvr_r%rrkrr)rr0rr)rrvr_r%rr(rr)rrvrr)rrvr_r%rr0rr) rrvr_r%rgr%rr,rr)rrvr_r%rr,rr)rrvr_r%rr) rrvrDr,rrrr0rr,rrp)rrrr,rr)rdr$rr%rr0)rrrr0rr,rr)rrvr_r%rr%)rrvrr)rdr$rr)rrvr_r%rr%r9r%r7r(r8r(rr)rrvr_r(rr<) rrvr_r%rr%r9r%r7r(rr)rrvr_r%rr%r9r%r7r(rBrrrC)rrvr_r%rr%r9r%r7r(rLr,rr)rrvrOr,rr,)rOr,rr,)r_r%rr)r_r%r[r0rr()rr)rrvrr<)rrvr_r%r{rrr|)rrvrrr,rr)rrvr_r%rr)irZ __future__rrrNrrrrr dataclassesrrpathlibrtypingrrr rrDEFAULT_CLAIM_TTL_SECONDSrr rrr rr"r$r^rlrorrLrsr[rrrcontextmanagerrrrrrrrrr r rrr r$r(r,r1rr9r;r>rCrLrNrSrZr^rarcrjrmDEFAULT_SPAWN_FAILURE_LIMITrrprrrrrrrrrrrrr$r.r6r;r?rArKrNrRrXrZrmrtrzrrrrrHrrrs &#"""""  ((((((((**********WVV666 $"""++++ 7777 S S S S S S S  S l 2 2 2 2 2 2 2  2 j   !!!!!!! !u x #suu$$$$<,v v v v r * ' ' ' '####$" $#$( %))-&*k&k&k&k&k&k&\ 4 4 4 4////#  ",,,,,,>4    <.     ****)))) 2 2 2 2&'''',"8#  ! :"# 666666rQQQQ"#0#0#0#0#0#0#nJ1! V'V'V'V'V'V'z1! >L!!# HHHHHH^! $$$$$$N$$$$N4:8:8:8:8z    $ +  C C C C C C C  C ,,,,f $$$$$$TWWWWWWt    0000p5 999999xRRRR*    0#4MMMMMM`    .RRRRv#4  4*4*4*4*4*4*vu,u,u,u,x!!!!H8 $!      08< # # # # #$ $ . $%)......n $       ,