@r1z4x/tezgah 1.3.0 → 1.5.0

package/hooks/tezgah_task.py

@@ -21,14 +21,19 @@ before it happens is decided once. This module is on the gate's hot path for
 every write, so it imports nothing from tezgah_context and shells out to
 nothing.
 
-A plan's body is read here too, and only here: the acceptance report
+A plan's body is read here too: the acceptance report
 (`tezgah-render-table --acceptance`) counts the items that name no command, so
 the record the gate reads and the items the report counts have one reader. Two
 readers of the body were added beside it and read in the same place - the
-`## Acceptance` items a plan cannot enter a writing phase without
-(`acceptance_gap`), and the spike a plan declares and has not answered
-(`spike_unanswered`) - for the same reason: the CLI refuses the phase move and
-the CI report counts the same items, and one module keeps them agreeing.
+`## Acceptance` items a plan cannot enter a writing phase with while any of them
+names no command (`acceptance_gap`, the predicate `--strict` refuses on too),
+and the spike a plan declares and has not answered (`spike_unanswered`) - for
+the same reason: the CLI refuses the phase move and the CI report counts the
+same items, and one module keeps them agreeing. The open plans' progress (the
+ticked boxes), the plans each one waits on (`after:`) and which ready plans can
+run at once (`queue`, `parallel`) are read here for `tezgah-task status`. The
+injected open-plans block keeps its own small reader
+(`hooks/tezgah_context.py::_plan_row`: id, title, the first `## Next` line).
 
 The `checkpoint:` key is read here for the same reason again: bin/tezgah-task
 writes it when the phase moves to `implementation` - the pre-work commit's sha
@@ -100,8 +105,9 @@ def frontmatter(text):
     return out
 
 
-def allowed_paths(text):
-    """The `allowed_paths:` list as a list of globs, [] when absent."""
+def _list_field(text, key):
+    """One frontmatter key's `- item` block as a list of strings, [] when the key
+    is absent or carries no block."""
     out = []
     collecting = False
     for line in _frontmatter_lines(text):
@@ -110,10 +116,24 @@ def allowed_paths(text):
             out.append(stripped[2:].strip())
             continue
         collecting = (not stripped.startswith("- ") and ":" in stripped
-                      and stripped.partition(":")[0].strip() == "allowed_paths")
+                      and stripped.partition(":")[0].strip() == key)
     return out
 
 
+def allowed_paths(text):
+    """The `allowed_paths:` list as a list of globs, [] when absent."""
+    return _list_field(text, "allowed_paths")
+
+
+def after(text):
+    """The plan ids this plan waits on (`after:`), in the order written: the
+    `- NNN` block `set_fields` writes, or the inline `after: 012, 015` a person
+    types. [] when the plan waits on nothing - which is what lets it run beside
+    the others."""
+    return (_list_field(text, "after")
+            or frontmatter(text).get("after", "").replace(",", " ").split())
+
+
 def section_lines(text, heading):
     """The lines of one `## <heading>` section with their 1-based numbers, []
     when the file has no such heading: the lines after the heading up to the next
@@ -129,7 +149,7 @@ def section_lines(text, heading):
     return out
 
 
-_ITEM = re.compile(r"^\s*- \[[ xX]\]\s*(.*)$")
+_ITEM = re.compile(r"^\s*- \[([ xX])\]\s*(.*)$")
 # The word `unverifiable`, as a word: the lookahead is a boundary a hyphen and a
 # letter both fail, so `unverifiable-ness` is not a marker.
 _MARKER = re.compile(r"unverifiable(?![-\w])", re.I)
@@ -191,10 +211,11 @@ def unverifiable_reason(text):
 
 def acceptance_items(text):
     """One plan file's `## Acceptance` items: a list of
