@r1z4x/tezgah 1.6.0 → 1.8.2

package/hooks/tezgah_paths.py

@@ -70,7 +70,8 @@ OFF_DIRS = (CONFIG_DIR, os.path.join(HOME, ".claude"))
 # the opencode plugin's own `off()` and the gate's control rule all answer from
 # it, and tests/test_paths.py fails when any of them names a switch it lacks.
 # CORE_SWITCHES are the sixteen the always-on contract names. ADR 007 leaves
-# UNCLASSIFIED_SWITCHES open - two `off()` names CORE does not list and two
+# UNCLASSIFIED_SWITCHES open - three `off()` names CORE does not list (the
+# third, `slices-off`, stops the slice journal: hooks/tezgah_task.py) and two
 # opt-in markers read with `armed()` - and until the owner classifies them the
 # control rule protects them like the rest (bin/tezgah-docs carries the same
 # set for its inventory check; the test pins the two equal).
@@ -78,7 +79,7 @@ CORE_SWITCHES = ("adhd-off", "consult-off", "docs-judge-off", "exec-mode.off",
                  "judge-off", "lang-off", "orchestrate-off", "ponytail-auto.off",
                  "pretooluse-off", "reminder-off", "research-off", "spec-off",
                  "task-off", "triage-off", "verify-off", "workspace-off")
-UNCLASSIFIED_SWITCHES = ("agents-off", "skill-suggest-on", "taste-on",
+UNCLASSIFIED_SWITCHES = ("agents-off", "skill-suggest-on", "slices-off", "taste-on",
                          "update-check-off")
 SWITCHES = CORE_SWITCHES + UNCLASSIFIED_SWITCHES
 REPO_MARKS = (".no-adhd", ".no-graph", ".no-lessons", ".no-plan-gate",
@@ -254,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):
@@ -737,17 +739,99 @@ def codex_bin():
     return which_user(os.environ.get("TEZGAH_CODEX_BIN") or "codex")
 
 
-# The values `reply_lang` (config.json) takes. The value itself is the switch:
-# `tr` (the default, and what an install without the key reads) asks for Turkish
-# replies, `en` for English ones, and `any` drops the Stop language check.
-REPLY_LANGS = ("tr", "en", "any")
+# The reply language (config.json `language`; an older config's `reply_lang`
+# still reads and is never rewritten). The value is the switch: a code with a
+# pack under hooks/lang/ asks for replies in that language, `any` for the
+# user's own, and only a pack that ships reply `markers` (tr) is judged by the
+# Stop language check. A config naming neither key reads as `tr`, the default
+# every install made before the packs keeps; a first install writes the
+# environment's language instead (`env_language`, bin/tezgah-setup).
+LANG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lang")
+_PACKS = []
 
 
-def reply_lang():
-    """The configured reply language, `tr` when unset or not one of REPLY_LANGS."""
+def languages():
+    """The values `language` takes: every shipped pack's code, then `any`."""
+    return tuple(packs()) + ("any",)
+
+
+def language():
+    """The configured reply language, `tr` when unset or not one of `languages()`."""
+    cfg = config()
+    for key in ("language", "reply_lang"):
+        value = cfg.get(key) if isinstance(cfg, dict) else None
+        if value in languages():
+            return value
+    return "tr"
+
+
+def spend_cap():
+    """The standing spend cap in USD, `spend_cap` in config.json: a paid run at
+    or under it is a process parameter the agent picks, one over it is asked
+    and waits (the ask policy's never-default class). 0 when unset, negative
+    or not a number, so every spend is asked."""
     cfg = config()
-    value = cfg.get("reply_lang") if isinstance(cfg, dict) else None
-    return value if value in REPLY_LANGS else "tr"
+    value = cfg.get("spend_cap") if isinstance(cfg, dict) else None
+    ok = isinstance(value, (int, float)) and not isinstance(value, bool)
+    return float(value) if ok and value > 0 else 0.0
+
+
+def env_language(environ=None):
+    """The language a first install asks for: the first of LANGUAGE (its own
+    first `:` entry), LC_ALL, LC_MESSAGES and LANG that is set and not empty -
+    GNU gettext's order - cut to its language code (`tr_TR.UTF-8` -> `tr`), or
+    `en` when that code has no pack (`C`, `POSIX`, a language not shipped)."""
+    environ = os.environ if environ is None else environ
+    for key in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
+        value = (environ.get(key) or "").split(":")[0]
+        if value:
+            code = value.split(".")[0].split("@")[0].split("_")[0].lower()
+            return code if code in packs() else "en"
+    return "en"
+
+
+def packs():
+    """{code: pack} for every hooks/lang/<code>.json, read once per process.
+
+    A pack is data: one language's half of every detection class (S5's
+    inventory) and the contract's own words (`say`), keyed alike in every pack
+    (tests/test_lang_packs.py). The detectors compile the union of all packs,
+    so a reply or prompt in any shipped language arms the same classes whatever
+    `language` says; a language is added by one file, never a regex edit."""
+    if not _PACKS:
+        found = {}
+        for name in sorted(os.listdir(LANG_DIR)):
+            if name.endswith(".json"):
+                with open(os.path.join(LANG_DIR, name), encoding="utf-8") as fh:
+                    found[name[:-5]] = json.load(fh)
+        _PACKS.append(found)
+    return _PACKS[0]
+
+
+def pack_values(*path):
+    """Each pack's value at `path` (nested keys), in pack order, skipping a
+    pack that lacks it."""
+    for pack in packs().values():
+        node = pack
+        for key in path:
+            node = node.get(key) if isinstance(node, dict) else None
+        if node is not None:
+            yield node
+
+
+def alts(*path):
+    """The fragments every pack lists at `path`, joined into one alternation;
+    `(?!)`, which never matches, when no pack lists one."""
+    return "|".join(f for frags in pack_values(*path) for f in frags) or "(?!)"
+
+
+def say(code=None):
+    """The contract's words for `code` (the configured language by default):
+    the English pack's `say` map with the code's own pack laid over it, so a
+    language with no pack, or `any`, speaks the canonical English tokens."""
+    words = dict(packs().get("en", {}).get("say", {}))
+    words.update(packs().get(code or language(), {}).get("say", {}))
+    return words
 
 
 # Switch latching (plan 051, ADR 018). A hook process that knows its session
@@ -861,6 +945,16 @@ def pony_level():
     return value if value in PONY_LEVELS else "full"
 
 
+# The router's input-side tokens (input plus cache reads and writes) on its
+# newest step, above which the per-turn reminder asks it to push heavy reads
+# through a slice (tezgah_context.context_nudge). Measured on 12,576 omp
+# main-thread steps (orchestrator-flow-audit S2 F1): median 396 k, p90 724 k. The
+# median is the normal working state and would fire on every other turn, so the
+# line sits just under p90: it marks the heaviest tenth of steps and stays rare
+# enough to be read.
+CONTEXT_NUDGE_TOKENS = 700000
+
+
 def tool(name):
     """Stable installed path for a tezgah CLI, else the plugin's own copy, so
     the text injected into a session names something that actually exists."""
@@ -897,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"),
@@ -1252,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):