i]UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZddlmZddlmZmZmZhdZhdZd Zd Zd Zd Zd ZdZdZejdZddZ ddZ!ddZ"ddZ#ddZ$ddZ%ddZ&dddZ'ddd!Z(ddd"Z)ddd#Z*ddd$Z+ddd%Z,dd&Z-ddd(Z.dddddd)d d0Z/ddddd1d!d2Z0d3d4d"d7Z1d3d8d#d:Z2e Gd;d<Z3e Gd=d>Z4e Gd?d@Z5e GdAdBZ6dCZ7e8Z9dDe:dE< dddFd$dJZ; dddFd%dKZ<d&dMZ=ej>d'dNZ?ddOZ@ddPZAd(dRZBddddSddddTdUdddddV d)dhZCd*djZDd+dmZEddddUddnd,drZFd-dtZGd.dwZHd/dxZId/dyZJd0dzZKd0d{ZLd1d}ZMd2dZNd3dZOd4dZP dddd5dZQdddddd6dZRd7dZSddddd8dZTd9dZUeddd:dZVeddd;dZWddd9dZXdddddZ[ejdZ\d?dZ]Gdde^Z_ddddddd@dZ`ddddAdZaddddBdZbdCdZcdddddDdZddCdZeddFdEdZfdFdZgdZhehZidZje GddZkdZld ZmiZnde:d<dGdńZodHdDŽZpdIdȄZqdddJd˄Zrddd̜dKd΄ZsdddLdτZtdMdфZudLd҄ZvddUdUddӜdNd؄ZwddٜdOdڄZxdPdۄZydQd܄ZzezZ{dRd݄Z|dedUdeiddޜdSdZ}dTdZ~ddFdUdZddeiddddVdZdWdZdXdZdYdZddddZdZ dd[dZddd\dZdddd]dZddd^dZddd_dZdddd`dZddFdadZddddbdZdcdZddd Zd3d ded ZdfdZdgdZdgdZdhdZdidZdS(ju SQLite-backed Kanban board for multi-profile, multi-project collaboration. In a fresh install the board lives at ``/kanban.db`` where ```` is the **shared Hermes root** (the parent of any active profile). Profiles intentionally collapse onto a shared board: it IS the cross-profile coordination primitive. A worker spawned with ``hermes -p `` joins the same board as the dispatcher that claimed the task. The same applies to ``/kanban/workspaces/`` and ``/kanban/logs/``. **Multiple boards (projects):** users can create additional boards to separate unrelated streams of work (e.g. one per project / repo / domain). Each board is a directory under ``/kanban/boards//`` with its own ``kanban.db``, ``workspaces/``, and ``logs/``. All boards share the profile's Hermes home but are otherwise isolated: a worker spawned for a task on board ``atm10-server`` sees only that board's tasks, cannot enumerate other boards, and its dispatcher ticks don't touch other boards' DBs. The first (and for single-project users, only) board is ``default``. For back-compat its on-disk DB is ``/kanban.db`` (not ``boards/default/kanban.db``), so installs that predate the boards feature keep working with zero migration. See :func:`kanban_db_path`. Board resolution order (highest precedence first, all optional): * ``board=`` argument passed directly to :func:`connect` / :func:`init_db` (explicit — used by the CLI ``--board`` flag and the dashboard ``?board=...`` query param). * ``HERMES_KANBAN_BOARD`` env var (used by the dispatcher to pin workers to the board their task lives on — workers cannot see other boards). * ``HERMES_KANBAN_DB`` env var (pins the DB file path directly — legacy override still honoured; highest precedence when the file path itself is what the caller wants to force). * ``/kanban/current`` — a one-line text file holding the slug of the "currently selected" board. Written by ``hermes kanban boards switch ``. When absent, the active board is ``default``. In standard installs ```` is ``~/.hermes``. In Docker / custom deployments where ``HERMES_HOME`` points outside ``~/.hermes`` (e.g. ``/opt/hermes``), ```` is ``HERMES_HOME``. Legacy env-var overrides still work: * ``HERMES_KANBAN_DB`` — pin the database file path directly. * ``HERMES_KANBAN_WORKSPACES_ROOT`` — pin the workspaces root directly. * ``HERMES_KANBAN_HOME`` — pin the umbrella root that anchors kanban paths. Useful for tests and unusual deployments. The dispatcher injects ``HERMES_KANBAN_DB``, ``HERMES_KANBAN_WORKSPACES_ROOT``, and ``HERMES_KANBAN_BOARD`` into worker subprocess env so workers converge on the exact DB the dispatcher used to claim their task — even under unusual symlink or Docker layouts. 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. The CAS coordination is **per-board** — each board is a separate DB, so multi-board installs get the same atomicity guarantees without any new locking. ) annotationsN) dataclassfield)Path)AnyIterableOptional>donetodoreadytriageblockedrunningarchived>dirscratchworktreei ii idefaultz^[a-z0-9][a-z0-9\-_]{0,63}$slug Optional[str]returnc|dSt|}|sdSt|st d|d|S)z>Lowercase + strip a slug; validate; return ``None`` for empty.Nzinvalid board slug zc: must be 1-64 chars, lowercase alphanumerics / hyphens / underscores, not starting with '-' or '_')strstriplower_BOARD_SLUG_REmatch ValueError)rss 9/home/piyush/.hermes/hermes-agent/hermes_cli/kanban_db.py_normalize_board_slugr#s |t D !!A t    " "  S$ S S S    Hrctjdd}|r!t |Sddlm}|S)aReturn the shared Hermes root that anchors the kanban board. Resolution order: 1. ``HERMES_KANBAN_HOME`` env var when set and non-empty (explicit override for tests and unusual deployments). 2. ``get_default_hermes_root()``, which already returns ```` when ``HERMES_HOME`` is ``/profiles/``, and returns ``HERMES_HOME`` directly for Docker / custom deployments. The kanban board is shared across profiles **by design** (see the module docstring). Resolving the kanban paths through the active profile's ``HERMES_HOME`` would silently fork the board per profile, which breaks the dispatcher / worker handoff. HERMES_KANBAN_HOMErget_default_hermes_root)osenvirongetrr expanduserhermes_constantsr))overrider)s r" kanban_homer0sg z~~2B77==??H+H~~((***888888 " " $ $$r$c*tdz dz S)uaReturn ``/kanban/boards`` — the parent of non-default board dirs. ``default`` is intentionally NOT under this directory — its DB lives at ``/kanban.db`` for back-compat with pre-boards installs. This function returns the directory where *additional* named boards live, used by :func:`list_boards` to enumerate them. kanbanboardsr0r$r" boards_rootr6s ==8 #h ..r$c*tdz dz S)zReturn the path to ``/kanban/current``. One-line text file written by ``hermes kanban boards switch `` to persist the user's board selection across CLI invocations. Absent by default (meaning: active board is ``default``). r2currentr4r5r$r"current_board_pathr9s ==8 #i //r$rctjdd}|r% t |}|r|Sn#t $rYnwxYw t }|r^|d}|r4 t |}|rt|r|Sn#t $rYnwxYwn#t$rYnwxYwtS)u`Return the active board slug, honouring the resolution chain. Order (highest precedence first): 1. ``HERMES_KANBAN_BOARD`` env var (set by the dispatcher on worker spawn, or manually for ad-hoc overrides). 2. ``/kanban/current`` on disk (set by ``hermes kanban boards switch``), but only when that board still exists. 3. ``DEFAULT_BOARD`` (``"default"``). A malformed or stale slug at any step falls through to the next layer with a best-effort warning — the dispatcher must never crash because a user hand-edited a file or removed a board directory. HERMES_KANBAN_BOARDr'utf-8encoding) r*r+r,rr#r r9exists read_text board_existsOSError DEFAULT_BOARD)envnormedfvals r"get_current_boardrHs/ *... 3 3 9 9 ; ;C  *3//F       D     88:: ++w+//5577C 2377F&,v"6"6&% !D      sHA AAA C(!C C CCCC C)(C)ct|}|stdt}|jdd||dzd|S)uKPersist ``slug`` as the active board. Returns the file written. Writes ``/kanban/current``. The caller should validate the slug exists first (via :func:`board_exists`) — this function does not — so that ``hermes kanban boards switch `` returns an error instead of silently pointing at nothing. board slug is requiredTparentsexist_ok r<r=)r#r r9parentmkdir write_text)rrEpaths r"set_current_boardrSsm#4 ( (F 31222   DKdT222OOFTMGO444 Kr$Nonecj tdS#t$rYdSwxYw)zLRemove ``/kanban/current`` so the active board reverts to ``default``.N)r9unlinkFileNotFoundErrorr5r$r"clear_current_boardrXsG ##%%%%%      s $ 22boardcPt|pt}t|z S)uReturn the on-disk directory for ``board``. ``default`` is ``/kanban/boards/default/`` **for metadata only** (board.json + workspaces/ + logs/). Its DB file stays at ``/kanban.db`` for back-compat — see :func:`kanban_db_path`. All other boards live at ``/kanban/boards//`` with everything inside that directory including the ``kanban.db``. )r#rCr6rYrs r" board_dirr\s% ! ' ' 8=D ==4 r$boolct|pt}|tkrdSt|}|p|dz S)u Return True if the board has a DB or a metadata dir on disk. ``default`` is considered to always exist — its DB is created on first :func:`connect` and there's no way for it to be missing in a configuration where the kanban feature is usable at all. T kanban.db)r#rCr\is_dirr?)rYrds r"rArAsT ! ' ' 8=D }t$A 88:: 3!k/11333r$cFtjdd}|r!t |St |}|t}|tkrtdz St|dz S)u^Return the path to the ``kanban.db`` for ``board``. Resolution (highest precedence first): 1. ``HERMES_KANBAN_DB`` env var — pins the path directly. Honoured for back-compat and for the dispatcher→worker handoff (defense in depth: dispatcher injects this into worker env so workers are immune to any path-resolution disagreement). 2. When ``board`` arg is None, the active board from :func:`get_current_board` is used. 3. Board ``default`` → ``/kanban.db`` (back-compat path). Other boards → ``/kanban/boards//kanban.db``. HERMES_KANBAN_DBr'Nr_ r*r+r,rrr-r#rHrCr0r\rYr/rs r"kanban_db_pathrfsz~~0"55;;==H+H~~((***  ' 'D | "" }}}{** T??[ ((r$cLtjdd}|r!t |St |}|t}|tkrtdz dz St|dz S)uReturn the directory under which ``scratch`` workspaces are created. Anchored per-board so workspaces don't leak between projects. ``HERMES_KANBAN_WORKSPACES_ROOT`` pins the path directly (highest precedence) — the dispatcher injects this into worker env. ``default`` keeps the legacy path ``/kanban/workspaces/`` so that existing scratch workspaces from before the boards feature are preserved. Other boards use ``/kanban/boards//workspaces/``. HERMES_KANBAN_WORKSPACES_ROOTr'Nr2 workspacesrdres r"workspaces_rootrj/sz~~=rBBHHJJH+H~~((***  ' 'D | "" }}}x',66 T??\ ))r$ct|}|t}|tkrtdz dz St |dz S)uDReturn the directory under which per-task worker logs are written. ``default`` keeps the legacy path ``/kanban/logs/``. Other boards use ``/kanban/boards//logs/``. Logs follow the board — makes ``hermes kanban log`` unambiguous even when multiple boards have tasks with the same id. Nr2logs)r#rHrCr0r\r[s r"worker_logs_dirrmEsQ ! ' 'D | "" }}}x'&00 T??V ##r$cRt|pt}t|dz S)zReturn the path to ``board.json`` for ``board``. Stores display metadata (display name, description, icon, color, created_at). The on-disk slug is the canonical identity; this file is purely for presentation in the CLI / dashboard. board.json)r#rCr\r[s r"board_metadata_pathrpUs' ! ' ' 8=D T??\ ))r$cdd|dddDp|S)uTurn a slug into a reasonable default display name. ``atm10-server`` → ``Atm10 Server``. Users can override via ``board.json`` but the default should look presentable in the dashboard without any follow-up editing.  c3BK|]}||VdSN) capitalize).0parts r" z._default_board_display_name..gs2\\$W[\DOO%%\\\\\\r$_-)joinreplacesplit)rs r"_default_board_display_namer~`sG 88\\$,,sC2H2H2N2Ns2S2S\\\ \ \ d`ddr$dictct|pt}|t|dddddd} t|}|rWt j|d}t|tr||d<| |n#tt j f$rYnwxYwtt||d<|S) u8Return ``board.json`` contents (or synthesized defaults). Never raises — a missing / malformed ``board.json`` falls back to a synthesised entry so the dashboard always has something to render. Includes the canonical ``slug`` and ``db_path`` so the caller doesn't need to reconstruct them. r'NF)rname descriptioniconcolor created_atrr<r=rdb_path)r#rCr~rpr?jsonloadsr@ isinstancerupdaterBJSONDecodeErrorrrf)rYrmetapraws r"read_board_metadatarjs ! ' ' 8=D+D11D   % % 88:: !*Q[['[::;;C#t$$ !#F  C   T) *     ...//DO KsA:B**CC)rrrrrrrrrrOptional[bool]ct|pt}t|}|dd|3t |pt ||d<|t ||d<|t ||d<|t ||d<|t||d<|ds#ttj |d<t|}|j d d |tj|d d dzdt t#||d<|S)zCreate / update ``board.json`` for ``board``. Preserves any existing fields not mentioned in the call. Sets ``created_at`` on first write. Returns the resulting metadata dict. rNrrrrrrTrKF)indent ensure_asciirNr<r=)r#rCrpoprrr~r]r,inttimerprOrPrQrdumpsrf) rYrrrrrrrrRs r"write_board_metadatarsi ! ' ' 8=D t $ $D HHY 4yy((M,G,M,MV !+..] 4yyV  E W >>Z 88L ! !. --\ t $ $DKdT222OO 4666=...//DO Kr$rrrrct|}|stdt|||||}t||S)u Create a new board directory + DB + metadata. Idempotent. Returns the resulting metadata. Raises :class:`ValueError` for a malformed slug; returns the existing metadata (not an error) if the board already exists — matching ``mkdir -p`` semantics. rJrrY)r#r rinit_db)rrrrrrErs r" create_boardrsc#4 ( (F 31222       D & Kr$T)include_archivedr list[dict]cg}t}|tt|tt }|rt|dD]}|s|j } t|}n#t$rY;wxYw|r||vrF|dz }|dz }|s|syt|} | dr|s|| |||S)aEnumerate all boards that exist on disk. Always includes ``default`` (even when the ``boards/default/`` metadata dir doesn't exist, because its DB is at the legacy path). Other boards are discovered by scanning ``boards/`` for subdirectories that either contain a ``kanban.db`` or a ``board.json``. Returns a list of metadata dicts, sorted with ``default`` first and the rest alphabetically. c4|jSrt)rr)rs r"zlist_boards..s!&,,..r$keyr_ror)setappendrrCaddr6r`sortediterdirrr#r r?r,) rentriesseenrootchildrrEhas_dbhas_metars r" list_boardsrsyGUUD NN&}55666HH] ==D {{}}DLLNN0H0HIII  E<<>> :D .t44     Vt^^k)1133F ,4466H h &v..Dxx ## ,<  NN4 HHV     Ns7C CC)archiverct|}|std|tkrtdt|}|std|dt |krt |rtdz }|ddttj }||d|z }d }|r&||d|d|z }|d z }|&| ||d t|d Sd d l }|||ddd S)uRemove or archive a board. ``archive=True`` (default) moves the board's directory to ``/kanban/boards/_archived/-/`` so the data is recoverable. ``archive=False`` deletes the directory outright. The ``default`` board cannot be removed — raises :class:`ValueError`. Returns a summary dict describing what happened (``{"slug", "action", "new_path"}``). rJz%the 'default' board cannot be removedzboard z does not exist _archivedTrKrzr)ractionnew_pathrNdeletedr')r#r rCr\r?rHrXr6rPrrrenamershutilrmtree) rrrEra archive_roottstargetsuffixrs r" remove_boardrs#4 ( (F 31222 @AAA&A 88::=;&;;;<<<f$$E"}}{2 4$777   6 0 0B 0 00mmoo !v$=$=$=$=V$=$==F aKFmmoo  *#f++NNN  a)DDDr$cjeZdZUdZded<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"<dZd ed#<ed)d(ZdS)*Taskz1In-memory view of a row from the ``tasks`` table.ridtitlerbodyassigneestatusrpriority created_byr Optional[int] started_at completed_atworkspace_kindworkspace_path claim_lock claim_expirestenantNresultidempotency_keyrconsecutive_failures worker_pidlast_failure_errormax_runtime_secondslast_heartbeat_atcurrent_run_idworkflow_template_idcurrent_step_keyzOptional[list]skills max_retriesrow sqlite3.Rowr'Task'ct|}d}d|vrW|drO tj|d}t |t r d|D}n#t $rd}YnwxYw|d id|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|dn d|vr|dnddd|vr|dnddd|vr|dn d|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dnddd|vr|dndd|dd|vr|dndS)!Nrc0g|]}|t|Sr5)r)rvr!s r" z!Task.from_row..hs##@#@#@qa#@CFF#@#@#@r$rrrrrrrrrrrrrrrrrrspawn_failuresrrrlast_spawn_errorrrrrrrr5)rkeysrrrlist Exception)clsrr skills_valueparseds r"from_rowz Task.from_row_sc388::'+ t  H  $CM22fd++A#@#@F#@#@#@L $ $ $#  $s3 3 3 4yy3 g,,3 V3 __ 3 x== 3 __ 3 <((3 <((3 <((3 ^,,3 /003 /003 <((3 o..3 %-$4$43x==$3 %-$4$43x==$!3 "7H46O6OC 122UY#3 &0F/M/M*++ 0@4/G/Gc*++Q13 4-9D,@,@s<((d53 8.BT-I-I())1Ct1K1Kc,--QU=3 B/Dt.K.K)**QUC3 H-@4,G,G'((TI3 N*:T)A)A$%%tO3 T0F/M/M*++SWU3 Z,>+E+E&''4[3 ^ <_3 b'4t&;&;M""c3 3 s;A-- A<;A<)rrrr)__name__ __module__ __qualname____doc____annotations__rrrrrrrrrrrr classmethodrr5r$r"rr+s;; GGGJJJKKKMMMOOO!!!!     F    %)O))))!"!!!! $J$$$$)-,,,,)-----'+++++$(N((((*.....&***** "F!!!!"&K%%%%> > > [> > > r$rceZdZUdZded<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``. rrrtask_idrprofilestep_keyrrrrrrrrended_atoutcomesummaryOptional[dict]metadataerrorrrr'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)Nrrrrrrrrrrrrrrrrr5)rrrr)rrrs r"rz 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)rrrr)rrrrrrrr5r$r"rrs GGGLLLKKK    &&&&$$$$OOO   [   r$rcBeZdZUded<ded<ded<ded<ded<dS) CommentrrrrauthorrrN)rrrrr5r$r"rrs= GGGLLLKKK IIIOOOOOr$rcPeZdZUded<ded<ded<ded<ded<d Zd ed <d S) EventrrrrkindrpayloadrNrrun_id)rrrrrr5r$r"rrsS GGGLLL IIIOOO F      r$ru 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, -- Unified consecutive-failure counter. Incremented on spawn -- failure, timeout, or crash; reset only on successful completion. -- The circuit breaker in _record_task_failure trips when this -- exceeds DEFAULT_FAILURE_LIMIT consecutive non-successes. consecutive_failures INTEGER NOT NULL DEFAULT 0, worker_pid INTEGER, -- Short excerpt of the most recent failure's error text. last_failure_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, -- Per-task override for the consecutive-failure circuit breaker. -- The value is the failure count at which the breaker trips — e.g. -- ``max_retries=1`` blocks on the first failure. NULL (the common -- case) falls through to the dispatcher-level ``kanban.failure_limit`` -- config and then ``DEFAULT_FAILURE_LIMIT``. max_retries INTEGER ); 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_PATHSrrOptional[Path]sqlite3.Connectionc.||}nt|}|jddt|}|t v}t jt|dd}t j|_ | d| d| d |rC| tt|t ||S) uOpen (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. Path resolution: * ``db_path`` explicit → used as-is (legacy callers, tests). * ``board`` explicit → resolves to that board's DB. * Neither → :func:`kanban_db_path` resolves via ``HERMES_KANBAN_DB`` env → ``HERMES_KANBAN_BOARD`` env → ``/kanban/current`` → ``default``. NrTrKr)isolation_leveltimeoutzPRAGMA journal_mode=WALzPRAGMA synchronous=NORMALzPRAGMA foreign_keys=ON)rfrOrPrresolversqlite3connectRow row_factoryexecute executescript SCHEMA_SQL_migrate_add_optional_columnsr)rrYrRresolved needs_initconns r"rrxs.E***KdT2224<<>>""H!33J ?3t99dB G G GD{DLL*+++LL,---LL)***) :&&&%d+++x((( Kr$cR||}nt|}|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. NrTrK) rfrOrPrrrdiscard contextlibclosingr)rrYrRrs r"rrsE***KdT2224<<>>""Hx(((  GDMM * *                  KsBB #B rc d|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|vr|dd|vr|dd |vr|d!d"|d#D}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}|d0|j|d,f}|jd1kr;|d2t t j|jf d(d(d(n #1swxYwYd3} | D]\} } |d4| | fd(S)5zAdd columns that were introduced after v1 release to legacy DBs. Called by ``init_db`` so opening an old DB is always safe. ch|] }|d Srr5rvrs r" z0_migrate_add_optional_columns..s L L LCCK L L Lr$zPRAGMA table_info(tasks)rz(ALTER TABLE tasks ADD COLUMN tenant TEXTrz(ALTER TABLE tasks ADD COLUMN result TEXTrz1ALTER TABLE tasks ADD COLUMN idempotency_key TEXTzJCREATE INDEX IF NOT EXISTS idx_tasks_idempotency ON tasks(idempotency_key)rzLALTER TABLE tasks ADD COLUMN consecutive_failures INTEGER NOT NULL DEFAULT 0rzCUPDATE tasks SET consecutive_failures = COALESCE(spawn_failures, 0)rz/ALTER TABLE tasks ADD COLUMN worker_pid INTEGERrz4ALTER TABLE tasks ADD COLUMN last_failure_error TEXTrz6UPDATE tasks SET last_failure_error = last_spawn_errorrz8ALTER TABLE tasks ADD COLUMN max_runtime_seconds INTEGERrz6ALTER TABLE tasks ADD COLUMN last_heartbeat_at INTEGERrz3ALTER TABLE tasks ADD COLUMN current_run_id INTEGERrz6ALTER TABLE tasks ADD COLUMN workflow_template_id TEXTrz2ALTER TABLE tasks ADD COLUMN current_step_key TEXTrz(ALTER TABLE tasks ADD COLUMN skills TEXTrz0ALTER TABLE tasks ADD COLUMN max_retries INTEGERch|] }|d Sr r5r!s r"r"z0_migrate_add_optional_columns..sUUUss6{UUUr$zPRAGMA table_info(task_events)rz1ALTER 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 NULLraV INSERT INTO task_runs ( task_id, profile, status, claim_lock, claim_expires, worker_pid, max_runtime_seconds, last_heartbeat_at, started_at ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?) rrrrzKUPDATE tasks SET current_run_id = ? WHERE id = ? AND current_run_id IS NULLrz_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_txnfetchallrr lastrowidrowcount) rcolsev_cols runs_existinflightrstartedcurupd_EVENT_RENAMESoldnews r"rrsz M L4<<0J#K#K L L LDt ?@@@t ?@@@$$ HIII  (   *T))  )    t # # LLU   4 FGGG4'' KLLL  % % LLH   D(( OPPP$&& MNNNt## JKKKT)) MNNN%% IJJJt ?@@@D  GHHHVUdll3S&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      s4DMM M c#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)rr)rs r"r)r)]su LL"### X  Z    s 4!Ac0dtjdzS)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_hexr5r$r" _new_task_idr?ss '#A&& &&r$cddl} |pd}n#t$rd}YnwxYw|dtjS)z:Return a ``host:pid`` string that identifies this claimer.rNunknown:)socket gethostnamerr*getpid)rChosts r" _claimer_idrGsfMMM!!##0y  " "RY[[ " ""s  ,,rc,|dSddlm}||S)zHLowercase-assignee normalization for Kanban rows (dashboard/CLI parity).Nrnormalize_profile_name)hermes_cli.profilesrJ)rrJs r"_canonical_assigneerLs0t:::::: ! !( + ++r$rr5F) rrrrrrrrLr rrrrrrrrrrrrrL Iterable[str]r rrrrOptional[Iterable[str]]rct|}|r|std|tvr'tdt td|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|nd|t|ndf| D]}| d||ft1||d||t3| ||rt3|ndddddn #1swxYwY|cS#t4j$r |dkrYwxYwt9d)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 dSrtr5rvrs r"rxzcreate_task..s',,!!,A,,,,,,r$N,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 1rrr r zunknown parent task(s): , z&SELECT status FROM tasks WHERE id IN (?)c3.K|]}|ddkVdSrr Nr5rvrs r"rxzcreate_task.. s+CCq{f4CCCCCCr$r a INSERT INTO tasks ( id, title, body, assignee, status, priority, created_by, created_at, workspace_kind, workspace_path, tenant, idempotency_key, max_runtime_seconds, skills, max_retries ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) DINSERT OR IGNORE INTO task_links (parent_id, child_id) VALUES (?, ?)created)rrrLrrr unreachable)rLrr VALID_WORKSPACE_KINDSrtuplerrrrrr(rrranger?r)_find_missing_parentsr{lenr*anyrr _append_eventrrIntegrityError RuntimeError)rrrrrrrrrrLr rrrr skills_listcleanedrr!rrnowattemptrinitial_statusmissingrowspids r" create_taskrnsT#8,,H . .,---222 &V4I-J-J & &! & &   ,,w,,,,,G(,K  ! !A q66<<>>D d{{ XXXXt|| HHTNNN NN4  ll /    (**  t9  dikk  C88NN..L 4E E 4%-NN%,N 4"7g"F"F"^",-\ RYHZHZ-\-\"]"]]#|| "%((3W+=">">?ADE#  #(**  CCdCCCCC4-3NZgZ3D'BBGZ()XDIIgDVDV)X)XYYY    & "&&'4GQ/000T3>3J ;///PT,7,CK(((6#CLL^g$,"0#'=="(7B"L${"3"3"3    uE E E E E E E E E E E E E E E LNNN%   !|| H   } % %%s7<M F*M5 MM MM MM*)M* list[str]ct|}|sgSddt|z}|d|d|}d|Dfd|DS)NrRrT"SELECT id FROM tasks WHERE id IN (rUch|] }|d Srr5rXs r"r"z(_find_missing_parents..Rs%%%1qw%%%r$cg|]}|v| Sr5r5)rvrpresents r"rz)_find_missing_parents..Ss# 3 3 3!!7"2"2A"2"2"2r$)rr{rarr*)rrL placeholdersrlrus @r"r`r`Is7mmG  88C#g,,.//L <<<\<<<  hjj &%%%%G 3 3 3 3w 3 3 33r$rOptional[Task]c|d|f}|rt|ndS)Nz SELECT * FROM tasks WHERE id = ?)rr(rrrrrs r"get_taskrzVs@ ,,9G: F F O O Q QC!$ .4==   $.r$)rrrrlimitrr{ list[Task]cd}g}|'|dz }|t||G|tvr$tdt t|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|Sr5)rrrXs r"rzlist_tasks..ws$ + + +DMM!   + + +r$)rrLVALID_STATUSESr rrrr*) rrrrrr{queryparamsrls r" list_tasksr[s& ,EF $$ )(33444   ' 'Nf^6L6LNNOO O "" f  "" f -* 4 4 ,, 66E ( '3u::''' <<v & & / / 1 1D + +d + + ++r$rct|}t|5|d|f}|s ddddS|d|ddkrt d|d|d |kr|d ||fn|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. z;SELECT status, claim_lock, assignee FROM tasks WHERE id = ?NFrrrzcannot reassign zS: currently running (claimed). Wait for completion or reclaim the stale lock first.rz_UPDATE tasks SET assignee = ?, consecutive_failures = 0, last_failure_error = NULL WHERE id = ?z*UPDATE tasks SET assignee = ? WHERE id = ?assignedT)rLr)rr(rerc)rrrrs r" assign_taskrzs "'**G 4ll IG:  (**    |  (S]i-G-GG7GGG  z?g % % LL9'"     LLEQXGY Z Z ZdGZ*g1FGGG/s-CA9CC#&C# 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): rSzlinking z -> z would create a cyclerZ%SELECT status FROM tasks WHERE id = ?rr zBUPDATE tasks SET status = 'todo' WHERE id = ? AND status = 'ready'linkedrOr)r r)r`r{ _would_cyclerr(rc)rrrrk parent_statuss r" link_tasksrsH9::: 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)rNr5rXs r"rxz_would_cycle..s&11qQz]111111r$F)rrrrr*extend)rrrrstacknoderls r"rrs 55D JE  2yy{{ 9  4 4<<  || AD7  (**   11D111111  2 5r$c t|5|d||f}|jrt||d||d|jdkcdddS#1swxYwYdS)Nz;DELETE FROM task_links WHERE parent_id = ? AND child_id = ?unlinkedrr)r)rr,rc)rrrr2s 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 Srr5rXs r"rzparent_ids..s ) ) )qAkN ) ) )r$rr*rrrls r" parent_idsrsA <<P    hjj  * )D ) ) ))r$cl|d|f}d|DS)NzESELECT child_id FROM task_links WHERE parent_id = ? ORDER BY child_idcg|] }|d S)rr5rXs r"rzchild_ids..s ( ( (aAjM ( ( (r$rrs r" child_idsrsA <<O    hjj  ) (4 ( ( ((r$list[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)rrr5rXs r"rz"parent_results..s% 1 1 1qQtWak " 1 1 1r$rrs r"parent_resultsrsE <<     hjj  2 1D 1 1 11r$rc |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 QINSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?) commented)rrar) rr rrr)rr(rcrar+)rrrrrhr2s r" add_commentrs} 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)rrrrr)rrrrr)rrXs r"rz!list_comments.. s\     wiLX;6       r$rrs r" list_commentsrsN <<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 ASCrrrrrrrrrrrr) rr*rrrrrrr)rrrloutrYrs r" list_eventsr,s <<U    hjj  C    23I,Hdj9...DGG   GGG  T7) vY\?,4,@,@Qx[E\AhK(((bf      Js$A A%$A%rrrrrcttj}|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. FrNz[INSERT INTO task_events (task_id, run_id, kind, payload, created_at) VALUES (?, ?, ?, ?, ?))rrrrr)rrrrrrhpls r"rcrcDsh dikk  C4; EG% 0 0 0 0BLL ! &$C(r$)rrrrrrrrc 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 = ?rNa 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 Frz3UPDATE tasks SET current_run_id = NULL WHERE id = ?)rrrr(rr) rrrrrrrrhrrs r"_end_runr\s& dikk  C ,,7'  hjj c*+t %& ' 'FLL   g   8@ JDJxe 4 4 4 4d   2 LL=z Mr$c|d|f}|r|drt|dndS)Nrr)rr(rrys r"_current_run_idrsS ,,7'  hjj*- P5E1F P3s#$ % % %DPr$)rrrc`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 = ?rNrz INSERT INTO task_runs ( task_id, profile, step_key, status, outcome, summary, error, metadata, started_at, ended_at ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) Frr)rrrr(rrr+) rrrrrrrhtrowrrr2s r"_synthesize_ended_runrs0 dikk  C <<C    hjj #'0d:DG+/9t&''TH ,,  Wh W U8@ JDJxe 4 4 4 4d     C" s}! " ""r$cd}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'rzYSELECT t.status FROM tasks t JOIN task_links l ON l.parent_id = t.id WHERE l.child_id = ?c3.K|]}|ddkVdSrWr5rQs r"rxz"recompute_ready..s+::Q1X;&(::::::r$zBUPDATE tasks SET status = 'ready' WHERE id = ? AND status = 'todo'r$Nr)r)rr*allrc)rr$ todo_rowsrrrLs r"recompute_readyrs> H 4LL 8  (**   C$iGll'  hjj  ::':::::  XJdGZ>>>A   & OsB%CC C) ttl_secondsclaimerrrc 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'rav 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', ?, ?, ?, ?) rrrz0UPDATE tasks SET current_run_id = ? WHERE id = ?claimed)lockexpiresrr) rrrGr)rr(r,r+rcrz) rrrrrhrrstaler2rrun_currs r" claim_taskrs 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)rrrGr)rr,r)rrrrrrr2rs r"heartbeat_claimrMs<$)++[!1!11G  #kmmD 4ll E gt $   <1  $T733F! If%sAB;-B;;B?B? signal_fnc nttj}d}|d|f}|D]}t |d|d|}t |5|d|d|d|f}|jdkr d d d mt||dd d d |d| }d |di} | |t||dd | ||dz }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. rzySELECT id, claim_lock, worker_pid FROM tasks WHERE status = 'running' AND claim_expires IS NOT NULL AND claim_expires < ?rrrzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND status = 'running' AND claim_lock IS ? AND claim_expires IS NOT NULL AND claim_expires < ?rrN reclaimedz stale_lock=rrrr stale_lockr) rrrr*_terminate_reclaimed_workerr)r,rrrc) rrrhrrr terminationr2rrs r"release_stale_claimsrls dikk  CI LL W   hjj  1  s<0I   t__  ,,FTC -s3 C|q         c$i#K7C $577$ F $S%67G NN; ' ' ' c$i     NI/               0 s=2D);A"D))D- 0D- )reasonrrc 8|d|f}|sdS|ddkr |ddS|d}t|d||}t|5|d ||f}|jd kr ddddSt ||d d |rd |nd ||}d||d} | |t||d | |dddn #1swxYwYt||dS)a!Operator-driven reclaim: release the claim and reset to ``ready``. Unlike :func:`release_stale_claims` which only acts on tasks whose ``claim_expires`` has passed, this function reclaims immediately regardless of TTL. Intended for the dashboard/CLI recovery flow when an operator wants to abort a running worker without waiting for the TTL to expire (e.g. after seeing a hallucination warning). Returns True if a reclaim happened, False if the task isn't in a reclaimable state (not running, or doesn't exist). z=SELECT status, claim_lock, worker_pid FROM tasks WHERE id = ?FrrrNrrzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND status IN ('running', 'ready', 'blocked') AND claim_lock IS ?rrzmanual_reclaim: zmanual_reclaim lock=rT)manualr prev_lockr) rr(rr)r,rrrc_clear_failure_counter) rrrrrrrr2rrs r" reclaim_taskrs$ ,,G    hjj u 8} !!c,&7&?uL!I- L9 K 4  ll "i    <1           ' /58+6+++7I77    "   {### ';     3               D4))) 4s3%C?%AC??DD) reclaim_firstrrct|rt|||pd t|||S#t$rYdSwxYw)a Reassign a task, optionally reclaiming a stuck running worker first. This is the recovery path for "this profile's model is broken, try a different one". If ``reclaim_first`` is True, any active claim is released (via :func:`reclaim_task`) before the reassign happens; otherwise the function refuses to reassign a currently-running task and returns False (caller can retry with ``reclaim_first=True``). Returns True if the reassign landed. ``profile`` may be ``None`` to unassign entirely. reassign)rF)rrre)rrrrrs r" reassign_taskrsb&AT76+?Z@@@@4'222 uus ) 77completing_task_id claimed_idstuple[list[str], list[str]]ctd|pgD}|sggfSt}g}|D]0}||vr*||||1|d|f}|g|fS|d}ddgt |z} |d| dt|} d | D} tt||} g} g}|D]}| |}|||/|r||kr| |M||kr| |i|| vr| |||| |fS) uPartition ``claimed_ids`` into (verified, phantom). A card is "verified" iff a row exists in ``tasks`` AND at least one of the following holds: * ``created_by`` matches the completing task's ``assignee`` profile (the common case: worker A spawns a card via ``kanban_create``, which stamps ``created_by=A``). * ``created_by`` matches the completing task's id (edge case where a worker passed its own task id as the ``created_by`` value). * The card is linked as a ``task_links.child`` of the completing task — i.e. the worker explicitly called ``kanban_create`` with ``parents=[]``. This accepts cards created through the dashboard/CLI by a different principal but then attached to the completing task by the worker. ``phantom`` returns ids that either don't exist at all, or exist but don't satisfy any of the three trust conditions. The caller decides what to do with each bucket; this helper never mutates. cg|]D}t|#t|ESr5)rr)rvxs r"rz)_verify_created_cards..s9MMM!c!ffllnnMs1vv||~~MMMr$z'SELECT assignee FROM tasks WHERE id = ?NrrRrTz.SELECT id, created_by FROM tasks WHERE id IN (rUc,i|]}|d|dS)rrr5rXs r" z)_verify_created_cards..1s" 4 4 4!QtWa o 4 4 4r$) rrrrr(r{rar^r*rr,)rrrrrorderedcidrcompleting_assigneervrlfoundlinked_childrenverifiedphantomrs r"_verify_created_cardsrs 2NM (9rMMMG 2v UUDG   d?? HHSMMM NN3    ,,14F3H  hjj {7{j/88SECLL011L <<HHHH g  hjj  5 4t 4 4 4E!$Id4F$G$G H HOHG   YYs^^   NN3      :1D#D#D OOC - - - OOC O # # OOC NN3     W r$z\bt_[a-f0-9]{8,}\btextc|sgSt|}|sgSt}g}|D]0}||vr*||||1ddgt |z}|d|dt| }d|Dfd|DS)ueRegex-scan free-form text for ``t_`` references; return the ones that don't exist in ``tasks``. Used as a non-blocking advisory check on completion summaries. An empty return means "no suspicious references found" — either the text had no IDs at all, or every ID it mentioned resolves to a real task. Duplicates are deduped. rRrTrqrUch|] }|d Srsr5rXs r"r"z._scan_prose_for_phantom_ids..ms&&&A$&&&r$cg|]}|v| Sr5r5)rvmexistings r"rz/_scan_prose_for_phantom_ids..ns# 3 3 3!(!2!2A!2!2!2r$) _TASK_ID_PROSE_REfindallrrrr{rarr^r*) rrmatchesruniquerrvrlrs @r"_scan_prose_for_phantom_idsrPs  ''--G  UUDF  D== HHQKKK MM!   88SECKK/00L <<<\<<< f   hjj '&&&&H 3 3 3 3v 3 3 33r$c$eZdZdZdfd ZxZS)HallucinatedCardsErroraORaised by ``complete_task`` when ``created_cards`` contains ids that don't exist or weren't created by the completing worker. The phantom list is attached as ``.phantom`` for callers that want structured access. Kept as ``ValueError`` subclass so existing tool-error handlers treat it as a recoverable user error. rrorrct||_||_tdd|dS)Nz`completion blocked: claimed created_cards that do not exist or were not created by this worker: rS)rrrsuper__init__r{)selfrr __class__s r"rzHallucinatedCardsError.__init__zs_G}} "4  H3799W3E3E H H     r$)rrorr)rrrrr __classcell__)rs@r"rrqsG          r$r)rrr created_cardsexpected_run_idrrrc 6ttj}|rt|||\}|rt|5t ||d||s|r8|p|pddddndddddn #1swxYwYt||ngt|5||d|||f} n'|d|||t|f} | j d kr dddd St||d d ||n|| } | |s|s|rt||d ||n||} ||n|pd} | r4| dddnd} |rt|nd| pdd} r| d<t ||d | | dddn #1swxYwYd td||g} | r^t|| }fd|D}|r>t|5t ||d|dd| dddn #1swxYwYt!||t#|dS)uTransition ``running|ready -> done`` and record ``result``. Accepts a task that is 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 do not 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. ``created_cards`` is an optional list of task ids the completing worker claims to have created. Each id is verified against ``tasks.created_by``. If any id is phantom (does not exist or was not created by this worker's assignee profile), completion is blocked with a ``HallucinatedCardsError`` and a ``completion_blocked_hallucination`` event is emitted so the rejected attempt is auditable. When all ids verify, they are recorded on the ``completed`` event payload. After a successful completion, ``summary`` and ``result`` are scanned for prose references like ``t_deadbeefcafe`` that do not resolve. Any suspected phantom references are recorded as a ``suspected_hallucinated_references`` event. This pass is advisory and never blocks. completion_blocked_hallucinationr'rN) phantom_cardsverified_cardssummary_previewa 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') a 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') AND current_run_id = ? rF completedr )rrrrrrr) result_lenrr rrrc6g|]}|tv|Sr5r)rvrr s r"rz!complete_task.. s+PPPa1Cw>(>f>*g##*#6F! F")!4gg&GR AKSZ%%''2244Q7==QS )/6#f+++Q!)T# #   A2@ . / ';     C C C C C C C C C C C C C C C Pw&78899I24CC QPPP<PPP  4  '#F(4"6"                4)))D 4s? AB((B,/B,AG*2B,G**G.1G. I//I36I3)rrc 2||n|}t|5|d|f}|r |ddkr ddddS|d||f|d|f}|rt|dnd}|t ||d || }nF|d ||f|,|d t j|d |f|r4|dddnd} t||dddg|dgngz|rt|nd| pdd|dddn #1swxYwYdS)z?Backfill the user-visible result for an already completed task.Nrrr Fz(UPDATE tasks SET result = ? WHERE id = ?z SELECT id FROM task_runs WHERE task_id = ? AND outcome = 'completed' ORDER BY COALESCE(ended_at, started_at, 0) DESC, id DESC LIMIT 1 rr rz-UPDATE task_runs SET summary = ? WHERE id = ?z.UPDATE task_runs SET metadata = ? WHERE id = ?rrrr'editedrrr)fieldsrrrT) r)rr(rrrrrrrcra) rrrrrhandoff_summaryrrunrrs r"edit_completed_task_resultr") s{")!4gg&O 45 5 ll 3gZ  (**  c(mv-- 5 5 5 5 5 5 5 5 6 W    ll J    (** $'0SYD >*g#'! FF LL? &)   # DZu===vF  'O ! ! # # . . 0 0 3DSD 9 9$&   '8y)'/'; ||E.4:c&kkk%-    U5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 l 4s9F D$F  FF)rrct|5||d|f}n%|d|t|f}|jdkr ddddSt ||dd|}||rt ||d|}t ||dd |i|  dddd S#1swxYwYdS) z"Transition ``running -> blocked``.Na6 UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires= NULL, worker_pid = NULL WHERE id = ? AND status IN ('running', 'ready') a` UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires= NULL, worker_pid = NULL WHERE id = ? AND status IN ('running', 'ready') AND current_run_id = ? rFrrrr)rrrrT)r)rrr,rrrc)rrrrr2rs r" block_taskr%l sr 4,,  ",,   CC,, #o../  C <1  ;,,,,,,,,< 'i    >f>*g!F dGY60B6RRRRY,,,,,,,,,,,,,,,,,,sA B8)AB88B<?B<c 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'rau 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)rrr)rr(r,rc)rrrhrr2s r" unblock_taskr( sl dikk  C 4 R J   (**   U+,  LLc% 01223   ll 2 J   <1  /0 dG[$7773sBC?CC#&C#)rrrc |#|stdt|5|d|f}| ddddSdg}g}g}|q||dpdkrQ|d|||d|O|pd|d pdkr?|d |||d |||d d |d t|} | jdkr ddddS|ry|rw|rc|d||dd |zdzttj ft||d|rd|inddddn #1swxYwYt|dS)u&Flesh out a triage task and promote it to ``todo``. Atomically updates ``title`` / ``body`` (when provided) and transitions ``status: triage -> todo`` in a single write txn. Returns False when the task is missing or not in the ``triage`` column — callers should surface that as "nothing to specify" rather than an error. ``todo`` (not ``ready``) is the correct landing column: ``recompute_ready`` promotes parent-free / parent-done todos to ``ready`` on the next dispatcher tick, which keeps the normal parent-gating behaviour intact for specified tasks that happen to have open parents. ``author`` is recorded on an audit comment only when at least one of ``title`` / ``body`` actually changed — avoids noisy comment spam for status-only promotions. Nztitle cannot be blankz@SELECT title, body FROM tasks WHERE id = ? AND status = 'triage'Fzstatus = 'todo'rr'z title = ?rzbody = ?zUPDATE tasks SET rSz# WHERE id = ? AND status = 'triage'rruSpecified — updated z and promoted to todo. specifiedchanged_fieldsT) rr r)rr(rr{r^r,rrrcr) rrrrrrsetsrr+r2s r"specify_triage_taskr- s0 0111 41 1 << N J   (**    1 1 1 1 1 1 1 1 --$&  8G3D3J!K!K KK $ $ $ MM%++-- ( ( (  ! !' * * *  &1A1GR H H KK # # # MM$     ! !& ) ) ) gll 2 $ 2 2 2 &MM   <1  31 1 1 1 1 1 1 1 4  f   LL&LLNN,ii//0./ $$        2@ J ~ . .d    Y1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 nD 4s-I/D&I"BIIIct|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'rFrz#task archived with run still activer$rrT)r)rr,rrc)rrr2rs r" archive_taskr/ s  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|jd t|j}|s t d|jd|jd |dd|S|d kr|jstj d z |jz St|j}|s t d|jd |jd|St d|)uResolve (and create if needed) the workspace for a task. - ``scratch``: a fresh dir under ``/workspaces//``, where ```` is the active board's root. The path is the same for the dispatcher and every profile worker, so handoff is path-stable. - ``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 kanban-root-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 absoluterTrKrz- 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: ) rrrr- is_absoluter rrjrPcwd)r0rYrrs r"resolve_workspacer59 sG(   +)D y   7T())4466A==??  QDGQQ*QQQ   e,,,tw6A t,,, u}}" NNNN  $ % % 0 0 2 2}} OOO&OOO  t,,, z" 78:: ,tw6 6 $ % % 0 0 2 2}} AAA&AAA  666 7 77r$rR Path | strct|5|dt||fddddS#1swxYwYdS)Nz0UPDATE tasks SET workspace_path = ? WHERE id = ?)r)rr)rrrRs r"set_workspace_pathr8y s 4   > YY                      s&AA Ari ceZdZUdZdZded<dZded<eeZ ded< eeZ d ed < eeZ d ed < eeZ d ed < eeZ d ed < eeZd ed<dS)DispatchResultz&Outcome of a single ``dispatch`` pass.rrrr$)default_factoryzlist[tuple[str, str, str]]spawnedroskipped_unassignedskipped_nonspawnablecrashed auto_blocked timed_outN)rrrrrrr$rrr<r=r>r?r@rAr5r$r"r:r: s00IH*/%*E*E*EGEEEEB$)E$$?$?$?????L&+eD&A&A&AAAAAJ t444G4444B#eD999L9999E 5666I6666BBr$r:iXz'dict[int, tuple[int, float]]'_recent_worker_exitsrm raw_statuscn|r|dkrdStj}t||ftt|<tttdzkrM|t z fdtDD]}t|dtttkrdttd}|dt|dzD]"\}}t|d!dSdS)zRecord a reaped child's exit status for later classification. Called from the reap loop in ``dispatch_once``. Safe to call many times; duplicate pids overwrite (pids can cycle, latest wins). rNrc,g|]\}\}}|k|Sr5r5)rvr_stcutoffs r"rz'_record_worker_exit.. s&TTT:1gr1VQr$c|ddS)Nrr5)kvs r"rz%_record_worker_exit.. sbeAhr$r) rrrBra_RECENT_WORKER_EXITS_MAX_RECENT_WORKER_EXIT_TTL_SECONDSitemsrr)rmrCrh_pidrryrHs @r"_record_worker_exitrO s; #(( )++C&)*oos%;S"   #;q#@@@66TTTT)=)C)C)E)ETTT 1 1D $ $T4 0 0 0 0   #;;;-3355;N;NOOO2W!223 1 1GD! $ $T4 0 0 0 0 <; 1 1r$'tuple[str, Optional[int]]'cFtt|}|dS|\}} tj|r tj|}|dkrdSd|fStj|rdtj|fSn#t$rYnwxYwdS)uClassify a recently-reaped worker by pid. Returns ``(kind, code)`` where ``kind`` is one of: * ``"clean_exit"`` — ``WIFEXITED`` with ``WEXITSTATUS == 0``. When the task is still ``running`` in the DB, this is a protocol violation (worker exited without calling ``kanban_complete`` / ``kanban_block``) and should be auto-blocked immediately — retrying will just loop. * ``"nonzero_exit"`` — ``WIFEXITED`` with non-zero status. Real error. * ``"signaled"`` — ``WIFSIGNALED`` (OOM killer, SIGKILL, etc). Real crash. * ``"unknown"`` — pid was not in the reap registry (either reaped by something else, or died between reap tick and liveness check). Fall back to existing crashed-counter behavior. ``code`` is the exit status (for ``clean_exit`` / ``nonzero_exit``) or the signal number (for ``signaled``), or ``None`` for ``unknown``. N)rANr) clean_exitr nonzero_exitsignaled) rBr,rr* WIFEXITED WEXITSTATUS WIFSIGNALEDWTERMSIGr)rmentryrrycodes r"_classify_worker_exitr[ s$ ! $ $SXX . .E }  FC  <   *>#&&Dqyy(("D) ) >#   2 C 0 01 1 2       s.B"B&)B BBc |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$rYnwxYwtjdkr tjddddtt|gtjtjdd d}|jdkrdSd |jpdvrdSn"#t tjt,f$rYnwxYwdS)ugReturn 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:** ``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 peek at ``/proc//status`` and treat ``State: Z`` as dead. On macOS we ask ``ps`` for the BSD ``stat`` field and treat values containing ``Z`` as dead. rFkillTlinuxz/proc/z/statusrYzState:ZrBrNdarwinpsz-ozstat=-p)stdoutstderrrr checkr')hasattrr*r]rProcessLookupErrorPermissionErrorrBsysplatformopen startswithr}rW subprocessr!rPIPEDEVNULL returncodercrSubprocessError TimeoutError)rmrFlineprocs r" _pid_aliveru s" #((u  2v   ! GCHHa uu tt uu |w 0s3xx000#66 !Dx00$**S!"4"4Q"777#(                          "?G<    D    ! ! >tWdCCMM:!!) D!##ut{(b//1111u23\B    D  4sx7A A* A* A*)A*>!D9C4 D%C4( D4C88D;C8<DDD.AF(F((GGrdict[str, Any]cddl}|rt|ndddddd}|r|dks|s|Stdddd}t ||s|Sd|d<||n"t td r tjnd}||Sd|d < |t||j n#ttf$r|cYSwxYwtd D].}t|s d|d <|cStjd /t|r> |t||jd|d<n#ttf$r|cYSwxYwt| |d <|S)z * * *"DOO"G,   KKK (__,D Ks$/CC$#C$5#EE/.E/)noterrc ttj}t|5||d||f}n&|d||t|f}|jdkr ddddS|t|nt ||}||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). NzJUPDATE tasks SET last_heartbeat_at = ? WHERE id = ? AND status = 'running'zaUPDATE tasks SET last_heartbeat_at = ? WHERE id = ? AND status = 'running' AND current_run_id = ?rFz7UPDATE task_runs SET last_heartbeat_at = ? WHERE id = ? heartbeatrrT)rrr)rr,rrc)rrrrrhr2rs r"heartbeat_workerrk s" dikk  C 4   ",,6gCC ,,Mgs?334C <1          "*   w//    LLIf      ';" ,VTNN    3               < 4sAC, AC,,C03C0cddl}g}ttj}tdddd}|d}|D]Y}|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|jdkr@t/|| dt| dt|d ddd d | | d[|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. rNrBra\SELECT t.id, t.worker_pid, COALESCE(r.started_at, t.started_at) AS active_started_at, t.max_runtime_seconds, t.claim_lock FROM tasks t LEFT JOIN task_runs r ON r.id = t.current_run_id WHERE t.status = 'running' AND t.max_runtime_seconds IS NOT NULL AND COALESCE(r.started_at, t.started_at) IS NOT NULL AND t.worker_pid IS NOT NULLrr'active_started_atrrrFr]rr}TzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, last_heartbeat_at = NULL WHERE id = ? AND status = 'running')rmelapsed_seconds limit_secondsr|rAzelapsed z s > limit r!rr)rmr|)rr release_claimend_runevent_payload_extra)r~rrrGr}rr*rlrfr*r]rrgrBr_rurrr)r,rrcr_record_task_failure)rrr~rArhrrlrrelapsedrmtidkilledr]ryr2rrs r"enforce_max_runtimer s"MMMI dikk  C ]]((a003666K << )  hjj KK< &B{++  C 34555 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 & & & & & & & & & & & & & & &< <1   c[W[[SAV=W9X9X[[[##,/F$C$C      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)r)rrr,)rrrr2s r"set_max_runtimer s 4  ll C$0S\\\dG D                 <1 s*AA  A c xg}g}t|5|d}tdddd}|D]i}|dpd}||s#t |dr9t|d}t|\}} |dkrd } d } d } ||d| d } nEd } |dkr d|d| } n|dkr d|d| } nd|d} d} ||dd} | |dkr || d<| | d<|d|df}|j dkrt||ddd| t| }t||d| | || |d| |d||d| | fk dddn #1swxYwYg}|D]=\}}}} } t||| d| rdndd d ||d}|r| |>|t_|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). When the reap registry shows the worker exited cleanly (rc=0) but the task was still ``running`` in the DB, treat it as a protocol violation (worker answered conversationally without calling ``kanban_complete`` / ``kanban_block``) and trip the circuit breaker on the first occurrence — retrying a worker whose CLI keeps returning 0 without a terminal transition just loops forever. z`SELECT id, worker_pid, claim_lock FROM tasks WHERE status = 'running' AND worker_pid IS NOT NULLrBrrrr'rrRTucworker exited cleanly (rc=0) without calling kanban_complete or kanban_block — protocol violationprotocol_violation)rmr exit_codeFrSzpid z exited with code rTz killed by signal z not aliver?)rmrNrA exit_kindrzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND status = 'running'rrr)rr failure_limitrrr)r)rr*rGr}rlrurr[r,rrrcrrdetect_crashed_workers_last_auto_blocked)rr? crash_detailsrlrrrrmrrZr error_text event_kind event_payloadr2rr@rrtrippeds r"rr s&G <>M 4DD|| B   (** %,,S!44Q7::: > > C|$*D??;// #l+,, c,'((C.s33JD$|## &*"M2 "<0!%!! &+">))!E!E!Et!E!EJJZ''!E!E!Et!E!EJJ!7!7!7!7J& (+L8I J J # (9(915M+.15M+.,,6T C |q  !#d)%i$!-00  #d)Z!! s4y)))$$YS%6'5w>  DDDDDDDDDDDDDDD^!L=J % %9S'-z& # 2<11(+ @ @     %    $ $ $ 1=- NsGG!!G%(G%)rrrrrrrrc |t}d}t|5|d|f} |  ddddSt | ddz} | d} d| vr| dnd} | t | } d}nt |} d }| | kr|r"|d | |dd |fn!|d | |dd |fd}|r"t ||d d |dd | || |d}| | ||dd |d}|r||t||d ||d}n|r"|d| |dd |fn!|d| |dd |f|r>t |||||dd d| i}t||||dd | d|dddn #1swxYwY|S)u=Record a non-success outcome (spawn_failed / crashed / timed_out) and maybe trip the circuit breaker. Unified replacement for the old spawn-only ``_record_spawn_failure``. Every path that ends a task with a non-success outcome funnels through here so the ``consecutive_failures`` counter and the auto-block threshold stay consistent. Returns True when the task was auto-blocked (counter reached ``failure_limit``), False when it was just updated in place. Modes: * ``release_claim=True, end_run=True`` — spawn-failure path. Caller has a running task with an open run; this transitions it back to ``ready`` (or ``blocked`` when the breaker trips), releases the claim, and closes the run with ``outcome=``. * ``release_claim=False, end_run=False`` — timeout/crash path. Caller has ALREADY flipped the task to ``ready`` and closed the run with the appropriate outcome. This just increments the counter; if the breaker trips, the task is re-transitioned ``ready → blocked`` and a ``gave_up`` event is emitted. ``event_payload_extra`` merges into the ``gave_up`` event payload when the breaker trips, so callers can include outcome-specific context (e.g. pid on crash, elapsed on timeout). Resolution order for the effective threshold: 1. per-task ``max_retries`` if set (nothing else overrides) 2. caller-supplied ``failure_limit`` (gateway passes the config value from ``kanban.failure_limit``; tests pass fixed values) 3. ``DEFAULT_FAILURE_LIMIT`` NFzHSELECT consecutive_failures, status, max_retries FROM tasks WHERE id = ?rrrrr0 dispatcherzUPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, consecutive_failures = ?, last_failure_error = ? WHERE id = ? AND status IN ('running', 'ready')izUPDATE tasks SET status = 'blocked', consecutive_failures = ?, last_failure_error = ? WHERE id = ? AND status IN ('ready', 'running')r')failurestrigger_outcomeeffective_limit limit_sourcer)rrrrrrTzUPDATE tasks SET status = 'ready', claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, consecutive_failures = ?, last_failure_error = ? WHERE id = ? AND status = 'running'zNUPDATE tasks SET consecutive_failures = ?, last_failure_error = ? WHERE id = ?r)rr) DEFAULT_FAILURE_LIMITr)rr(rrrrrc)rrrrrrrrrrr cur_status task_overriderrrrs r"rr sZ- G 4eell &(/z   (**  ; eeeeeeees1233a7] #0388::"="=C  4   $!-00O!LL!-00O'L  & &  FuTcT{G4  FuTcT{G4  F !'%i+$,+2+:(4    %#2 ,tt#* G# 42333 gy'&    GG  :uTcT{G4  :uTcT{G4  !'#G+((3  '7#DSDkx@@!CeeeeeeeeeeeeeeeN Ns-G:FG::G>G>rc .t|||d|ddS)N spawn_failedT)rrrr)r)rrrrs r"_record_spawn_failurer7 s.  gu#    r$c Tt|5|dt||ft||}|%|dt||ft ||ddt|i|ddddS#1swxYwYdS)zRecord the spawned child's pid + emit a ``spawned`` event. The event's payload carries the pid so a human reading ``hermes kanban tail`` can correlate log lines with OS-level traces without opening the drawer. z,UPDATE tasks SET worker_pid = ? WHERE id = ?Nz0UPDATE task_runs SET worker_pid = ? WHERE id = ?r<rmr)r)rrrrc)rrrmrs r"_set_worker_pidrG s 4 R R : XXw    !w//   LLBS6"    dGYC0A&QQQQ R R R R R R R R R R R R R R R R R RsBBB!$B!ct|5|d|fddddS#1swxYwYdS)uReset the unified consecutive-failures counter. Called from ``complete_task`` on successful completion — a fresh success means the task + profile combination is working and any past failures are history. NOT called on spawn success anymore: a successful spawn proves the worker could start but says nothing about whether the run will succeed, so we need to let timeouts and crashes accumulate across spawn boundaries. zQUPDATE tasks SET consecutive_failures = 0, last_failure_error = NULL WHERE id = ?N)r)r)rrs r"rr\ s 4    5 J                     s 599c|d}|sdS ddlm}n#t$rYdSwxYw|D]}||drdSdS)uReturn True iff there is at least one ready+assigned+unclaimed task whose assignee maps to a real Hermes profile. Used by the gateway- and CLI-embedded dispatchers' health telemetry to decide whether ``0 spawned`` is a "stuck" condition (real spawnable work waiting) or a "correctly idle" condition (only control-plane lanes like ``orion-cc`` / ``orion-research`` waiting on terminals that pull tasks via ``claim_task`` directly). Falls back to "any ready+assigned" if ``profile_exists`` is not importable (e.g. partial install) — preserves the old behavior so the warning still fires in degraded environments. znSELECT DISTINCT assignee FROM tasks WHERE status = 'ready' AND assignee IS NOT NULL AND claim_lock IS NULLFrprofile_existsTr)rr*rKrr)rrlrrs r"has_spawnable_readyrr s << %  hjj  u6666666 tt >#j/ * * 44  5s4 AA)spawn_fnrdry_run max_spawnrrYrrc  tjdtj\}}n#t$rYnwxYw|dkrnt ||Ln#t $rYnwxYwt } t|| _t|| _ ttdg} | r| j | t|| _t!|| _|d} d} | D]} | | |krn| ds!| j| d7 dd lm}n#t $rd}YnwxYw|2|| ds!| j| d|r*| j| d| dd ft5|| d| }| t7|| }nT#t $rG}t9||jd ||}|r| j |jYd}~+d}~wwxYwt=||jt?|||nt@} ddl!} |"|}d|j#vr||t?|| }n||t?|}n0#tHtJf$r||t?|}YnwxYw|r#tM||jtO|| j|j|j(pd t?|f| dz } M#t $rQ}t9||jt?||}|r| j |jYd}~d}~wwxYw| S)uRun one dispatcher tick. Steps: 1. Reclaim stale running tasks (TTL expired). 2. Reclaim crashed running tasks (host-local PID no longer alive). 3. Promote todo -> ready where all parents are done. 4. For each ready task with an assignee, atomically claim and call ``spawn_fn(task, workspace_path, board) -> 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. ``board`` pins workspace/log/db resolution for this tick to a specific board. When omitted, the current-board resolution chain is used. TrrzsSELECT id, assignee FROM tasks WHERE status = 'ready' AND claim_lock IS NULL ORDER BY priority DESC, created_at ASCNrrrr')rrz workspace: rrYr))r*waitpidWNOHANGChildProcessErrorrOrr:rrrr?getattrr@rrrArr$rr*r=rrKrr>r<rr5rrr8r_default_spawninspect signature parameters TypeErrorr rrr)rrrrrrrYrN_statusr_crash_auto_blocked ready_rowsr<rrr workspaceexcauto_spawnrsigrms r" dispatch_oncer sV   /  " 2rz : : gg$    qyy g . . . /        F+D11F+D11FN" 4b8""#6777*400F%d++FO 1hjj  GN7N7  W %9%9 E:   % , ,SY 7 7 7  " : : : : : : : " " "!NNN "  %nnS_.M.M %  ' . .s4y 9 9 9    N ! !3t9c*or"B C C C T3t9+FFF ?  )'???II   (gj"5"5"5+D 7#**7:666 HHHH  4S^^<<<%1~ 7 NNN 6''//cn,, &#i..FFFCC &#i..99Cz* 6 6 6fWc)nn55 6 <gj#c((;;; N ! !7:w/?/E2s9~~"V W W W qLGG 7 7 7(gj#c((+D 7#**7:666  7 MsA"'A 4A4A AAE E)(E)(G:: I >Olog_path max_bytescl |sdS|j|krdS||jdz} |r|n#t $rYnwxYw||dS#t $rYdSwxYw)uRotate ```` 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)r?statst_size with_suffixrrVrBr)rrrotateds r"_rotate_worker_logr/s      F ==?? "i / / F&&x'=>> ~~ !       D           s?B%B%B%(A>=B%> B B% B  B%% B32B3rc nddl}|jstd|jdddlm}||j}d|j}t tj}|j r |j |d<|j|d<||d <|j t|j |d <|j r |j |d <tt| |d <tt| |d<t|p t!}||d<||d<dd|ddg} |jr)|jD]!} | r| dkr| d| g"| dd|gt'| } | dd| |jdz } t+| t,t/| d} |j| tj|r|nd|j| |j|d}n1#t:$r$| t?dwxYw|j S)a|Fire-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. ``board`` pins the child's kanban context to that board: the child's ``HERMES_KANBAN_DB`` / ``HERMES_KANBAN_BOARD`` / workspaces_root env vars all resolve to the same board the dispatcher claimed the task from. Workers cannot accidentally see other boards. rNr2z has no assigneerIzwork kanban task HERMES_TENANTHERMES_KANBAN_TASKHERMES_KANBAN_WORKSPACEHERMES_KANBAN_RUN_IDHERMES_KANBAN_CLAIM_LOCKrrcrhr;HERMES_PROFILEhermesrbz--skillsz kanban-workerchatz-qTrK.logab)r4stdinrcrdrDstart_new_sessionzv`hermes` executable not found on PATH. Install Hermes Agent or activate its venv before running the kanban dispatcher.)!rmrr rrKrJrr*r+rrrrrfrjr#rHrrrmrPrDEFAULT_LOG_ROTATE_BYTESrkPopenrRisdirroSTDOUTrWclosererm)r0rrYrmrJ profile_argpromptrDresolved_boardcmdsklog_dirrlog_frts r"rrFs$ =<::::;;;::::::((77K * * *F rz  C {+#{O $C%.C!" &&)$*=&>&> "# :*./ &'".u"="="=>>C+.U/K/K/K+L+LC'(+511H5F5H5HN!/C (C  k O C( {-+ - -B -bO++ J+,,,JJ fE***G MM$M...DG))))Hx!9::: 4 E z W]]955? 4$$"         ^     8Os ._handlesr$)SIGINTr)rr)r )r~ threadingrcurrent_thread main_threadrr rBis_setrrrrr traceback print_excwait) rrrrrr~rrsig_namerrresrs ` r" run_daemonrs3MMM__&&  !!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. rr!rr{rrrc|sdS|}t||kr|S|d|dt||z dzS)z;Truncate a string to `limit` chars with a visible ellipsis.r'Nu… [truncated, z chars omitted])rra)r!r{s r"_capz"build_worker_context.._capsY 2 GGII q66U??H%yMc!ffunMMMMMr$z# Kanban task z: r'z Assignee: z (unassigned)z Status: z Tenant: z Workspace: z @ z (unresolved)z## Bodyc g|] }|j | Srt)rrXs r"rz(build_worker_context..3sOOOq 8N8N8N8Nr$Nrrz## Prior attempts on this taskz_(z earlier attemptz omitted; showing most recent z)_z%Y-%m-%d %H:%Mz (unknown)z ### Attempt u — z (rSrUz _error_: FT)r sort_keysz _metadata_: ``rcg|] }|d Srr5rXs r"rz(build_worker_context..]s666Q!K.666r$r c(g|]}|jdk |S)r )rrXs r"rz(build_worker_context..es$PPP!qyK7O7OA7O7O7Or$c|jSrt)r)rYs r"rz&build_worker_context..fsALr$)rreversez## 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 @rrr z (no summary)z- rrz): z## Comment threadz earlier commentz**z** (z):rN)r!rr{rrr),rzr _CTX_MAX_FIELD_BYTESrrrrrrrrrr_CTX_MAX_BODY_BYTES list_runsra_CTX_MAX_PRIOR_ATTEMPTS enumeraterstrftime localtimerrrrrrrrrrr*sortrrrrr_CTX_MAX_COMMENTSrr_CTX_MAX_COMMENT_BYTESr{rstrip)rrr0rlines all_prioromittedshownfirst_shown_idxoffsetr!idxrrrmeta_str parent_rowsr wrote_headerrmptruns body_lines role_rowsrr!first all_comments omitted_cshown_ccs r"build_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 Uci}|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 statusnrSELECT assignee, status, COUNT(*) AS n FROM tasks WHERE status != 'archived' AND assignee IS NOT NULL GROUP BY assignee, statusrz>SELECT MIN(created_at) AS ts FROM tasks WHERE status = 'ready'rN) by_status by_assigneeoldest_ready_age_secondsrh)rr setdefaultr(r)rr/rr0 oldest_rowrholdest_ready_ages r" board_statsr5s0!#I|| 511$'s3x== #h-  -/K|| $SS FIS]] s:33CMBBHhjj dikk  C  A$T*6 s:d#$$ $ $<@ "$4   r$c@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)rrrrr)r0rhage_since_createdage_since_startedtime_to_completes r"task_ager=s dikk  C6:oOc$/22224&*o?c$/""""4   'D T_%G!H!HHH"& 10$4  r$) thread_iduser_idrjchat_idr>r?c 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 (?, ?, ?, ?, ?, ?) r'N)rrr)r)rrrjr@r>r?rhs r"add_notify_subrBs dikk  C 4     hb'3 G                      sAA #A c|*|d|f}n'|d}d|DS)Nz2SELECT * FROM kanban_notify_subs WHERE task_id = ?z SELECT * FROM kanban_notify_subsc,g|]}t|Sr5)rrXs r"rz$list_notify_subs..s " " "DGG " " "r$rrs r"list_notify_subsrEsf|| @7*  (** ||>??HHJJ " "T " " ""r$)r>ct|5|d||||pdf}dddn #1swxYwY|jdkS)NzcDELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = ? AND chat_id = ? AND thread_id = ?r'r)r)rr,)rrrjr@r>r2s r"remove_notify_subrGs 4  ll A hb 9                 kindsrHtuple[int, list[Event]]c`|d||||pdf}|dgfSt|d}|rt|nd}d|r+ddd t |zzd zndzd z} ||g} |r| ||| | } g} |} | D]} |d rtj |d nd}n#t$rd}YnwxYw| t|d |d|d||dd| vr|dt|dndt| t|d } | | fS)aReturn ``(new_cursor, events)`` for a given subscription. Only events with ``id > 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 = ?r'Nr last_event_idz7SELECT * FROM task_events WHERE task_id = ? AND id > ? z AND kind IN (rRrTz) zORDER BY id ASCrrrrrrr)rr(rrr{rarr*rrrrrrmax)rrrjr@r>rHrcursor kind_listqrrlrmax_idrYrs r"unseen_events_for_subrQ%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 = ?r')r)rr)rrrjr@r>rRs r"advance_notify_cursorrTVs 4    S __gx)/r J                     s+AA A i')older_than_secondsrUc 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)rrr)rr,)rrUrHr2s r" gc_eventsrWks  $6 7 7 7F 4  ll J I                 s| q ! !!sA$$A(+A()rUrYcft|}|sdStj|z }d}|D]]} |r6|j|kr||dz }N#t$rYZwxYw|S)uHDelete 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. Scoped to ``board`` (defaults to the active board) — per-board isolation means deleting logs from board A cannot touch board B's logs.rrr) rmr?rris_filerst_mtimerVrB)rUrYrrHremovedrs r"gc_worker_logsr\|sE***G >>  q Y[[- -FG __   yy{{ qvvxx0699 1     H  NsA B!! B.-B.c.t||dz S)uRReturn the path to a worker's log file. The file may not exist (task never spawned, or log already GC'd). When ``board`` is None, resolves via the active board (env var → current-board file → default). The dispatcher always passes the board explicitly to avoid any resolution ambiguity when multiple boards exist.rr)rm)rrYs r"worker_log_pathr^s#  ' ' 'W*:*:*: ::r$) tail_bytesrYr_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).rNr<r|)r>errorsrb )ra) r^r?r@rrrkseektellreadlineendswithreaddecoderB) rr_rYrRsizerFprobepartialdatas r"read_worker_logrnsz 7% 0 0 0D ;;==t  >>79>EE Eyy{{" $   j  tj())) **,,''.."16688t3C3CFF5MMM6688D               {{79{555 tts<D6)D6+BD D6DD6DD66 EEc ddlm}|}|dz }n#t$rgcYSwxYwt}|r|d|r| t|D]H}|s|dz r||j In#t$rYnwxYwt|S)aReturn the set of assignee/profile names discovered on disk. Includes: - named profiles under ``/profiles//config.yaml`` - the implicit ``default`` profile when the default Hermes root exists Reads profile paths directly so this module has no import dependency on ``hermes_cli.profiles`` (which pulls in a large chunk of the CLI startup path). rr(profilesrz config.yaml) r.r)rrr?rr`rrrYrrB)r) default_root profiles_dirnamesrYs r"list_profiles_on_diskrts:<<<<<<..00 #j0  eeE )  4 4 6 677 * *||~~M)2244*IIej)))  *     D  %==s ''6A*C!! C.-C.c`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-rrcHg|]}||v|idS))ron_diskcounts)r,)rvrrxrws r"rz#known_assignees..sM     wjjr**     r$)rrtrrr2rr)rrrsrxrws @@r"known_assigneesrys'))**G)+F|| $NN ADCH #j/2..s8}== 7S/// 0 0E          r$)include_activerz 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|Sr5)rrrXs r"rzlist_runs.."s" * * *CLLOO * * *r$r)rrrzrOrrls r"rrsa 4A F ) (( ++A <<6 " " + + - -D * *T * * **r$ Optional[Run]c|dt|f}|rt|ndS)Nz$SELECT * FROM task_runs WHERE id = ?)rrr(rr)rrrs r"get_runr%sL ,,.V  hjj!$ -3<<   -r$c|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 1Nrr(rrrys r" active_runr,sK ,, +    hjj  !$ -3<<   -r$c|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 1Nrrys r" latest_runr6sK ,, 4    hjj  !$ -3<<   -r$cl|d|f}|r|dndS)ubReturn the latest non-null ``task_runs.summary`` for ``task_id``. The kanban-worker skill writes its handoff to ``task_runs.summary`` via ``complete_task(summary=...)``; ``tasks.result`` is left empty unless the caller passes ``result=`` explicitly. Dashboards and CLI "show" views need this value to surface what a worker actually did — without it, ``tasks.result`` is NULL and the task looks like a no-op even when the run completed. Picks the most recent run by ``ended_at`` (falling back to ``id`` for ties or unfinished rows). Returns None if no run has a summary. zSELECT summary FROM task_runs WHERE task_id = ? AND summary IS NOT NULL AND summary != '' ORDER BY COALESCE(ended_at, started_at) DESC, id DESC LIMIT 1rN)rr(rys r"latest_summaryr@sG ,, H     hjj  ! *3y>>d*r$task_idsdict[str, str]ct|}|siSdd|D}|d|d|}d|DS)uBatch-fetch latest non-null summaries for a list of task ids. Used by the dashboard board endpoint to attach ``latest_summary`` to every card in a single SQL query, avoiding the N+1 pattern of calling :func:`latest_summary` per task. Returns a dict mapping ``task_id`` → summary string, omitting tasks with no summary. Approach: a window function picks the newest non-null-summary row per ``task_id``; works against SQLite ≥ 3.25 (default on every supported platform). rRc3K|]}dVdS)rTNr5)rvrys r"rxz#latest_summaries..gs"--AC------r$aD SELECT task_id, summary FROM ( SELECT task_id, summary, ROW_NUMBER() OVER ( PARTITION BY task_id ORDER BY COALESCE(ended_at, started_at) DESC, id DESC ) AS rn FROM task_runs WHERE task_id IN (zZ) AND summary IS NOT NULL AND summary != '' ) WHERE rn = 1 c,i|]}|d|dS)rrr5rXs r"rz$latest_summaries..ws" 5 5 51AiL!I, 5 5 5r$)rr{rr*)rridsrvrls r"latest_summariesrVs x..C  88-------L << !-    hjj  6 5 5 5 55r$)rrrr)rr)rr)rrrr)rrTrt)rYrrr)rYrrr])rrrr)rYrrr)rYrrrrrrrrrrrrr) rrrrrrrrrrrr)rr]rr)rrrr]rr)rr rYrrr )rr rYrrr)rr rrT)rr )rrrr) rr rrrrrrrrrrrrrrrrrLrMr r]rrrrrrNrrrr)rr rLrMrro)rr rrrrw)rr rrrrrrrr]r{rrr|)rr rrrrrr])rr rrrrrrT)rr rrrrrr])rr rrrro)rr rrrr) rr rrrrrrrr)rr rrrr)rr rrrr) rr rrrrrrrrrrT)rr rrrrrrrrrrrrrr)rr rrrr)rr rrrrrrrrrrrr)rr rr) rr rrrrrrrrw) rr rrrrrrrr])rr rrrrrr]) rr rrrrrr]rrrr])rr rrrrMrr)rr rrrro)rr rrrrrrrrrrNrrrr]) rr rrrrrrrrrr]) rr rrrrrrrr])rr rrrr]) rr rrrrrrrrrr])r0rrYrrr)rr rrrRr6rrT)rmrrCrrrT)rmrrrP)rmrrr])rmrrrrrv) rr rrrrrrrr])rr rro)rr rrrrrr])rr rrrrrrrrrr]rr]rrrr]) rr rrrrrrrr])rr rrrmrrrT)rr rrrrT)rr rr])rr rrrr]rrrrrYrrr:)rrrrrrT)r0rrrrYrrr)rrrrrrrrT)rr rrrr)rr rr)r0rrr)rr rrrjrr@rr>rr?rrrT)rr rrrr) rr rrrjrr@rr>rrr])rr rrrjrr@rr>rrHrNrrI)rr rrrjrr@rr>rrRrrrT)rr rUrrr)rUrrYrrr)rrrYrrr)rrr_rrYrrr)rro)rr rr)rr rrrzr]rr{)rr rrrr~)rr rrrr~)rr rrrr)rr rrMrr)r __future__rrrr*rer=rrmrir dataclassesrrpathlibrtypingrrr rr]DEFAULT_CLAIM_TTL_SECONDSrrr rrrCcompilerr#r0r6r9rHrSrXr\rArfrjrmrpr~rrrrrrrrrrrrrrrrcontextmanagerr)r?rGrLrnr`rzrrrrrrrrrrrrcrrrrrrrrrrrrr rrr"r%r(r-r/r5r8rDEFAULT_SPAWN_FAILURE_LIMITrr:rLrKrBrOr[rurrrrrrrrr_clear_spawn_failuresrrrrrr+r5r=rBrErGrQrTrWr\r^rnrtryrrrrrrr5r$r"rsGDDDL#"""""  ((((((((**********WVV666 $""" :;;     %%%%.////0000$$$$N"           4 4 4 4 4)))))2*****, $ $ $ $ $ *****eeeeH!%#&&&&&&X!% :-1))))))X04'E'E'E'E'E'E\ r r r r r r r  r j 2 2 2 2 2 2 2  2 j   !!!!!!! !@ N #suu$$$$#* ******\# :X X X X v * ' ' ' '####,,,," $#$( %))-&*!%!o&o&o&o&o&o&d 4 4 4 4////#  ",,,,,,>J    <.     ****)))) 2 2 2 2&'''',"8#  ! :"# 666666rQQQQ"#0#0#0#0#0#0#nJ1! V'V'V'V'V'V'z1! D,,,,,,f! BBBBBBT  >HHHH\BJ4554444B     Z   ,!!#-1%)ccccccV"# @@@@@@N!%) 444444n$$$$V  RRRRRRj4=A=8=8=8=8=8=8@    $3+ CCCCCCC CB#&7999991111.    F>>>>J 222222r%) 000000lllllll^    ||||J*.WWWWWWB       RRRR*    &/F0#4ZZZZZZz    6 ssssssx#4  4*4*4*4*4*4*vu,u,u,u,x!!!!H8 $!      08< # # # # #$ $ . $%)......n $       ,