@r1z4x/tezgah 1.7.0 → 1.8.2

package/hooks/tezgah_integrity.py

@@ -484,7 +484,8 @@ PERMANENT_ERROR = re.compile(
 # `turn` row carries when a host hands the refusal back as a prompt (plan 083).
 # `open`, `ready` and `blocked` are a `todo` row's counts of the host's todo list
 # (`note_todo`), and `heads` the list of its ready items' heads, each redacted:
-# `detail` holds the same heads, one per line, under the row's cut.
+# `detail` holds the same heads, one per line, under the row's cut. `taken` is
+# the in-progress items' heads, and `partial` marks a Cursor `merge: true` list.
 # `residual` is a `subagent_end` row's count of residual items no blocker type
 # accounts for (`unblocked_items`): the parent's Stop owes them (S4 finding 2).
 # `questions` and `defaults` are an `ask` row's counts (`note_ask`): the
@@ -501,7 +502,7 @@ LEDGER_FIELDS = frozenset(("id", "exit", "out_bytes", "fail_class", "workspace",
                            "check", "key", "block", "repo", "empty_run", "cause",
                            "host", "switches", "harness", "authorized", "inflight",
                            "reask", "open", "ready", "blocked", "heads", "residual",
-                           "questions", "defaults"))
+                           "questions", "defaults", "taken", "partial"))
 
 # The row contract's own version, stamped by the writer beside `kind` and `ts` so
 # it is not a caller field. It exists because a row is read back to decide a
@@ -3279,15 +3280,16 @@ TODO_HEAD = 60
 def note_todo(session_id, tool, inp, snapshot=None, cwd=None, agent=None):
     """Write one `todo` row for a todo call: the `open`, `ready` and `blocked`
     counts, every ready item's head in `heads` (redacted, TODO_HEAD characters
-    each) and the same heads in `detail`, one per line, which the row's cut may
-    shorten. A call whose list is not in hand (an omp `todo` result without
-    its `details`) writes nothing, so it cannot read as an empty queue. An item
-    whose own text types a blocker (KARAR, YETKİ, GERİ ALINAMAZ, ORTAM, or
-    `blocked`) counts as blocked: Claude's and Codex's lists have no blocked
-    status. `agent` is the host's subagent id: a subagent's list is its own,
-    and the readers skip it. ponytail: a Cursor `merge: true` call carries
-    only the items it changes and is recorded as the whole list, so its counts
-    can run low."""
+    each), every in-progress item's head in `taken`, and the ready heads in
+    `detail`, one per line, which the row's cut may shorten. A call whose list
+    is not in hand (an omp `todo` result without its `details`) writes nothing,
+    so it cannot read as an empty queue. An item whose own text types a blocker
+    (KARAR, YETKİ, GERİ ALINAMAZ, ORTAM, or `blocked`) counts as blocked:
+    Claude's and Codex's lists have no blocked status. `agent` is the host's
+    subagent id: a subagent's list is its own, and the readers skip it. A
+    Cursor `merge: true` call carries only the items it changes: its row is
+    marked `partial`, which the `open todo` class skips. ponytail: the counts
+    of a partial row can still run low for `ready steps`."""
     raw = snapshot if snapshot is not None else inp.get("todos", inp.get("plan"))
     if not isinstance(raw, list):
         return
@@ -3299,12 +3301,18 @@ def note_todo(session_id, tool, inp, snapshot=None, cwd=None, agent=None):
     blocked = [text for text, status in items if status == "blocked" or
                BLOCKER_SAID.search(text) or BLOCKER_TRIED.search(text)
                or re.search(r"\bblocked\b", text, re.I)]
-    heads = [_stored_text(" ".join(text.split()))[:TODO_HEAD] for text, status in items
+
+    def head(text):
+        return _stored_text(" ".join(text.split()))[:TODO_HEAD]
+    heads = [head(text) for text, status in items
              if status == "pending" and text not in blocked]
+    taken = [head(text) for text, status in items
+             if status != "pending" and text not in blocked]
     note(session_id, "todo", "\n".join(heads),
          id=call_id(tool, inp), tool=str(tool or "").strip() or None,
          workspace=root_for(cwd) if cwd else None, agent=agent or None,
-         open=len(items), ready=len(heads), blocked=len(blocked), heads=heads)
+         open=len(items), ready=len(heads), blocked=len(blocked), heads=heads,
+         taken=taken, partial=True if snapshot is None and inp.get("merge") else None)
 
 
 def note_tool(session_id, tool, inp, failed=None, *, interrupted=False,
@@ -5550,6 +5558,16 @@ READY_STEPS = (
     "or named in the reply on one line with its {DECISION}, {ACCESS}, {IRREVERSIBLE} "
     "or {ENV}. End the turn only when no step is ready.")
 
+# The `open todo` class (plan 097): the reply claims done while the newest todo
+# list still holds an in-progress item, not blocked (`open_left`). Filled with
+# the count and up to three heads.
+OPEN_TODO = (
+    "The reply claims done, but the newest todo list still holds %d item(s) in "
+    "progress: %s. Finish them and mark them done in the todo list, or say "
+    "plainly which are left and why - each on one line with its {DECISION}, "
+    "{ACCESS}, {IRREVERSIBLE} or {ENV}, or marked blocked in the todo list "
+    "with its reason.")
+
 
 def _tr_lower(text):
     """`text` lowercased the Turkish way (I -> ı, İ -> i): `str.lower` reads