-    {"line", "text", "state"}, plus "reason" when the state is "unverifiable".
-    One field and not two - "checkable" (the item names a command),
-    "unverifiable" (it says so and why) or "missing" (neither) - so no caller can
-    read two answers about one item.
+    {"line", "text", "checked", "state"}, plus "reason" when the state is
+    "unverifiable". One field and not two - "checkable" (the item names a
+    command), "unverifiable" (it says so and why) or "missing" (neither) - so no
+    caller can read two answers about one item. "checked" is the box (`- [x]`),
+    which is the plan's progress and says nothing about the item's proof.
 
     An item is one `- [ ]`/`- [x]` line plus the lines it wraps onto, up to the
     next item or a blank line: the format wraps at 79 columns, so an item is more
@@ -204,8 +225,8 @@ def acceptance_items(text):
     for number, line in section_lines(text, "Acceptance"):
         found = _ITEM.match(line)
         if found:
-            out.append({"line": number, "text": " ".join(found.group(1).split()),
-                        "state": "missing"})
+            out.append({"line": number, "text": " ".join(found.group(2).split()),
+                        "checked": found.group(1) != " ", "state": "missing"})
         elif out and line.strip():
             out[-1]["text"] = " ".join((out[-1]["text"] + " " + line).split())
     for item in out:
@@ -217,19 +238,27 @@ def acceptance_items(text):
     return out
 
 
+def unproven(items):
+    """The items that name no command and declare no `unverifiable` - the one
+    predicate both the phase move (`acceptance_gap`) and `render_table
+    --acceptance --strict` refuse on, so the two cannot let through different
+    plans."""
+    return [item for item in items if item["state"] == "missing"]
+
+
 def acceptance_gap(text):
-    """The plan's Acceptance items when nothing in them can check the work: every
-    item the section carries is `missing`, so none names a command and none
-    declares itself `unverifiable`. [] otherwise, and [] when the plan has no
-    Acceptance items at all.
+    """The plan's Acceptance items that nothing can check: each one names no
+    command and declares no `unverifiable`. [] when every item names its proof,
+    and [] when the plan has no Acceptance items at all.
 
-    A plan with an empty or absent section is a different defect - the format asks
-    plan-add to write the items, and the render_table report does not gate that
-    case either - so refusing it here would tax every plan that predates the rule
-    while the two readers still agreed about every item either of them can see.
-    Returns the items so a refusal can count them."""
-    items = acceptance_items(text)
-    return items if items and all(item["state"] == "missing" for item in items) else []
+    Any such item is a gap, not only a section made of them: the format asks for
+    the proof per item, and the strict report refuses an open plan on one, so a
+    phase move that let one through would be refused later by the reader it was
+    meant to answer first. A plan with an empty or absent section is a different
+    defect - the format asks plan-add to write the items, and the report does not
+    gate that case either - so refusing it here would tax every plan that
+    predates the rule. Returns the items so a refusal can name them."""
+    return unproven(acceptance_items(text))
 
 
 # The `checkpoint:` values a plan can carry: a commit sha (the tree was clean at
@@ -295,6 +324,30 @@ def spike_unanswered(text):
 
 
 ACCEPTANCE_DIRS = ("open", "done")
+# The `status:` a plan carries in each directory (plan-add's format): a plan
+# under open/ is open or blocked, one under done/ is done or discarded.
+OPEN_STATUSES = ("open", "blocked")
+
+
+def _plan_files(root, sub):
+    """(name, path, text) for every readable `*.md` under
+    `<root>/.tezgah/plans/<sub>`, sorted by name; an absent directory or an
+    unreadable file is skipped, so a reader built on it never raises."""
+    directory = os.path.join(root, ".tezgah", "plans", sub)
+    try:
+        names = sorted(os.listdir(directory))
+    except OSError:
+        return
+    for name in names:
+        if not name.endswith(".md"):
+            continue
+        path = os.path.join(directory, name)
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                text = fh.read()
+        except OSError:
+            continue
+        yield name, path, text
 
 
 def acceptance_report(root):
@@ -310,20 +363,7 @@ def acceptance_report(root):
     items = []
     plans = 0
     for sub in ACCEPTANCE_DIRS:
