@r1z4x/tezgah 1.9.2 → 1.13.0

package/hooks/tezgah_context.py

@@ -20,20 +20,19 @@ import tezgah_research
 import tezgah_store
 from tezgah_guard import import_crash_key
 from tezgah_integrity import (GRANT_KIND, STEP_KINDS, _heredocs, _path as _ledger_path,
-                              _shell_segments, bind_session,
+                              _shell_commands, bind_session,
                               changed_files, cut, last_check, note,
                               note_compaction, note_turn, outward_classes, redact,
                               scratch_evidence, UNTRUSTED_CHANNEL)
 from tezgah_lessons import (lesson_key, lines as lesson_lines,
                             tainted as tainted_lessons)
-from tezgah_policy import (CONDITIONAL_KEYS, CORE, FANOUT_ACTION, POINTERS,
+from tezgah_policy import (ARMED_ACTIONS, BIN_TOOLS, CONDITIONAL_KEYS, CORE, POINTERS,
                            PROMPT_REMINDER, REPLY_ANY, open_lines_note,
                            pony_level_line)
 from tezgah_paths import (CACHE, CONTEXT_NUDGE_TOKENS, REPO_MARKS, SWITCHES,
                           ai_research_dir, alts, armed,
                           cache_dir, codegraph_bin, consult_options,
                           ensure_workspace, fallback_cache, have_judge_key, language,
-                          link_workspace,
                           off, orx_bin, packs, pony_level, project_top, root_for,
                           roots, say, tool,
                           work_tree, workspace, workspace_from_repo, worktrees,
@@ -146,7 +145,8 @@ def _fanout():
 
 
 PROMPT_HINTS = tuple((key, _hints(key)) for key in
-                     ("spec", "consult", "research", "product", "graph")) + (
+                     ("spec", "consult", "research", "product", "design",
+                      "graph")) + (
     ("fanout", _fanout()),)
 
 # the detached auto-index worker (lock-guarded, retrying); same dir as this file
@@ -174,12 +174,23 @@ CORE_RULES = (
     ("research", "**Research: route it to OpenResearch.**"),
     ("product", "**Product analysis: five axes, one evidence class per "
                 "finding.**"),
+    ("design", "**Design: UI work reads the design skills.**"),
     ("attribution", "**No AI attribution, ever, on any host.**"),
     ("lang", "**Identifiers and messages stay English.**"),
     ("workspace", "**Workspace: `.tezgah/` only.**"),
     ("fanout", "**Parallel by default: fan out independent items.**"),
 )
 
+# The shipped skill an armed rule leads with: the skill hint when the section
+# search gave no line (`tezgah_skill_pick.rule_hint`, which still asks the
+# skill to carry 3 of the prompt's words). S4Remeasure p08: the Research
+# paragraph names orx's manual, Claude's roster lists `tezgah:research` by name
+# only, and the skill holding the line's protocol was never opened. Product
+# and design are not here: their paragraphs already name a skill per ask, and
+# a lead skill hinted for them was wrong on 3 of 3 S2/S3 prompts it reached
+# (no-ai-slop, feature-audit and analyze-app asks) and right on none.
+RULE_SKILL = {"research": "research"}
+
 # The per-turn reminder's clause for each switchable rule, matched against
 # PROMPT_REMINDER with its whitespace collapsed. A kill switch drops its clause
 # here as it drops its paragraph from CORE; a test pins every clause to the
@@ -234,10 +245,9 @@ def render(text, root=""):
         words.update(REPLY_ANY)
     for key, word in words.items():
         text = text.replace("{%s}" % key.upper(), word)
-    return (text.replace("{CONSULT_BIN}", tool("consult"))
-                .replace("{CODEGEN_BIN}", tool("codegen"))
-                .replace("{ORX_BIN}", orx_bin() or "orx")
-                .replace("{RESEARCH_BIN}", tool("tezgah-research")).replace("{ROUTE_BIN}", tool("tezgah-route"))
+    for placeholder, name in BIN_TOOLS.items():
+        text = text.replace(placeholder, tool(name))
+    return (text.replace("{ORX_BIN}", orx_bin() or "orx")
                 .replace("{AI_RESEARCH_DIR}", ai_research_dir())
                 .replace("{PONY_LEVEL}", _pony_level_line())
                 .replace("{ROOT}", root or ACTIVE_ROOT[0]
@@ -406,6 +416,53 @@ def slug(path):
     return re.sub(r"[^A-Za-z0-9]+", "-", path).strip("-")
 
 
+def seed_index(root):
+    """Copy the main checkout's codegraph index into a linked worktree that has
+    none (plan 118), so the worker below runs the incremental `sync` on it, not a
+    full `init`. Returns the main checkout seeded from, else None.
+
+    The database stores repo-relative paths only, so a copy is a sound start for
+    the worktree's own index (spike: sync 1 s against init 10 s on this repo).
+    sqlite's backup API, not a file copy: main's codegraph may be writing. The
+    copy lands under a temporary name and is linked into place, so a second
+    seeder or a running worker never reads a half-written file. Every failure
+    fails open to today's `init`."""
+    import shutil
+    import sqlite3
+    import urllib.parse
+    from tezgah_paths import linked_main
+    main = linked_main(root)
+    src = main and os.path.join(main, ".codegraph", "codegraph.db")
+    dst = os.path.join(root, ".codegraph", "codegraph.db")
+    if not src or not os.path.isfile(src) or os.path.lexists(dst):
+        return None
+    tmp = "%s.seed-%d" % (dst, os.getpid())
+    try:
+        os.makedirs(os.path.dirname(dst), exist_ok=True)
+        ignore = os.path.join(main, ".codegraph", ".gitignore")
+        if os.path.isfile(ignore) and not os.path.lexists(
+                os.path.join(root, ".codegraph", ".gitignore")):
+            shutil.copyfile(ignore, os.path.join(root, ".codegraph", ".gitignore"))
+        source = sqlite3.connect("file:%s?mode=ro" % urllib.parse.quote(src), uri=True)
+        try:
+            target = sqlite3.connect(tmp)
+            try:
+                source.backup(target)
+            finally:
+                target.close()
+        finally:
+            source.close()
+        os.link(tmp, dst)   # refuses when another seeder got there first
+        return main
+    except Exception:
+        return None
+    finally:
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+
+
 def autoindex(root):
     """Detached incremental index. Returns a one-line status for the context."""
     if root in roots():
@@ -450,6 +507,7 @@ def autoindex(root):
         except OSError:
             pass
         note = "last auto-index failed (see %s)" % log_path
+    seeded = seed_index(root)
     try:
         log = open(log_path, "ab")
         # Spawn the lock-guarded worker rather than indexing inline. Two sessions
@@ -465,7 +523,8 @@ def autoindex(root):
         )
     except Exception as exc:
         return "auto-index could not start (%s); index this repo from a shell" % exc
-    verb = "re-indexing" if stamped else "indexing (first time)"
+    verb = ("syncing its copy of %s's index" % seeded if seeded
+            else "re-indexing" if stamped else "indexing (first time)")
     if note:
         return "%s; %s in background now" % (note, verb)
     return "%s in background now" % verb
@@ -601,10 +660,11 @@ def task_line(task):
     handing those steps to the user."""
     paths = ", ".join(task.get("allowed_paths") or []) or "any path in the repo"
     return ("Active task %s is in phase `%s`; writes allowed on: %s. Move the "
-            "phase yourself with `tezgah-task phase <next>` when the work reaches "
-            "it, and `tezgah-task close %s done` when it is merged - never hand "
+            "phase yourself with `%s phase <next>` when the work reaches "
+            "it, and `%s close %s done` when it is merged - never hand "
             "these steps to the user." % (task.get("id"), task.get("phase"),
-                                          paths, task.get("id")))
+                                          paths, tool("tezgah-task"),
+                                          tool("tezgah-task"), task.get("id")))
 
 
 # --- the resume block: the live turn state a compact loses -------------------
@@ -636,7 +696,7 @@ RESUME_FILES = 3
 # session_start, every prompt's `slices` part while any is pending.
 SLICE_LINES = 3
 SLICE_CHARS = 160
-SLICES_HEAD = "Slices left stopped or open (the journal, `tezgah-task slice reconcile`):"
+SLICES_HEAD = "Slices left stopped or open (the journal, `{TASK_BIN} slice reconcile`):"
 
 
 def _plan_facts(path):
@@ -842,7 +902,7 @@ def lessons(root):
                for ln in lines[-LESSON_LINES:])
     if late:
         more += ("\n(%d of the lines above do not open with their rule; run "
-                 "`tezgah-lessons` for rewrites)" % late)
+                 "`%s` for rewrites)" % (late, tool("tezgah-lessons")))
     return ("## Lessons from past mistakes in this repo (.tezgah/lessons.md)\n"
             + "\n".join("- " + ln for ln in recent) + more + "\n"
             "These are standing constraints: check the spec and the change "
@@ -964,12 +1024,12 @@ def armed_again(key):
     """The one line a matching prompt pays for a paragraph this session was
     already shown. The research rule keeps its `{OPEN_LINES}` slot: the open
     lines are a fact about the repo now, not rule text the session holds. The
-    fan-out rule keeps its action (`FANOUT_ACTION`): the rule is a thing to do
-    on this turn's list, and a bare reminder that it exists was not done."""
+    fan-out, product and design rules keep their action (`ARMED_ACTIONS`): the
+    rule is a thing to do on this turn's ask, and a bare reminder that it exists
+    was not done."""
     label = dict(CORE_RULES)[key]
-    if key == "fanout":
-        return ("%s Armed again: %s The full rule is in the `tezgah-contract` "
-                "skill." % (label, FANOUT_ACTION))
+    if key in ARMED_ACTIONS:
+        return "%s Armed again: %s" % (label, ARMED_ACTIONS[key])
     return ("%s Armed again: the full rule was given earlier this session and "
             "is in the `tezgah-contract` skill.%s"
             % (label, "{OPEN_LINES}" if key == "research" else ""))
@@ -1106,6 +1166,9 @@ def switches(cwd):
     if off("spec-off"):
         drop.add("spec")
         disabled.append("spec-off")
+    if off("design-off"):
+        drop.add("design")
+        disabled.append("design-off")
     if off("verify-off"):
         drop.add("integrity")
         disabled.append("verify-off")
@@ -1284,20 +1347,32 @@ def session_of(payload):
 # move to 15500 B. Moved again on 2026-10-13 (plan 105): the fidelity rule says
 # a research, analysis, review or plan ask ends at the plan (+105 B of core), and
 # the fixture's subagent brief reached 5500 B exactly, so subagent_start moves to
-# 5800 B. A
+# 5800 B. Moved again on 2026-10-22 (plan 126): every CLI the core names is
+# rendered as its installed path (BIN_TOOLS), since no host but Claude has the
+# tezgah bin dir on PATH, and the worktree fixture's session start then gave up
+# its worktrees line (509 B), so the session budgets move to 16000 B. Moved
+# again on 2026-10-22 (plan 126, second pass): a research ask arms the Research
+# and Product paragraphs (6239 B on Claude, S4Remeasure p08) and the skill hint
+# that names the research skill (about 330 B with its path) was the block given
+# up, so the prompt budget moves to 7000 B. Moved again on 2026-10-28 (plan
+# 136): the subagent pointer says an owner-only question goes back as
+# `ESCALATE: owner` (+330 B), the fixture's subagent_start reached 5958 B and
+# gave up `consult` (205 B), so subagent_start moves to 6100 B. Moved again on
+# 2026-10-29 (plan 142): the output-shape paragraph says what the host's plan
+# mode changes (+168 B), and the worktree fixture's session_start gave up its
+# worktrees line again, so the session budgets move to 16200 B. A
 # budget in bytes, not tokens: this file has no tokenizer and a wrong estimate
 # would be worse than a bound.
-CONTEXT_BUDGET = {"session_start": 15500, "post_compact": 15500,
-                  "subagent_start": 5800, "user_prompt": 6500}
+CONTEXT_BUDGET = {"session_start": 16200, "post_compact": 16200,
+                  "subagent_start": 6100, "user_prompt": 7000}
 DEFAULT_BUDGET = 13000
 # The blocks in the order they are given up when the budget is exceeded, lowest
 # value first: text another surface already carries (the plan table lives in the
 # plan-status skill, the sibling checkouts in `tezgah-research --all`, the
 # lessons file is on disk, the generated-subagent note is a one-time fact); the
-# per-turn skill hint - a suggestion of which skill to read first, never an
-# instruction, so it yields to the relevant lessons after it - and those lessons,
-# which first shrink to their first lesson (SHRINK); only the lessons a turn
-# still shows are marked seen, so a later turn may still carry the rest. Then
+# lessons this prompt is about, which first shrink to their first lesson (SHRINK);
+# only the lessons a turn still shows are marked seen, so a later turn may still
+# carry the rest. Then
 # the tooling-availability lines, then the live state lines - the stale-graph
 # glance, then the resume
 # block, which outlives every status and availability line because it is the only
@@ -1306,17 +1381,19 @@ DEFAULT_BUDGET = 13000
 # journal's stopped or open slices, which outlive the resume block because after
 # an omp `/clear` they are the one pointer left to delegated work in flight - then
 # the scratch-path warning, which is about evidence the turn may already have
-# claimed - then the active task's phase, which outlives both because a phase is what
-# stops a refused write before it happens - then the delta, and the skill pointer
-# last. A key absent from this tuple is never dropped: the always-on core, the
+# claimed - then the per-turn skill hint, which names the skill this ask needs
+# and no other block can work that out (it was the first block given up: 32
+# live drops, plan 126) - then the active task's phase, which outlives the hint
+# because a phase is what stops a refused write before it happens - then the
+# delta, and the skill pointer last. A key absent from this tuple is never dropped: the always-on core, the
 # per-turn reminder and an armed paragraph ARE the rules, and a budget that could
 # spend them would turn bloat into rule loss - which is the failure the budget
 # exists to prevent, not one it may cause.
-DROP_ORDER = ("knowledge", "worktrees", "lessons", "skill", "lessons_turn",
+DROP_ORDER = ("knowledge", "worktrees", "lessons", "lessons_turn",
               "taste", "plans", "subagents", "steer", "orca", "consult", "research",
               "research_broken", "graph", "offnote", "orchestrate",
-              "index", "resume", "slices", "context", "scratch", "task", "delta",
-              "pointer")
+              "index", "resume", "slices", "context", "scratch", "skill", "task",
+              "delta", "pointer")
 
 
 def _first_item(text):
@@ -1449,17 +1526,18 @@ GATE_MIN_CALLS = 3
 # The tool names whose every call leaves a PreToolUse row (`began`,
 # tezgah_gate.decision's write and shell branch) and every refused one a `deny`:
 # Claude's write and shell tools, omp's `bash`/`edit`/`write` and Codex's
-# `exec_command`/`apply_patch`. A
+# `exec_command`/`apply_patch`, Droid's `Execute`/`Create`/`ApplyPatch`. A
 # tool the gate may pass without a row (Read, Grep, Task, WebFetch, an MCP
 # call) is not counted, so its absence from the ledger is never read as a
 # disarmed gate.
 GATED_TOOLS = re.compile(r"(?i)^(?:bash|powershell|pwsh|edit|write|multiedit|"
-                         r"notebookedit|exec_command|shell|apply_patch)$")
+                         r"notebookedit|exec_command|shell|apply_patch|"
+                         r"execute|create|applypatch)$")
 GATE_INACTIVE = (
     "tezgah gate inactive on this host: %d gated tool call(s) since this "
     "session's first turn and not one row from the gate, so the shortcut "
     "denials and the Stop check are not running. Say so before claiming a check "
-    "passed, run `tezgah-setup --report` yourself and quote its MISS rows.")
+    "passed, run `~/.config/tezgah/bin/tezgah-setup --report` yourself and quote its MISS rows.")
 
 
 def _iso_epoch(value):
@@ -1580,7 +1658,8 @@ def context_nudge(payload, session_id):
 # The ledger kinds a hook other than the tool hooks writes: the prompt hook's
 # turn marker, judge row, lesson rows and disarm row, the Stop hook's claim,
 # refusal, after_block and shape rows and the stop_spec rows of plan 063's shadow
-# (old ledgers only), the subagent-end hook's subagent_end row,
+# (old ledgers only), the subagent-end hook's subagent_end row, Droid's Stop
+# `reply_unread` row (a turn end whose reply the transcript did not yield),
 # compaction, the subagent mark and the `subagent_start` lineage row (both from
 # SubagentStart), the omp fork's `forked` row, the guard's crash
 # row (any hook), the damage row any reader writes and the session start's
@@ -1593,7 +1672,7 @@ NOT_TOOL_HOOK = frozenset((b"turn", b"judge", b"claim", b"refusal",
                            b"after_block", b"subagent_end", b"stop_spec",
                            b"shape", b"compact", b"orch", b"crash", b"route",
                            b"spawned", b"forked", b"lesson", b"disarm", b"ledger_damage",
-                           b"attest", b"subagent_start"))
+                           b"attest", b"subagent_start", b"reply_unread"))
 # The rows PostToolUse writes (`note_tool`): they prove the host ran the call,
 # not that the gate saw it - a PostToolUse hook keeps writing them while a
 # broken PreToolUse hook lets every call through - so they are no proof either.
@@ -2100,9 +2179,19 @@ def context_for(event, cwd, payload=None, with_core=True):
         # line at most, each section once per session (`section_hint`).
         if prompt and tezgah_skill_pick:
             hint = tezgah_skill_pick.suggest(prompt, session_id)
+            # the host: omp's bridge and opencode's plugin send it, Claude's
+            # manifest row declares it (`TEZGAH_HOST`, hooks/hooks.json)
+            host = (payload or {}).get("host") if isinstance(payload, dict) else None
+            host = host or os.environ.get("TEZGAH_HOST")
             if not hint:
-                host = (payload or {}).get("host") if isinstance(payload, dict) else None
-                hint = tezgah_skill_pick.section_hint(prompt, session_id, host=host)
+                hint = tezgah_skill_pick.section_hint(prompt, session_id, host=host,
+                                                      cwd=cwd)
+            for k in CONDITIONAL_KEYS:
+                if hint:
+                    break
+                if k in RULE_SKILL and k in conditional and k in matched:
+                    hint = tezgah_skill_pick.rule_hint(RULE_SKILL[k], prompt,
+                                                       session_id, host=host)
             if hint:
                 parts.append(("skill", hint))
         # C1 and C3 ride this turn because it is the only channel a live state
@@ -2150,7 +2239,7 @@ def context_for(event, cwd, payload=None, with_core=True):
         # next turn and this part is the one that names the work left in flight.
         pending = slice_lines(root, session_id)
         if pending:
-            parts.append(("slices", "\n".join([SLICES_HEAD] + pending)))
+            parts.append(("slices", "\n".join([render(SLICES_HEAD)] + pending)))
         # The router's own context: above the threshold, one line asks it to
         # push heavy reading through a slice (orchestrator-flow-audit S2 F1).
         heavy = context_nudge(payload, session_id)
@@ -2260,15 +2349,17 @@ def context_for(event, cwd, payload=None, with_core=True):
                  else steering(root, (payload or {}).get("host")))
         if steer:
             parts.append(("steer", steer))
+    # The workspace every per-project artifact lands in: created, ignored by the
+    # project and given its private git before anything writes there. A root is
+    # not a project, the helper returns None outside a work tree, and a linked
+    # worktree is handed the main checkout's as a link rather than a second store
+    # (plan 121). The session start is not the only event that gets here - a
+    # compaction and a delegated agent's first call do too, and a worktree made
+    # outside tezgah takes the link from whichever comes first. On a made
+    # workspace a second call costs three stats and one file read.
+    if ws not in roots():
+        ensure_workspace(root)
     if event in ("session_start", "post_compact"):
-        # The workspace every per-project artifact lands in: created, ignored by
-        # the project and given its private git before anything writes there.
-        # A root is not a project, and the helper returns None outside a work tree.
-        if ws not in roots():
-            # never link to a `.tezgah` ensure_workspace refused: one the
-            # project tracks or a link the clone placed (review of plan 100)
-            if ensure_workspace(ws) and ws != root:
-                link_workspace(root, ws)
         # The live turn state, first in this region: on a compacted or resumed
         # session it is the one thing the rest of the block cannot re-derive.
         resume = resume_state(root, session_of(payload))
@@ -2367,7 +2458,12 @@ def context_for(event, cwd, payload=None, with_core=True):
                       "(each tagged DERIVED, you concluded it, or RETRIEVED, "
                       "you read it), Evidence (the path:line or command behind "
                       "each), Confidence, Unresolved, Disconfirming, Conflicts. "
-                      "Full rules: the `tezgah-contract` skill."))
+                      "A question only the owner can answer - choosing a variant "
+                      "or option a research, analysis or review recommends; a way "
+                      "around a tezgah refusal; deciding about another session's "
+                      "work (its line, plan or branch) - is never yours: return "
+                      "`ESCALATE: owner` with the options and a recommended "
+                      "default. Full rules: the `tezgah-contract` skill."))
     else:
         parts.append(("pointer", POINTER_LINE))
     text = budgeted(event, [(key, render(text.strip())) for key, text in parts])
@@ -2408,6 +2504,8 @@ _WRAPPER_ARG = frozenset(("timeout",))
 _OPTION_ARG = frozenset(("-u", "-g", "-k", "-o", "-C", "-h", "-T", "-r", "-t",
                          "--user", "--group", "--prompt", "--chdir"))
 _ASSIGNMENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=")
+# the programs that cannot fail, so the `||` arm behind one never runs
+NO_FAIL = frozenset(("true", ":"))
 
 
 def _substitutions(text, start, end):
@@ -2435,7 +2533,10 @@ def shell_programs(command, _depth=0):
     """Every word a shell line would run as a program, in order. A closed
     heredoc body is data: a quoted tag's whole, an unquoted tag's all but its
     `$( )` and backtick substitutions, which bash runs. The deny readers keep an
-    unquoted body visible whole."""
+    unquoted body visible whole. A `||` arm behind a pipeline that cannot fail
+    (`true` or `:` in its last stage, `SKIP=1 true` included) never runs, so its
+    words are dropped until the next `;`, newline, `&` or substitution close
+    (plan 129)."""
     command = str(command or "")
     text = list(command)
     for h in _heredocs(command):
@@ -2448,9 +2549,33 @@ def shell_programs(command, _depth=0):
         for k in range(h[4], h[5][1]):
             if text[k] != "\n" and k not in keep:
                 text[k] = " "
-    out = []
-    for words in _shell_segments("".join(text)):
-        out += _command_words(words, _depth)
+    # `ok` is the whole `&&`/`||` list's failability so far, not one stage's:
+    # `a && b || c` runs `c` when `a` fails, so a `||` arm is dead only when
+    # every link before it cannot fail. A builder (`|`, not `||`) hands the
+    # list its last stage's status, as bash's exit is the pipeline's last.
+    out, alive, safe = [], True, True
+    for words, sep in _shell_commands("".join(text)):
+        if alive:
+            progs = _command_words(words, _depth)
+            out += progs
+        # a pipeline stage's own status is overwritten by the stage after it,
+        # so only the stage that ends the pipeline folds into `safe`; a stage
+        # that was skipped leaves the list's own status standing (a skipped
+        # `&&` arm is why `a && b | true || c` still runs `c` when `a` fails)
+        if "|" in sep and "||" not in sep:
+            continue
+        if alive:
+            # `! cmd` inverts the status, so the arm after a `||` still runs:
+            # a negated command is never "safe" (`! true || p1` runs `p1`)
+            negated = bool(words) and words[0] == "!"
+            safe = safe and not negated and bool(progs) and progs[0] in NO_FAIL
+        # the separator decides the NEXT command, so it is read after this one
+        if "||" in sep:
+            alive, safe = not safe, True
+        elif "&&" in sep:
+            alive = True  # the list may still succeed, so its next link may run
+        elif ";" in sep or "\n" in sep or sep == "&" or sep == "":
+            alive, safe = True, True
     return out
 
 
@@ -2831,7 +2956,7 @@ TOOL_USE_MEASURES = frozenset(("consult", "research", "graph", "orch", "judge"))
 
 
 def health_segments(cwd, session_id=None, used_override=None, idx_override=None,
-                    observable=None):
+                    observable=None, manifest=None):
     """The armed/used checklist as structured segments, host-neutral.
 
     Each segment is {"key", "state", "glyph", "text", "group"}, the version
@@ -2861,7 +2986,13 @@ def health_segments(cwd, session_id=None, used_override=None, idx_override=None,
 
     idx_override: an idx glyph the host already resolved (one of "✓↻✗?–"), for a
     redraw that must not fork git for a cosmetic line - omp re-renders on every
-    turn_end and tool_result. None probes as before; the other marks stay live."""
+    turn_end and tool_result. None probes as before; the other marks stay live.
+
+    manifest: an extension manifest named outright (the renderer's
+    `--manifest`), read instead of the one discovered from `cwd`. Either way
+    the built-in marks stay and the extension's chips follow them - a manifest
+    that declares `statusline.override` owns where the line is drawn, never
+    what it carries."""
     if session_id:
         bind_session(session_id)  # the marks show the switches this session honors
     base, marks = repo_marks(cwd)
@@ -2921,6 +3052,27 @@ def health_segments(cwd, session_id=None, used_override=None, idx_override=None,
         if plan:
             segs.append({"key": "plans", "state": "ready" if "blk" in plan else "info",
                          "glyph": "", "text": plan, "group": 3})
+    # A repository's own statusline extension (tezgah_extension): it produces
+    # structured segments, the line renders them after every built-in mark. Its
+    # own `group` is normalized to one cluster past the built-ins, so the
+    # separator reads the same however the extension numbered it. Imported here,
+    # not at the top: a broken extension module costs its chips, never the line.
+    try:
+        import tezgah_extension
+        ext = tezgah_extension.segments(cwd, session_id=session_id,
+                                        manifest_file=manifest)
+    except Exception:
+        ext = []
+    if ext:
+        next_group = 1 + max((s.get("group", 0) for s in segs), default=-1)
+        for seg in ext:
+            seg["group"] = next_group
+            # The state carries the mark, exactly as it does for a built-in: an
+            # extension that leaves `glyph` out gets the same ✓/○/✗ the core
+            # draws for its own marks, and only names one when it means another.
+            if not seg.get("glyph"):
+                seg["glyph"] = GLYPHS.get(seg.get("state"), "")
+        segs.extend(ext)
     return segs