@@ -6019,7 +6037,7 @@ def _residual_block(text, rows, shape, verdict=(None, None), session_id=None,
     the `needless ask` class when `needless_ask` names the question the reply
     ends on (any turn, worked or not: the plan proposal that ends "Başlayayım
     mı?" is its measured case); else the `ready steps` class when `ready_left`
-    names one; else the
+    names one; else the `open todo` class when `open_left` names one; else the
     `stopped slice` class when `_stopped_slice` finds one; else `verdict`. Not
     asked for a subagent's end (`shape` false) or a nested session: both
     replies are read by code, not by the user (`_shape_block`). Residual work
@@ -6053,10 +6071,15 @@ def _residual_block(text, rows, shape, verdict=(None, None), session_id=None,
     asked = needless_ask(text, lambda: grants_in_force(session_id))
     if asked:
         return ("needless ask", NEEDLESS_ASK % cut(asked, 80))
-    ready = ready_left(text, rows, session_id, cwd)
+    todo = _turn_todo(rows, session_id)
+    ready = _ready_in(text, todo, session_id, cwd)
     if ready:
         return ("ready steps", READY_STEPS % (
             len(ready), "; ".join(cut(head, 48) for head in ready[:3])))
+    taken = open_left(text, todo, session_id, cwd)
+    if taken:
+        return ("open todo", OPEN_TODO % (
+            len(taken), "; ".join(cut(head, 48) for head in taken[:3])))
     stopped = _stopped_slice(session_id, cwd)
     if not stopped:
         return verdict
@@ -6067,15 +6090,21 @@ def _residual_block(text, rows, shape, verdict=(None, None), session_id=None,
 
 def ready_heads(row, session_id, cwd):
     """A `todo` row's ready heads (`note_todo`), less each one an open slice of
-    this session is working on: the slice id appears in the head, or the whole
-    head in the slice's own task (`task`, without an omp batch's shared
-    context), each as a word-bounded match of two characters or more,
-    case-insensitive. omp's `todo start` sets every other `in_progress` item
-    back to `pending`, so a dispatched item reads as ready in the list while
-    its slice runs. ponytail: a record written before `task` existed falls
-    back to its brief's last paragraph. Read from `tezgah_task.pending`, off
-    under `slices-off`, and fail open to the row's own heads."""
-    heads = [str(h) for h in row.get("heads") or () if str(h).strip()]
+    this session is working on (`_not_running`). omp's `todo start` sets every
+    other `in_progress` item back to `pending`, so a dispatched item reads as
+    ready in the list while its slice runs."""
+    return _not_running([str(h) for h in row.get("heads") or () if str(h).strip()],
+                        session_id, cwd)
+
+
+def _not_running(heads, session_id, cwd):
+    """`heads` less each one an open slice of this session is working on: the
+    slice id appears in the head, or the whole head in the slice's own task
+    (`task`, without an omp batch's shared context), each as a word-bounded
+    match of two characters or more, case-insensitive. ponytail: a record
+    written before `task` existed falls back to its brief's last paragraph.
+    Read from `tezgah_task.pending`, off under `slices-off`, and fail open to
+    `heads`."""
     if not (heads and session_id and cwd) or off("slices-off"):
         return heads
     try:
@@ -6104,17 +6133,15 @@ def newest_todo(rows):
     return next((r for r in rows if r.get("kind") == "todo" and not r.get("agent")), None)
 
 
-def ready_left(text, rows, session_id, cwd=None):
-    """The heads of the ready steps the reply leaves: the newest `todo` row's
-    ready items (`ready_heads`), less each one a line of the reply names (its
-    first 24 characters, inline code kept) beside a KARAR, YETKİ, GERİ ALINAMAZ
-    or ORTAM token outside code. Asked like `residual work`: in a turn that
-    did work, of a ledger with a turn marker, off under `orchestrate-off`. The
-    row may come from an earlier turn: an unfinished step carries over. It is
-    found by its serialized shape and only the lines back to the newest
-    parent `todo` row are parsed, so the Stop path still parses the turn and
-    not the session (StopReadBound). A done item is gone from the list, so it
-    never needs the reply."""
+def _turn_todo(rows, session_id):
+    """The newest parent `todo` row the Stop path judges, else a falsy value
+    (`[]` on the gated exits, the neuter matrix's anchors). Asked like
+    `residual work`: in a turn that did work, of a ledger with a turn marker,
+    off under `orchestrate-off`. The row may come from an earlier turn: an
+    unfinished step carries over. It is found by its serialized shape and only
+    the lines back to the newest parent `todo` row are parsed, so the Stop path
+    still parses the turn and not the session (StopReadBound). Read once for
+    both todo classes."""
     if not session_id or off("orchestrate-off"):
         return []
     if not any(str(r.get("kind")) in STEP_KINDS for r in rows):
@@ -6122,14 +6149,54 @@ def ready_left(text, rows, session_id, cwd=None):
     lines = _ledger_lines(_path(session_id))
     if not _turn_count(lines):
         return []
-    row = newest_todo(r for line in reversed(lines) if TODO_ROW.search(line)
-                      for r in _parse([line]))
-    if not row or not row.get("ready"):
-        return []
+    return newest_todo(r for line in reversed(lines) if TODO_ROW.search(line)
+                       for r in _parse([line]))
+
+
+def _untyped(text, heads):
+    """`heads` less each one a line of the reply names (its first 24
+    characters, inline code kept) beside a KARAR, YETKİ, GERİ ALINAMAZ or ORTAM
+    token outside code."""
     typed = [_tr_lower(" ".join(line.split())) for line in str(text or "").splitlines()
              if BLOCKER_SAID.search(_prose(line)) or BLOCKER_TRIED.search(_prose(line))]
-    return [h for h in ready_heads(row, session_id, cwd)
-            if not any(_tr_lower(h)[:24] in line for line in typed)]
+    return [h for h in heads if not any(_tr_lower(h)[:24] in line for line in typed)]
+
+
+def _ready_in(text, row, session_id, cwd=None):
+    """`ready_left` over a row already read (`_turn_todo`)."""
+    if not row or not row.get("ready"):
+        return []
+    return _untyped(text, ready_heads(row, session_id, cwd))
+
+
+def ready_left(text, rows, session_id, cwd=None):
+    """The heads of the ready steps the reply leaves: the newest `todo` row's
+    (`_turn_todo`) ready items (`ready_heads`), less each one the reply types
+    with its blocker (`_untyped`). A done item is gone from the list, so it
+    never needs the reply."""
+    return _ready_in(text, _turn_todo(rows, session_id), session_id, cwd)
+
+
+def open_left(text, row, session_id=None, cwd=None):
+    """The heads of the in-progress items a done claim leaves (the `open todo`
+    class): the row's `open - blocked - ready` count, named by its `taken`
+    heads, when the reply claims done (`asserted_claims`). A blocked item is
+    not counted, an in-progress one a running slice of this session works on
+    (`_not_running`: Claude's TodoWrite has no blocked status, so a dispatched
+    step reads in_progress) is not either, and one the reply types with its
+    blocker (`_untyped`) passes. A `partial` row (Cursor `merge: true`) holds
+    only the changed items, so it is not judged. ponytail: a row written before
+    `taken` existed is named by its count alone."""
+    if not row or row.get("partial"):
+        return []
+    left = (int(row.get("open") or 0) - int(row.get("blocked") or 0)
+            - int(row.get("ready") or 0))
+    if left <= 0 or not asserted_claims(text)[0]:
+        return []
+    heads = [str(h) for h in row.get("taken") or () if str(h).strip()]
+    if not heads:
+        return ["%d in-progress item(s)" % left]
+    return _untyped(text, _not_running(heads, session_id, cwd))
 
 
 def _settle_slices(cwd):

package/hooks/tezgah_models.py

@@ -1185,40 +1185,84 @@ def _in_order(routes, kids):
     return [stem for _ts, stem in kids]
 
 
-def _join(routes, kids, spawned_as):
-    """[child stem or None] per route. A child's type is what its parent's task
-    call recorded for its name (`spawn` rows, omp), else its own `agent` (the
-    type itself on opencode). With every child typed, each route agent's routes
-    join that agent's children by `_in_order`, and a child of an unrouted type
-    is left out; with any child untyped, order over all of them is the only
-    evidence. Whatever is not proven stays None (`unjoined`)."""
-    typed = [(ts, stem, spawned_as.get(agent, agent)) for ts, stem, agent in kids]
-    if any(kind is None for _ts, _stem, kind in typed):
-        stems = _in_order(routes, [(ts, stem) for ts, stem, _k in typed])
-        return stems or [None] * len(routes)
-    out = [None] * len(routes)
+# How far apart, in seconds, two children of one task call start: an omp call
+# of 11 workers opened their ledgers over 2 seconds (ledger 01a12277). A second
+# task call within that gap would read as part of the first - ponytail: a model
+# turn between two calls takes longer than this.
+FAN_OUT_GAP = 2
+
+# How long after its route a route's first worker may start: tezgah-route runs
+# right before the task call. The joined omp routes (ledgers 01a12277, 01a12bf1)
+# started theirs 39 to 1296 s later; 1296 s is a route made beside another and
+# run after it finished. Past this a same-type child proves nothing.
+ROUTE_GAP = 1800
+
+
+def _fan_out(kids):
+    """The children of the first task call in sorted [(ts, key)]: each started
+    within FAN_OUT_GAP of the one before."""
+    out = kids[:1]
+    for kid in kids[1:]:
+        if kid[0] - out[-1][0] > FAN_OUT_GAP:
+            break
+        out.append(kid)
+    return out
+
+
+def _join(routes, kids):
+    """[[child key]] per route, [] where unjoined; `kids` is [(ts, key, type)],
+    type None when no row typed the child.
+
+    With no child typed, order over all of them is the only evidence
+    (`_in_order`). Otherwise each route agent's routes join that agent's
+    children: a route owns the first fan-out of its type after it and before
+    the next route of its type - later same-type spawns are ones no route sent.
+    It owns nothing when the route before it of its type had no worker yet
+    (both routes' workers may be in this one fan-out), when the fan-out started
+    more than ROUTE_GAP after it, or when an untyped child started inside its
+    span (that child could be its worker). A child of an
+    unrouted type is left out. Whatever is not proven stays unjoined."""
+    if kids and all(kind is None for _ts, _key, kind in kids):
+        keys = _in_order(routes, [(ts, key) for ts, key, _k in kids])
+        return [[key] for key in keys] if keys else [[] for _r in routes]
+    out = [[] for _r in routes]
+    untyped = [ts for ts, _key, kind in kids if kind is None]
     for agent in {fields.get("agent") for _ts, fields in routes}:
         mine = [i for i, (_ts, fields) in enumerate(routes) if fields.get("agent") == agent]
-        stems = _in_order([routes[i] for i in mine],
-                          [(ts, stem) for ts, stem, kind in typed if kind == agent])
-        for i, stem in zip(mine, stems or []):
-            out[i] = stem
+        theirs = sorted((ts, key) for ts, key, kind in kids if kind == agent)
+        for n, i in enumerate(mine):
+            start = routes[i][0]
+            end = routes[mine[n + 1]][0] if n + 1 < len(mine) else float("inf")
+            if n and not any(routes[mine[n - 1]][0] <= ts < start for ts, _key in theirs):
+                continue
+            batch = _fan_out([kid for kid in theirs if start <= kid[0] < end])
+            if batch and batch[0][0] - start <= ROUTE_GAP \
+                    and not any(start <= ts <= batch[-1][0] for ts in untyped):
+                out[i] = [key for _ts, key in batch]
     return out
 
 
+# A fan-out's outcome is its most telling first check: one failed worker fails
+# the route, so a fan-out never hides a failure behind a sibling's pass.
+OUTCOME_ORDER = ("fail", "pass", "ran", "none")
+
+
 def route_report(ledgers):
     """({(via, tier): counts}, counts for Jev routes below the static tier) over
     {ledger stem: rows}.
 
-    A routed worker runs in its own session, so its checks are in its own ledger,
-    whose `spawned` row names the parent session the route row was written under.
-    A route joins the child `_join` can prove is its worker, and the outcome is
-    that child's first check (`pass`, `fail`, `ran`, `none`). A route it cannot
-    prove - an unrouted spawn, a tie, a host that writes no `spawned` row - is
-    `unjoined`: the parent's own next check is never taken for the worker's, and
-    neither is a guess. The second count is the V2-as-default question: Jev
-    picking under the static table's tier, and how often that first attempt
-    failed (docs/models.md)."""
+    A routed worker on omp and opencode runs in its own session, so its checks
+    are in its own ledger, whose `spawned` row names the parent session the
+    route row was written under. On Claude and Codex it runs under its parent's
+    session id: its rows are in the parent's ledger with `agent` = its id, and
+    the `subagent_start` row (SubagentStart's agent_id, agent_type in `detail`)
+    types it. A route joins the children `_join` can prove are its workers, and
+    the outcome is their first check (`pass`, `fail`, `ran`, `none`; over a
+    fan-out, OUTCOME_ORDER's first). A route it cannot prove - an unrouted
+    spawn, a tie, a host that writes no child row - is `unjoined`: the parent's
+    own next check is never taken for the worker's, and neither is a guess. The
+    second count is the V2-as-default question: Jev picking under the static
+    table's tier, and how often that first attempt failed (docs/models.md)."""
     def counts():
         return {"routes": 0, "pass": 0, "fail": 0, "ran": 0, "none": 0, "unjoined": 0}
     def spawn_rows(rows):
@@ -1228,7 +1272,11 @@ def route_report(ledgers):
     for stem, rows in ledgers.items():
         link = next((r for r in rows if r.get("kind") == "spawned" and r.get("parent")),
                     None)
-        if link:
+        # Cursor's row is written from the parent's subagentStart under the
+        # child's `subagent_id`; that the child's own calls carry this id is not
+        # documented, so the link counts only once a row of the child's landed
+        if link and not (link.get("host") == "cursor"
+                         and all(r.get("kind") == "spawned" for r in rows)):
             children.setdefault(ti._slug(link["parent"]), []).append(
                 (link.get("ts") or 0, stem, link.get("agent")))
     groups, below = {}, counts()
@@ -1240,15 +1288,27 @@ def route_report(ledgers):
         # orchestrator shares the parent's TEZGAH_SESSION, so its worker names
         # that parent while the row typing the worker is in the orchestrator's
         # ledger. Another session's task names never type this one's children.
-        # A name two calls typed differently is untyped (None): order decides.
+        # A name two calls typed differently is untyped (None).
         spawned_as = {}
         for r in spawn_rows(rows) + [r for _ts, kid, _a in children.get(stem, [])
                                      for r in spawn_rows(ledgers[kid])]:
             if spawned_as.setdefault(r["child"], r["agent"]) != r["agent"]:
                 spawned_as[r["child"]] = None
-        for (_ts, fields), kid in zip(routes, _join(routes, children.get(stem, []),
-                                                    spawned_as)):
-            outcome = _outcome(ledgers[kid]) if kid else "unjoined"
+        # a child key is (ledger stem, agent id): "" for a whole ledger; an
+        # empty type (a Cursor subagentStart with no subagent_type) is no type
+        kids = [(ts, (kid, ""), spawned_as.get(name, name) or None)
+                for ts, kid, name in children.get(stem, [])]
+        # a Claude plugin agent's type is plugin-scoped (`tezgah:tezgah-cheap`)
+        kids += [(r.get("ts") or 0, (stem, r["agent"]),
+                  str(r.get("detail") or "").rsplit(":", 1)[-1] or None)
+                 for r in rows if r.get("kind") == "subagent_start"
+                 and isinstance(r.get("agent"), str) and r["agent"]]
+        for (_ts, fields), keys in zip(routes, _join(routes, kids)):
+            got = {_outcome(ledgers[kid] if not agent else
+                            [r for r in ledgers[kid] if r.get("agent") == agent
+                             and r.get("kind") != "subagent_start"])
+                   for kid, agent in keys}
+            outcome = next((o for o in OUTCOME_ORDER if o in got), "unjoined")
             bins = [groups.setdefault((fields["via"], fields["tier"]), counts())]
             static = fields.get("static")
             if fields["via"] == "jev" and static in TIERS and \

package/hooks/tezgah_paths.py

@@ -255,14 +255,15 @@ def root_for(path):
 
 
 def _toplevel(real):
-    """The nearest directory at or above `real` holding a `.git` entry, else None."""
+    """The nearest directory at or above `real` holding a `.git` entry, else
+    None - the project for a path inside its `.tezgah` (`project_top`)."""
     cur = real
     while not os.path.lexists(os.path.join(cur, ".git")):
         parent = os.path.dirname(cur)
         if parent == cur:
             return None
         cur = parent
-    return cur
+    return project_top(cur)
 
 
 def linked_main(path):
@@ -990,6 +991,26 @@ def workspace(repo):
     return os.path.join(repo, WORKSPACE)
 
 
+def project_top(path):
+    """`path`, or the project owning the workspace when the nearest `.git` at or
+    above `path` is a `.tezgah`'s own repository.
+
+    git and the `.git` walk both answer the workspace for a path inside it, and a
+    caller that joins `.tezgah` to that answer or sets the project up there wrote
+    `<x>/.tezgah/.tezgah/plans/README.md`, `.tezgah/.cursor` and `.tezgah/.codegraph`.
+    A repository cloned inside the workspace answers for itself. Every resolver
+    (`_toplevel`, the hooks' and CLIs' `repo_root`) passes its answer through here."""
+    cur = path
+    while not os.path.lexists(os.path.join(cur, ".git")):
+        parent = os.path.dirname(cur)
+        if parent == cur:
+            return path
+        cur = parent
+    if os.path.basename(cur) == WORKSPACE:
+        return project_top(os.path.dirname(cur))
+    return path
+
+
 # The workspace paths whose text is injected as a standing constraint: each is
 # checked for a symlink, because a clone can carry one pointing into its own tree.
 WORKSPACE_INJECTED = (".tezgah", os.path.join(".tezgah", "lessons.md"),
@@ -1345,15 +1366,32 @@ def seed_identity(repo, ws=None):
         pass
 
 
+# What git says when another git process holds the private repository's index
+# or a ref: every worktree commits into the main checkout's one `.tezgah/.git`,
+# so two closes or a close and a research commit collide (plan 097: 10 of 19
+# concurrent rounds).
+_GIT_LOCKED = (".lock': File exists", "cannot lock ref")
+# The waits between tries, ~1.5 s in all: a commit there takes milliseconds,
+# and a lock still held after it is a crashed git, which the caller reports.
+_LOCK_WAITS = (0.1, 0.2, 0.4, 0.8)
+
+
 def ws_git(repo, *args, **kw):
     """`git -C <repo>/.tezgah <args>` with tezgah's commit identity, as a
-    CompletedProcess (text, captured unless `kw` says otherwise). Raises OSError
-    when git is not installed, like subprocess.run."""
+    CompletedProcess (text, captured unless `kw` says otherwise), tried again
+    while another git holds a lock there (`_GIT_LOCKED`). Raises OSError when
+    git is not installed, like subprocess.run."""
     import subprocess  # deferred: see ensure_workspace
+    import time
     kw.setdefault("capture_output", True)
     kw.setdefault("text", True)
-    return subprocess.run(["git", "-C", workspace(repo)] + list(WS_IDENTITY)
-                          + list(args), **kw)
+    cmd = ["git", "-C", workspace(repo)] + list(WS_IDENTITY) + list(args)
+    for wait in _LOCK_WAITS + (None,):
+        done = subprocess.run(cmd, **kw)
+        err = done.stderr if isinstance(done.stderr, str) else ""
+        if not done.returncode or wait is None or not any(s in err for s in _GIT_LOCKED):
+            return done
+        time.sleep(wait)
 
 
 def guarded_opener(drop_auth=False):

package/hooks/tezgah_policy.py

@@ -397,9 +397,9 @@ Routing: `{ROUTE_BIN} "<brief>"` names the worker - tezgah-cheap, -standard or
 -frontier, or the specialist whose whole job the brief is (tezgah-tester,
 -docs, -security, -ui, -researcher, -reviewer) - and the spawn uses that name,
 never the host's generic task agent (overrides for stored data, credentials,
-security first; then a Jev judgement; the static phase table with no key). A worker that answers
-`ESCALATE:` is restarted on tezgah-frontier with the original brief, never
-continued; the main thread never switches model (the cache is per model). A
+security first; then a Jev judgement; the static phase table with no key). A report missing an output field, or an
+`ESCALATE:`, gets one narrower re-brief of the same role naming that field or judgement; only a second miss is
+restarted on tezgah-frontier with the original brief, never continued; the main thread never switches model (the cache is per model). A
 code-discovery brief names codegraph's tools (`codegraph callers`, `callees`,
 `impact`, `node`, `files`, `codegraph_explore`) and says "answer from
 the graph, grep only for literal text"; never a grep-only explorer (observed).

package/hooks/tezgah_research.py

@@ -3550,10 +3550,13 @@ def _check_review_integrity(base, errors, warnings, strict):
                       % (" and ".join(high), len(order), order[0][:80]))
 
 
-def check_line(repo, slug, git=True, strict=False):
+def check_line(repo, slug, git=True, strict=False, code=None):
     """(errors, warnings) for one research line. `git=False` skips the checks that
     need git history, for callers that must stay cheap (the session context).
-    `strict=True` turns every guarantee the checker cannot decide into an error."""
+    `strict=True` turns every guarantee the checker cannot decide into an error.
+    `code` is the checkout the check runs in when it is not `repo`: the line
+    lives in the main checkout's workspace (plan 097) and its citations and
+    proofs resolve against the checkout whose branch holds the code."""
     base = line_dir(repo, slug)
     errors, warnings = [], []
     if not os.path.isdir(base):
@@ -3566,7 +3569,8 @@ def check_line(repo, slug, git=True, strict=False):
             errors.append("%s is missing" % name)
     _check_state(base, errors, warnings, strict)
     _check_findings(base, errors, warnings, strict)
-    _check_claims(base, errors, warnings, roots=(repo,), strict=strict)
+    _check_claims(base, errors, warnings, roots=(repo, code) if code and code != repo
+                  else (repo,), strict=strict)
     _check_predictions(repo, base, errors, warnings, strict, git)
     seal_errors, intact = _check_seal(base)
     errors.extend(seal_errors)
@@ -3685,7 +3689,7 @@ def _check_derived_phase(base, phase, direction, warnings):
                         "stopped describing the line" % (direction, derived, want))
 
 
-def check(repo, slug=None, git=True, strict=False, all_lines=True):
+def check(repo, slug=None, git=True, strict=False, all_lines=True, code=None):
     """{slug: {"errors": [...], "warnings": [...]}} for one line or every line.
 
     With `all_lines=False` and no slug, a line under `done/` is read by its order
@@ -3699,7 +3703,7 @@ def check(repo, slug=None, git=True, strict=False, all_lines=True):
             if errors:
                 out[name] = {"errors": errors, "warnings": []}
             continue
-        errors, warnings = check_line(repo, name, git=git, strict=strict)
+        errors, warnings = check_line(repo, name, git=git, strict=strict, code=code)
         out[name] = {"errors": errors, "warnings": warnings}
     return out