-        directory = os.path.join(root, ".tezgah", "plans", sub)
-        try:
-            names = sorted(os.listdir(directory))
-        except OSError:
-            continue
-        for name in names:
-            if not name.endswith(".md"):
-                continue
-            path = os.path.join(directory, name)
-            try:
-                with open(path, "r", encoding="utf-8") as fh:
-                    text = fh.read()
-            except OSError:
-                continue
+        for name, _, text in _plan_files(root, sub):
             plans += 1
             for item in acceptance_items(text):
                 item["plan"] = ".tezgah/plans/%s/%s" % (sub, name)
@@ -331,6 +371,72 @@ def acceptance_report(root):
     return {"plans": plans, "items": items}
 
 
+def _plan_id(fields, name):
+    return fields.get("id") or name.split("-")[0]
+
+
+def _prefix(glob):
+    """The literal head of a glob: everything before its first `*`."""
+    return glob.split("*", 1)[0]
+
+
+def scopes_overlap(first, second):
+    """Could two allowlists name one file? An empty list is every path, and two
+    globs can only meet when one literal head is a prefix of the other's - so
+    `hooks/a*.py` and `hooks/b*.py` never do, and `**/x` meets everything.
+    ponytail: prefix test, not glob intersection - it says "overlap" for
+    `hooks/*.py` against `hooks/x/y.md`, which only costs a missed pairing."""
+    if not first or not second:
+        return True
+    return any(a.startswith(b) or b.startswith(a)
+               for a in map(_prefix, first) for b in map(_prefix, second))
+
+
+def queue(root):
+    """Every open plan as a row: {"id", "status", "path", "checked", "items" (the
+    Acceptance boxes ticked, and their count), "after" ([id, state] per plan it
+    waits on: `done`, `discarded`, `open` or `missing` when no plan carries the
+    id), "ready" (not blocked, and everything it waits on is done), "overlaps"
+    (the other open plans whose allowed_paths can name one of its files)}.
+
+    The plans' progress and order had no reader: the boxes were counted nowhere
+    and nothing said which plans could run beside each other. Never raises."""
+    state = {}
+    for name, _, text in _plan_files(root, "done"):
+        fields = frontmatter(text)
+        state[_plan_id(fields, name)] = ("discarded" if fields.get("status") == "discarded"
+                                         else "done")
+    rows = []
+    scopes = {}
+    for name, path, text in _plan_files(root, "open"):
+        fields = frontmatter(text)
+        ident = _plan_id(fields, name)
+        state[ident] = "open"
+        items = acceptance_items(text)
+        scopes[ident] = allowed_paths(text)
+        rows.append({"id": ident, "status": fields.get("status", ""), "path": path,
+                     "checked": sum(1 for item in items if item["checked"]),
+                     "items": len(items), "after": after(text)})
+    for row in rows:
+        row["after"] = [[ident, state.get(ident, "missing")] for ident in row["after"]]
+        row["ready"] = (row["status"] != "blocked"
+                        and all(dep == "done" for _, dep in row["after"]))
+        row["overlaps"] = [other["id"] for other in rows if other is not row
+                           and scopes_overlap(scopes[row["id"]], scopes[other["id"]])]
+    return rows
+
+
+def parallel(rows):
+    """The ready plans that can run at once, in id order: each one shares no
+    allowed_paths prefix with any other picked (greedy, first id first). [] when
+    fewer than two qualify - one plan is not a fan-out."""
+    picked = []
+    for row in rows:
+        if row["ready"] and not any(other in row["overlaps"] for other in picked):
+            picked.append(row["id"])
+    return picked if len(picked) > 1 else []
+
+
 def active(cwd, base):
     """The active task as a dict, or None. Scans `<repo_root>/.tezgah/plans/open/*.md`
     sorted by name, first file whose frontmatter carries a valid `phase`.

package/hooks/tezgah_taste.py

@@ -6,8 +6,8 @@ Opt-in and off by default. A row is written only when the `taste-on` marker is
 armed (`tezgah_paths.armed`), the repository carries no `.no-taste` mark, its
 `.tezgah/` already exists and is the user's own (`workspace_from_repo`: a
 workspace that came with the clone is data, and nothing of the user's is
-written into it). The store is `<git root>/.tezgah/taste/signals.jsonl`, one
-JSON object per line, owner-only.
+written into it). The store is the `signals` table of
+`<git root>/.tezgah/taste/taste.db` (`tezgah_store.taste`), owner-only.
 
 Every public function is total: it never raises and makes no network call.
 The capture functions append at most one row each. They run on the prompt and
@@ -86,9 +86,10 @@ def _write(root, kind, session_id, host, **fields):
            .strftime("%Y-%m-%dT%H:%M:%SZ"),
            "kind": kind, "session": str(session_id or ""), "host": host or _host()}
     row.update(fields)
-    # the ledger's own writer: its flock, torn-tail repair and 0700/0600 modes
-    ti._append(os.path.join(root, ".tezgah", "taste", "signals.jsonl"),
-               json.dumps(row, ensure_ascii=False) + "\n")
+    # imported here, not at the top: the off path never loads sqlite3
+    import tezgah_store as store
+    with store.taste(os.path.join(root, ".tezgah", "taste")) as db:
+        store.append(db, "signals", row)
 
 
 def _host():
@@ -215,8 +216,10 @@ def write_note(session_id, inp, cwd, tool=None):
 def learn_later(root):
     """Start `tezgah-taste learn --repo <root> --no-fallback` detached when the
     signals of `root` (the git root `enabled` returned) grew since the last
-    start and an hour has passed. Only when TypeSafe resolves: the automatic run
-    never pays a generative provider for a decision it may not apply. Not on a
+    start and an hour has passed; the stamp (a `taste_learn` document of the
+    cache database) keeps the newest signal's append number. Only when
+    the Jev model resolves through any carrier: the automatic run never pays a
+    generative provider for a decision it may not apply. Not on a
     machine without flock (Windows), where two background runs in two
     repositories would race on the user ledger. ponytail: no Windows lock; add
     one (msvcrt.locking) before enabling it there. Total; the stamp is written
@@ -224,27 +227,27 @@ def learn_later(root):
     try:
         if not root:
             return
-        size = os.path.getsize(os.path.join(root, ".tezgah", "taste", "signals.jsonl"))
+        import tezgah_store as store
+        with store.taste(os.path.join(root, ".tezgah", "taste"), create=False) as db:
+            if db is None:
+                return
+            count = store.last(db, "signals")
         base = os.path.join(tezgah_paths.cache_dir(), "taste-learn")
         name = re.sub(r"[^A-Za-z0-9]+", "-", root).strip("-")
-        stamp = os.path.join(base, name + ".json")
-        try:
-            with open(stamp, encoding="utf-8") as fh:
-                last = json.load(fh)
-        except (OSError, ValueError):
-            last = {}
+        last = store.doc("taste_learn", name)
+        last = last if isinstance(last, dict) else {}
         now = time.time()
-        if size <= last.get("size", -1) or now - last.get("at", 0) < LEARN_EVERY:
+        if count <= last.get("rows", 0) or now - last.get("at", 0) < LEARN_EVERY:
             return
         # the costlier checks run only once a start is due: at most hourly
         import tezgah_judge
         import tezgah_taste_ledger
         if tezgah_taste_ledger.fcntl is None or tezgah_paths.off("judge-off") \
-                or not tezgah_judge.named(("typesafe",)):
+                or not tezgah_judge.named(("jev",)):
+            return
+        if not store.put_doc("taste_learn", name, {"rows": count, "at": now}):
             return
         os.makedirs(base, exist_ok=True)
-        with open(stamp, "w", encoding="utf-8") as fh:
-            json.dump({"size": size, "at": now}, fh)
         with open(os.path.join(base, name + ".log"), "ab") as log:
             subprocess.Popen([sys.executable, BIN, "learn", "--repo", root,
                               "--no-fallback"],

package/hooks/tezgah_taste_ledger.py

@@ -21,20 +21,20 @@ answers and keeps the ledger.
 - Apply: a rule needs confidence >= `RULE_AT` and a calibration bound >=
   `BOUND_AT` (Clopper-Pearson on an independently labelled sample); a hint needs
   `HINT_AT`; a learning whose evidence paths are all gone from the tree is
-  suspended. The benefit gate's stop file turns injection off.
+  suspended. The benefit gate's stopped state turns injection off.
 
-Store: `<repo>/.tezgah/taste/ledger.json` for path, language and repository
-learnings, `~/.config/tezgah/taste/ledger.json` for user learnings.
+Store: `tezgah_store.taste` - `<repo>/.tezgah/taste/taste.db` for path,
+language and repository learnings and every taste row, and
+`~/.config/tezgah/taste/taste.db` for user learnings.
 """
 import datetime
 import errno
 import fnmatch
-import json
 import math
 import os
 
-import tezgah_integrity as ti
-from tezgah_paths import CONFIG_DIR, cache_dir
+import tezgah_store as store
+from tezgah_paths import CONFIG_DIR
 
 try:
     import fcntl
@@ -66,35 +66,21 @@ def user_dir():
     return os.path.join(CONFIG_DIR, "taste")
 
 
-def _load(path):
-    try:
-        with open(path, encoding="utf-8") as fh:
-            data = json.load(fh)
-        if isinstance(data, dict) and isinstance(data.get("learnings"), dict):
-            data.setdefault("meta", {})
-            return data
-    except (OSError, ValueError):
-        pass
-    return {"v": 1, "learnings": {}, "meta": {}}
-
-
-def _save(path, data):
-    os.makedirs(os.path.dirname(path), mode=0o700, exist_ok=True)
-    tmp = "%s.%d.tmp" % (path, os.getpid())
-    with open(tmp, "w", encoding="utf-8") as fh:
-        json.dump(data, fh, ensure_ascii=False, indent=1, sort_keys=True)
-    os.replace(tmp, path)
+def _load(dirpath, user=False):
+    with store.taste(dirpath, user, create=False) as db:
+        return store.load_ledger(db) if db else {"v": 1, "learnings": {}, "meta": {}}
 
 
 def load(root):
     """{"repo": ledger, "user": ledger}."""
-    return {"repo": _load(os.path.join(store_dir(root), "ledger.json")),
-            "user": _load(os.path.join(user_dir(), "ledger.json"))}
+    return {"repo": _load(store_dir(root)), "user": _load(user_dir(), user=True)}
 
 
 def save(root, ledgers):
-    _save(os.path.join(store_dir(root), "ledger.json"), ledgers["repo"])
-    _save(os.path.join(user_dir(), "ledger.json"), ledgers["user"])
+    with store.taste(store_dir(root)) as db:
+        store.save_ledger(db, ledgers["repo"])
+    with store.taste(user_dir(), user=True) as db:
+        store.save_ledger(db, ledgers["user"])
 
 
 def every(ledgers):
@@ -142,34 +128,33 @@ def cp_lower(x, n, alpha=0.05):
     return lo
 
 
-def rows(path):
-    try:
-        with open(path, encoding="utf-8") as fh:
-            for line in fh:
-                try:
-                    row = json.loads(line)
-                except ValueError:
-                    continue
-                if isinstance(row, dict):
-                    yield row
-    except OSError:
-        return
+def rows(root, table, where="", args=()):
+    """One taste table's rows in append order (`tezgah_store.TASTE_ROWS`); []
+    when the repository has no store yet."""
+    with store.taste(store_dir(root), create=False) as db:
+        return store.rows(db, table, where, args) if db else []
 
 
-def append(path, row, strict=False):
-    """One row through the ledger's own writer: flock, torn-tail repair, 0600.
-    That writer drops a row it cannot write, which a hook wants; `strict` (the
-    CLI's decision, defect and label rows) reads the tail back and raises
-    OSError when the row is not there, so `learn` stops before it saves a
-    ledger whose decision was never recorded and would be re-applied."""
-    line = json.dumps(row, ensure_ascii=False) + "\n"
-    ti._append(path, line)
-    if strict:
-        data = line.encode("utf-8")
-        with open(path, "rb") as fh:
-            fh.seek(max(0, os.path.getsize(path) - len(data)))
-            if fh.read() != data:
-                raise OSError("taste row not written to %s" % path)
+def jev_rows():
+    """(where, args) for `rows`: the rows a Jev carrier (`tezgah_judge.JEV_CARRIERS`)
+    decided, whichever one answered - an old `typesafe` row included. Imported
+    here, not at the top: the write hook loads this module and never asks."""
+    import tezgah_judge
+    carriers = tuple(tezgah_judge.JEV_CARRIERS)
+    return "WHERE provider IN (%s)" % ", ".join("?" * len(carriers)), carriers
+
+
+def append(root, table, row, strict=False):
+    """One row into a taste table. A hook drops a row it cannot write; `strict`
+    (the CLI's decision, defect and label rows) raises instead, so `learn` stops
+    before it saves a ledger whose decision was never recorded and would be
+    re-applied."""
+    try:
+        with store.taste(store_dir(root)) as db:
+            store.append(db, table, row)
+    except store.ERRORS:
+        if strict:
+            raise
 
 
 class Busy(Exception):
@@ -217,11 +202,11 @@ class locked:
 def calibration(root):
     """(x, n, bound): of the labelled signals the typed decision called a
     preference, how many the label agrees with, and the Clopper-Pearson lower
-    bound on that precision. Only typed-provider decisions count; the labels are
+    bound on that precision. Only Jev decisions count; the labels are
     a sample drawn independently of what was injected (`tezgah-taste label`)."""
     x = n = 0
-    for row in rows(os.path.join(store_dir(root), "labels.jsonl")):
-        if row.get("provider") != "typesafe" or row.get("decided") != "preference":
+    for row in rows(root, "labels", *jev_rows()):
+        if row.get("decided") != "preference":
             continue
         n += 1
         x += row.get("label") == "preference"
@@ -282,7 +267,7 @@ def apply(ledgers, sig, dec, day, applied=()):
 
     `dec` is the typed decision: `kind`, `category`, `scope` as (choice,
     probability), `relations` {learning id: (relation, probability)} and
-    `verified`, True only when TypeSafe answered - any other provider's decision
+    `verified`, True only when the Jev model answered - any other provider's decision
     is never applied. `applied` are the ids injected in the signal's session."""
     if not dec.get("verified"):
         return "unverified"
@@ -428,11 +413,8 @@ def suspended(learning, root):
 
 def stopped(root):
     """True when the benefit gate stopped injection for this repository."""
-    try:
-        with open(os.path.join(store_dir(root), "gate.json"), encoding="utf-8") as fh:
-            return bool(json.load(fh).get("stopped"))
-    except (OSError, ValueError, AttributeError):
-        return False
+    with store.taste(store_dir(root), create=False) as db:
+        return bool(db) and store.gate_stopped(db)
 
 
 def usable(root, day=None):
@@ -478,10 +460,10 @@ def block(root, day=None):
 
 
 def record_injection(root, session_id, ids, day=None):
-    """One `injected.jsonl` row: the meta loop counts a later correction in this
+    """One `injected` row: the meta loop counts a later correction in this
     session against these ids, and the benefit gate splits its arms at the first."""
     if ids:
-        append(os.path.join(store_dir(root), "injected.jsonl"),
+        append(root, "injected",
                {"session": str(session_id or ""), "day": now_day() if day is None else day,
                 "ids": list(ids)})
 
@@ -489,9 +471,8 @@ def record_injection(root, session_id, ids, day=None):
 def injected(root, session_id):
     """The learning ids injected in one session."""
     ids = set()
-    for row in rows(os.path.join(store_dir(root), "injected.jsonl")):
-        if row.get("session") == session_id:
-            ids.update(row.get("ids") or ())
+    for row in rows(root, "injected", "WHERE session = ?", (session_id,)):
+        ids.update(row.get("ids") or ())
     return ids
 
 
@@ -502,24 +483,18 @@ def write_note(root, session_id, rel_path):
     if not session_id or not rel_path or stopped(root):
         return ""
     kind = os.path.splitext(rel_path)[1] or os.path.basename(rel_path)
-    seen_path = os.path.join(cache_dir(), "taste-notes",
-                             "%s.json" % str(session_id).replace(os.sep, "_"))
-    try:
-        with open(seen_path, encoding="utf-8") as fh:
-            seen = set(json.load(fh))
-    except (OSError, ValueError, TypeError):
-        seen = set()
+    session_id = str(session_id)
+    with store.taste(store_dir(root), create=False) as db:
+        seen = store.seen(db, session_id) if db else set()
     hits = [(mode, learning) for mode, learning in usable(root)
             if learning["scope"] in ("path", "language") and learning["id"] not in seen
             and fnmatch.fnmatch(rel_path, learning["where"])]
     if not hits:
         return ""
-    seen.update(m[1]["id"] for m in hits)
     try:
-        os.makedirs(os.path.dirname(seen_path), mode=0o700, exist_ok=True)
-        with open(seen_path, "w", encoding="utf-8") as fh:
-            json.dump(sorted(seen), fh)
-    except OSError:
+        with store.taste(store_dir(root)) as db:
+            store.mark_seen(db, session_id, [m[1]["id"] for m in hits])
+    except store.ERRORS:
         return ""
     record_injection(root, session_id, [m[1]["id"] for m in hits])
     return ("Taste for %s files (narrower scope wins):\n" % kind
@@ -529,8 +504,8 @@ def write_note(root, session_id, rel_path):
 # --- markdown and export ----------------------------------------------------------------
 
 def markdown(root, day=None):
-    """Rewrite `<store>/<category>/taste.md` from the active learnings; the JSON
-    ledger stays the source of truth. Returns the files written."""
+    """Rewrite `<store>/<category>/taste.md` from the active learnings; the
+    database stays the source of truth. Returns the files written."""
     day = now_day() if day is None else day
     by_cat = {}
     for learning in every(load(root)).values():
@@ -590,7 +565,7 @@ def export_agents(root):
 
 def first_injection(root):
     """The day of the first injection, or None: where the gate's arms split."""
-    days = [r["day"] for r in rows(os.path.join(store_dir(root), "injected.jsonl"))
+    days = [r["day"] for r in rows(root, "injected")
             if isinstance(r.get("day"), (int, float))]
     return min(days) if days else None
 
@@ -601,13 +576,13 @@ def gate(root, need=980, alpha=0.1):
     Every decided signal is one prompt after a writing turn. The arms split at
     the first injection, by when the turn happened (`at`), not by when `learn`
     decided it, so a backfill of old sessions stays in the before arm. Once both
-    arms hold `need` turns, `gate.json` says stopped unless the after-rate is
+    arms hold `need` turns, the gate's state says stopped unless the after-rate is
     lower at one-sided p < `alpha`. Returns the report."""
     first = first_injection(root)
     arms = {"before": [0, 0], "after": [0, 0]}
-    for row in rows(os.path.join(store_dir(root), "decisions.jsonl")):
+    for row in rows(root, "decisions", *jev_rows()):
         at = row.get("at")
-        if row.get("provider") != "typesafe" or not isinstance(at, (int, float)):
+        if not isinstance(at, (int, float)):
             continue
         arm = arms["after" if first is not None and at >= first else "before"]
         arm[0] += 1
@@ -623,6 +598,6 @@ def gate(root, need=980, alpha=0.1):
         report["p"] = round(0.5 * math.erfc(z / math.sqrt(2)), 4)
     if n1 >= need and n2 >= need:
         report["stopped"] = not (report["p"] is not None and report["p"] < alpha)
-        _save(os.path.join(store_dir(root), "gate.json"),
-              {"stopped": report["stopped"], "report": report})
+        with store.taste(store_dir(root)) as db:
+            store.set_gate(db, report["stopped"], report)
     return report