@r1z4x/tezgah 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -6,6 +6,37 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.4.0] - 2026-10-08
+
+### Changed
+
+- **Taste state lives in SQLite.** The repository's signals, decisions,
+  defects, labels, injections, gate state, learnings and write-note history
+  move to `.tezgah/taste/taste.db`. User-scope learnings move to
+  `~/.config/tezgah/taste/taste.db`. Opening a store imports the old JSON and
+  JSONL files and renames each to `<name>.imported`. It also takes rows an
+  older install appends to an old file later. `taste.md` stays a text file.
+- **The evidence ledger lives in SQLite.** Session rows move from
+  `~/.cache/tezgah/evidence/<session>.jsonl` to the `evidence` table of
+  `~/.cache/tezgah/tezgah.db`. Each row is one INSERT, so no reader meets a
+  torn line. A read or write of a session imports its old JSONL file first.
+  Session start imports the rest in the background once a day, and
+  `tezgah-doctor --import-evidence` imports them now. opencode's plugin uses
+  the same database through node:sqlite. On node before 22.5 it calls the
+  store's `evidence` CLI. The old files stay in place: an opencode process
+  started before the upgrade may still append to one. `tezgah-doctor --clean`
+  deletes a session idle past the retention window.
+- **The small cache stores live in the same database.** They move from files
+  under `~/.cache/tezgah/` to tables of `~/.cache/tezgah/tezgah.db`. These are
+  the turn stamps, switch baselines, used-tool marks and status marks. The
+  nudge marks, the judge's marks, the skill hints and the update check move
+  too. So do the lesson-taint index, Cursor's marks and replies, the snapshot
+  and replay indexes and the taste-learn stamps. The first open of the
+  database imports each store's old files once and deletes them. A later open
+  deletes, unread, a file an older release still running writes there. Snapshot
+  blobs, replay runs and logs stay files. `tezgah-doctor --clean` sweeps the
+  stamps and marks there.
+
 ## [1.3.0] - 2026-10-07
 
 ### Added
@@ -833,7 +864,8 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   the copy could not find `hooks/` and died on import. It now links into the
   installed tree, and also installs the command as `tezgah`.
 
-[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.3.0...HEAD
+[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.4.0
 [1.3.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.3.0
 [1.2.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.2.0
 [1.1.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.1.0

package/MANIFEST

@@ -142,6 +142,7 @@ hooks/tezgah_skill_pick.py
 hooks/tezgah_snapshot.py
 hooks/tezgah_stack.py
 hooks/tezgah_stopspec.py
+hooks/tezgah_store.py
 hooks/tezgah_task.py
 hooks/tezgah_taste.py
 hooks/tezgah_taste_ledger.py
@@ -670,6 +671,7 @@ tests/test_ai_research_library.py
 tests/test_apps_registry.py
 tests/test_attest.py
 tests/test_bash_agreement.py
+tests/test_cache_store.py
 tests/test_cheap_source.py
 tests/test_clarity.py
 tests/test_claude_adapters.py
@@ -694,6 +696,7 @@ tests/test_dsh_statusline.py
 tests/test_embed.py
 tests/test_encoding.py
 tests/test_enforcers.py
+tests/test_evidence_store.py
 tests/test_fuzz_shell.py
 tests/test_gate.py
 tests/test_gate_vectors.py

package/bin/tezgah-doctor

@@ -34,12 +34,14 @@ this tree.
   tezgah-doctor --coverage         the tracked files the graph index does not hold
   tezgah-doctor --coverage --repo ~/Projects/x
   tezgah-doctor --clean            vacuum the opencode database, and delete the
-                                   hook state (evidence ledgers, turns/,
-                                   sessions/, classify.log, context-drops.log,
-                                   debug.log) idle > 30 days
-                                   (--retention-days N); $TEZGAH_SESSION's
-                                   own files are always kept
+                                   hook state (evidence ledgers, turn
+                                   stamps, used-tool marks, classify.log,
+                                   context-drops.log, debug.log) idle > 30
+                                   days (--retention-days N);
+                                   $TEZGAH_SESSION's own state is always kept
   tezgah-doctor --prune-sessions 30   delete sessions idle > 30 days, then vacuum
+  tezgah-doctor --import-evidence  import the legacy JSONL evidence ledgers
+                                   into the evidence database now
 """
 import argparse
 import importlib.machinery
@@ -79,7 +81,11 @@ GRAPH_DB = CODEGRAPH + ".db"
 # The per-session state the hooks write and nothing else removes: the evidence
 # ledgers, the per-turn stamps, the used-tool marks and the two capped logs.
 # Audit L-11 (GAP-10) measured 2,000 of each, 400 days old, surviving a full
-# cycle and `--clean`. Snapshots are not here: tezgah_snapshot caps them itself.
+# cycle and `--clean`. The stamps and the marks are rows of the cache database
+# (`tezgah_store.sweep_cache`); the evidence directory holds the legacy ledger
+# files its import has not taken, and `turns/` and `sessions/` the files a
+# writer from an older release still running beside this one adds there.
+# Snapshots are not here: tezgah_snapshot caps them itself.
 STATE_DIRS = ("evidence", "turns", "sessions")
 STATE_LOGS = ("classify.log", "context-drops.log", "debug.log")
 RETENTION_DAYS = 30
@@ -277,20 +283,36 @@ def prune_sessions(days):
 
 def sweep_state(days, session=None):
     """Delete the hook state not modified for `days`, in the global cache and
-    the temp fallback; (removed, bytes freed).
-
-    By mtime because every writer appends or rewrites in place, so a file's
-    mtime is its session's last activity. The current session's files
-    (`TEZGAH_SESSION`, the id omp and the judgement CLIs export) are kept
-    whatever their age: a session idle past the window and then resumed must
-    not lose its ledger mid-flight."""
+    the temp fallback; (files removed, bytes freed, evidence sessions deleted,
+    evidence rows deleted, turn-stamp and used-mark rows deleted).
+
+    The evidence ledger is swept in its database (`tezgah_store.sweep_evidence`,
+    after importing the legacy JSONL files): every session whose newest row is
+    older than the cutoff loses its rows. The turn stamps and the used-tool
+    marks are swept there too, by the time each was last written
+    (`tezgah_store.sweep_cache`). The other files go by mtime, because
+    every writer appends or rewrites in place, so a file's mtime is its
+    session's last activity. The current session (`TEZGAH_SESSION`, the id omp
+    and the judgement CLIs export) is kept whatever its age: a session idle past
+    the window and then resumed must not lose its ledger mid-flight."""
+    import tezgah_store
     from tezgah_context import slug
     from tezgah_integrity import _slug
     keep = ({_slug(session) + ".jsonl", slug(session) + ".json",
              slug(session) + ".jsonl"} if session else set())
     cutoff = time.time() - days * 86400
-    removed = freed = 0
+    removed = freed = sessions = rows = marks = 0
     for base in dict.fromkeys((CACHE, fallback_cache())):
+        try:
+            swept = tezgah_store.sweep_evidence(base, cutoff,
+                                                _slug(session) if session else None)
+        except tezgah_store.ERRORS:
+            swept = (0, 0)
+        sessions, rows = sessions + swept[0], rows + swept[1]
+        try:
+            marks += tezgah_store.sweep_cache(base, cutoff, slug(session) if session else None)
+        except tezgah_store.ERRORS:
+            pass
         paths = [os.path.join(base, name) for name in STATE_LOGS]
         for sub in STATE_DIRS:
             try:
@@ -310,7 +332,15 @@ def sweep_state(days, session=None):
                 continue
             removed += 1
             freed += st.st_size
-    return removed, freed
+    return removed, freed, sessions, rows, marks
+
+
+def import_evidence():
+    """The bulk import of the legacy JSONL ledgers into the evidence database
+    of the cache and of the temp fallback: {cache: files seen}."""
+    import tezgah_store
+    return {base: tezgah_store.import_evidence(base)
+            for base in dict.fromkeys((CACHE, fallback_cache()))}
 
 
 
@@ -421,7 +451,7 @@ def main():
                     help="a saved `codegraph files -j` dump to read for --coverage")
     ap.add_argument("--clean", action="store_true",
                     help="vacuum the opencode database and delete tezgah hook "
-                         "state (ledgers, turns/, sessions/, classify.log, "
+                         "state (ledgers, turn stamps, used-tool marks, classify.log, "
                          "context-drops.log, debug.log) not "
                          "modified for --retention-days; the current session "
                          "($TEZGAH_SESSION) is kept (opt-in)")
@@ -431,6 +461,10 @@ def main():
                          "%(default)s days)")
     ap.add_argument("--prune-sessions", type=int, metavar="DAYS",
                     help="delete sessions idle longer than DAYS, then vacuum")
+    ap.add_argument("--import-evidence", action="store_true",
+                    help="import the legacy JSONL evidence ledgers into the "
+                         "evidence database now, instead of at the next "
+                         "session start's daily run")
     args = ap.parse_args()
     if args.retention_days < 1:
         ap.error("--retention-days wants a positive day count")
@@ -439,6 +473,19 @@ def main():
         repo = os.path.realpath(os.path.expanduser(args.repo[0]) if args.repo
                                 else os.getcwd())
         return coverage_report(repo, args.dump)
+    if args.import_evidence:
+        import tezgah_store
+        try:
+            seen = import_evidence()
+        except tezgah_store.ERRORS as exc:
+            print("evidence import failed: %s" % exc, file=sys.stderr)
+            return 1
+        if args.json:
+            print(json.dumps({"imported": seen}, indent=2))
+        else:
+            for base, n in seen.items():
+                print("%s: %d legacy ledger file(s) imported" % (base, n))
+        return 0
     if args.stack:
         import tezgah_stack
         repo = os.path.realpath(os.path.expanduser(args.repo[0]) if args.repo
@@ -470,10 +517,13 @@ def main():
                 except sqlite3.Error as exc:
                     cleaned["vacuum"] = "failed: %s" % exc
         if args.clean:
-            removed, freed = sweep_state(args.retention_days,
-                                         os.environ.get("TEZGAH_SESSION"))
+            removed, freed, sessions, rows, marks = sweep_state(
+                args.retention_days, os.environ.get("TEZGAH_SESSION"))
             cleaned["state"] = {"removed": removed, "bytes": freed,
                                 "days": args.retention_days}
+            cleaned["evidence"] = {"sessions": sessions, "rows": rows,
+                                   "days": args.retention_days}
+            cleaned["marks"] = {"rows": marks, "days": args.retention_days}
         rep = collect(pairs)
 
     if args.json:
@@ -499,6 +549,13 @@ def main():
         if st:
             print("  hook state    %d file(s) older than %d days removed, %s"
                   % (st["removed"], st["days"], human(st["bytes"])))
+        ev = cleaned.get("evidence")
+        if ev:
+            print("  evidence      %d session(s) idle > %d days deleted (%d rows)"
+                  % (ev["sessions"], ev["days"], ev["rows"]))
+        mk = cleaned.get("marks")
+        if mk:
+            print("  stamps/marks  %d row(s) idle > %d days deleted" % (mk["rows"], mk["days"]))
     elif rep["opencode_db_bytes"] > 500 * 1024 * 1024:
         print("\nrun with --clean to vacuum; --prune-sessions DAYS to shrink the db")
     return 0

package/bin/tezgah-setup

@@ -59,6 +59,7 @@ import tezgah_paths as tp  # noqa: E402
 import tezgah_policy as policy  # noqa: E402
 import tezgah_agents  # noqa: E402
 import tezgah_integrity  # noqa: E402
+import tezgah_store  # noqa: E402
 import tezgah_attest as ta  # noqa: E402
 from tezgah_policy import (  # noqa: E402
     ADHD, CODEGRAPH_RULE, CODEGRAPH_STATIC, CONSULT, EXEC, NO_CONSULT,
@@ -4161,17 +4162,6 @@ def _denied(host, stdout):
     return (got.get("hookSpecificOutput") or {}).get("permissionDecision") == "deny"
 
 
-def _live_cleanup(slug):
-    """Remove every cache file the synthetic session left (named by its slug)."""
-    for dirpath, _dirs, files in os.walk(tp.cache_dir()):
-        for name in files:
-            if slug in name:
-                try:
-                    os.remove(os.path.join(dirpath, name))
-                except OSError:
-                    pass
-
-
 def live_probe(host, deny=False):
     """(state, line) for one host: ok, miss or unverified. `deny` sends the
     PreToolUse probe: the host's deny envelope and a deny row must both appear;
@@ -4211,15 +4201,14 @@ def live_probe(host, deny=False):
                                   capture_output=True, text=True, env=env,
                                   cwd=root, timeout=LIVE_TIMEOUT)
         ms = int((time.monotonic() - started) * 1000)
-        try:
-            with open(ledger, encoding="utf-8") as fh:
-                kinds = [json.loads(ln).get("kind") for ln in fh if ln.strip()]
-        except (OSError, ValueError):
-            kinds = []
+        kinds = [row.get("kind") for row in tezgah_integrity.events_path(ledger)]
     except (OSError, subprocess.SubprocessError) as exc:
         return "miss", "live %s: the hook did not run (%s)" % (who, exc)
     finally:
-        _live_cleanup(slug)
+        try:
+            tezgah_store.forget_session(ledger)
+        except tezgah_store.ERRORS:
+            pass
         shutil.rmtree(root, ignore_errors=True)
     err = (proc.stderr or "").strip().splitlines()
     tail = " (exit %d%s)" % (proc.returncode, ": " + err[-1][:160] if err else "")

package/bin/tezgah-taste

@@ -34,15 +34,15 @@ judge's provider (`hooks/tezgah_judge.py` names it); with no credential or
 `judge-off` set they send nothing and exit 2.
 
 `learn` is taste-1's pipeline on tezgah (research line taste-architecture,
-design T1P). Each prompt after a writing turn - from the capture rows in
-`<repo>/.tezgah/taste/signals.jsonl`, or with `--from-transcripts` from this
-repository's omp and Claude transcripts - becomes one structured signal built by
-code: the prompt, the files written, the agent's edits and the user's own edit
-between two agent writes. One typed decision per signal, required from TypeSafe
-(`only=("typesafe",)`): preference, defect or none; the category; the scope; and
-how it relates to each learning held. A decision any other provider gave is
-recorded `unverified` and never applied. A defect goes to `defects.jsonl`, never
-into the ledger. The ledger itself is `hooks/tezgah_taste_ledger.py`. A
+design T1P). Each prompt after a writing turn - from the capture rows in the
+`signals` table of `<repo>/.tezgah/taste/taste.db`, or with `--from-transcripts`
+from this repository's omp and Claude transcripts - becomes one structured signal
+built by code: the prompt, the files written, the agent's edits and the user's
+own edit between two agent writes. One typed decision per signal, required from
+TypeSafe (`only=("typesafe",)`): preference, defect or none; the category; the
+scope; and how it relates to each learning held. A decision any other provider
+gave is recorded `unverified` and never applied. A defect goes to the `defects`
+table, never into the ledger. The ledger itself is `hooks/tezgah_taste_ledger.py`. A
 learning that becomes active gets one readable line from a generative provider
 (a `text` question; the user's own words when none answers).
 
@@ -70,6 +70,7 @@ sys.path.insert(0, os.path.join(HERE, "hooks"))
 import tezgah_integrity as ti  # noqa: E402
 import tezgah_judge  # noqa: E402
 import tezgah_models  # noqa: E402
+import tezgah_paths  # noqa: E402
 import tezgah_taste_ledger as tl  # noqa: E402
 
 WRITE_TOOLS = {"omp": {"edit", "write"},
@@ -466,18 +467,13 @@ def iso_day(ts):
 
 
 def _snapshots():
-    """{absolute path: [(ts, id, after)]} over the snapshot store, oldest first."""
-    import tezgah_snapshot as ts
+    """{absolute path: [(ts, id, after)]} over the snapshot index, oldest first."""
+    import tezgah_store
     out = {}
-    for d in ts._dirs():
-        try:
-            with open(os.path.join(d, "meta.json"), encoding="utf-8") as fh:
-                meta = json.load(fh)
-        except (OSError, ValueError):
-            continue
-        if isinstance(meta, dict) and meta.get("path"):
+    for meta in tezgah_store.snapshots():
+        if isinstance(meta, dict) and meta.get("path") and meta.get("id"):
             out.setdefault(meta["path"], []).append(
-                (int(meta.get("ts") or 0), os.path.basename(d), bool(meta.get("after"))))
+                (int(meta.get("ts") or 0), meta["id"], bool(meta.get("after"))))
     for rows in out.values():
         rows.sort()
     return out
@@ -522,7 +518,7 @@ def user_diff(repo, rel, after_sid, snaps):
 def capture_signals(repo):
     """One signal per prompt that followed a writing turn, from the capture rows."""
     snaps, turns, out = None, {}, []
-    for row in tl.rows(os.path.join(tl.store_dir(repo), "signals.jsonl")):
+    for row in tl.rows(repo, "signals"):
         session = row.get("session") or ""
         turn = turns.setdefault(session, {"edits": [], "after": []})
         if row.get("kind") == "edit":
@@ -666,9 +662,15 @@ def write_line(learning):
 
 
 def store_or_exit(args):
+    """The repository whose taste store a command opens. Refused when its
+    `.tezgah` came with the clone: those files are the project's data, and
+    opening the store would import, rename or create files in them."""
     repo = repo_root(os.path.abspath(args.repo or os.getcwd()))
     if not repo:
         raise SystemExit(misuse("not inside a git repository"))
+    if tezgah_paths.workspace_from_repo(repo):
+        raise SystemExit(misuse("%s/.tezgah came with the repository; its taste "
+                                "store is not opened" % repo))
     return repo
 
 
@@ -689,7 +691,7 @@ def cmd_learn(args):
     signals = (transcript_signals(repo, args.host) if args.from_transcripts
                else capture_signals(repo))
     decided = {}
-    for r in tl.rows(os.path.join(tl.store_dir(repo), "decisions.jsonl")):
+    for r in tl.rows(repo, "decisions"):
         decided[r.get("id")] = decided.get(r.get("id")) or r.get("provider") == "typesafe"
     # a typed decision is final; an unverified one is retried, TypeSafe only
     todo = [s for s in signals if not decided.get(s["id"])]
@@ -709,7 +711,7 @@ def cmd_learn(args):
         tokens[0] += result["usage"]["input_tokens"]
         tokens[1] += result["usage"]["output_tokens"]
         day = tl.now_day()
-        tl.append(os.path.join(tl.store_dir(repo), "decisions.jsonl"), {
+        tl.append(repo, "decisions", {
             "id": sig["id"], "day": day, "at": sig.get("at"), "session": sig["session"],
             "provider": result.get("provider"), "model": result.get("model"),
             "verified": dec["verified"], "kind": dec["kind"][0], "p": dec["kind"][1],
@@ -722,7 +724,7 @@ def cmd_learn(args):
         counts["typesafe"] += 1
         counts[dec["kind"][0] if dec["kind"][0] in CLASSES else "none"] += 1
         if dec["kind"][0] == "defect":
-            tl.append(os.path.join(tl.store_dir(repo), "defects.jsonl"),
+            tl.append(repo, "defects",
                       {"id": sig["id"], "day": day, "session": sig["session"],
                        "text": ti.redact(sig["text"])[:600], "paths": sig["paths"][:8]},
                       strict=True)
@@ -806,17 +808,16 @@ def cmd_label(args):
     sample of unlabelled typed decisions - drawn without regard to what was
     injected, so the calibration bound rests on an unselected sample."""
     repo = store_or_exit(args)
-    store = tl.store_dir(repo)
-    decided = {r["id"]: r for r in tl.rows(os.path.join(store, "decisions.jsonl"))
-               if r.get("provider") == "typesafe" and r.get("id")}
-    labelled = {r.get("id") for r in tl.rows(os.path.join(store, "labels.jsonl"))}
+    decided = {r["id"]: r for r in tl.rows(repo, "decisions", "WHERE provider = ?",
+                                            ("typesafe",)) if r.get("id")}
+    labelled = {r.get("id") for r in tl.rows(repo, "labels")}
     if args.id:
         if args.label not in CLASSES:
             return misuse("label is one of %s" % ", ".join(CLASSES))
         row = decided.get(args.id)
         if row is None:
             return misuse("no typed decision %s" % args.id)
-        tl.append(os.path.join(store, "labels.jsonl"),
+        tl.append(repo, "labels",
                   {"id": args.id, "label": args.label, "decided": row.get("kind"),
                    "provider": row.get("provider"), "day": tl.now_day()}, strict=True)
         print("%s labelled %s (decided %s)" % (args.id, args.label, row.get("kind")))
@@ -910,7 +911,7 @@ def main(argv):
                "gate": cmd_gate}[args.cmd]
     if args.cmd not in ("learn", "accept", "reject", "edit", "label"):
         return handler(args)
-    # the commands that rewrite ledger.json: one at a time, or the last one
+    # the commands that rewrite the ledgers: one at a time, or the last one
     # to finish would silently drop what the other wrote
     try:
         repo = store_or_exit(args)

package/docs/architecture.md

@@ -154,10 +154,10 @@ lowest-value blocks are dropped in a fixed order rather than the rules
 
 | Store | Path | Writer | Authoritative for |
 |---|---|---|---|
-| Evidence ledger | `~/.cache/tezgah/evidence/<session>.jsonl` (`hooks/tezgah_integrity.py::_path`) | `note_tool` from each host's PostToolUse (`hooks/tezgah_integrity.py::note_tool`) | what a session actually ran, and therefore the Stop verdict |
-| Session store (used marks) | the chosen cache dir, `sessions/<session>.jsonl` (`hooks/tezgah_context.py::record`) | `record` (`hooks/tezgah_context.py::record`) from every adapter | nothing evidential: a convenience channel for a surface that has no transcript; an `orch` mark is also written to the evidence ledger (`hooks/tezgah_context.py::record`) so `fanout` can count it |
-| Snapshot store | `<cache dir>/snapshots` (`hooks/tezgah_snapshot.py::_store`) | `capture` on the write path (`hooks/tezgah_snapshot.py::capture`) | the pre-write bytes; the rollback source |
-| Turn stamp | `<cache dir>/turns/<session>.json` (`hooks/tezgah_context.py::_stamp_path`) | `write_stamp` (`hooks/tezgah_context.py::write_stamp`) | the comparison behind the one-line delta, nothing else |
+| Evidence ledger | the `evidence` rows of `~/.cache/tezgah/tezgah.db`, keyed by the session's `evidence/<session>.jsonl` path (`hooks/tezgah_integrity.py::_path`, `hooks/tezgah_store.py::EVIDENCE_SCHEMA`); an old JSONL file at that path is imported (`hooks/tezgah_store.py::_sync`) | `note_tool` from each host's PostToolUse (`hooks/tezgah_integrity.py::note_tool`) | what a session actually ran, and therefore the Stop verdict |
+| Session store (used marks) | the `used` rows of the cache dir's `tezgah.db`, one per session and kind (`hooks/tezgah_store.py::use`) | `record` (`hooks/tezgah_context.py::record`) from every adapter | nothing evidential: a convenience channel for a surface that has no transcript; an `orch` mark is also written to the evidence ledger (`hooks/tezgah_context.py::record`) so `fanout` can count it |
+| Snapshot store | the blobs under `<cache dir>/snapshots` (`hooks/tezgah_snapshot.py::_store`), their manifests the `snapshots` rows of `tezgah.db` (`hooks/tezgah_store.py::add_snapshot`) | `capture` on the write path (`hooks/tezgah_snapshot.py::capture`) | the pre-write bytes; the rollback source |
+| Turn stamp | the `turns` rows of the cache dir's `tezgah.db`, one per session (`hooks/tezgah_context.py::write_stamp`) | `write_stamp` (`hooks/tezgah_context.py::write_stamp`) | the comparison behind the one-line delta, nothing else |
 | Installed config dir | `~/.config/tezgah` (`hooks/tezgah_paths.py::CONFIG_DIR`) | the installer and the user | which roots are armed, which kill switches are on |
 | Plugin copy | `~/.claude/plugins/cache/<marketplace>/tezgah/<version>/` (`bin/tezgah-setup::plugin_copies`) | `tezgah-setup --sync` (`bin/tezgah-setup::sync`) | what Claude Code actually executes — a copy, never this checkout |
 

package/docs/clarity-baseline.json

@@ -30,10 +30,10 @@
     "semicolons": 3
   },
   "docs/evidence.md": {
-    "long_sentences": 109,
-    "passive": 57,
+    "long_sentences": 108,
+    "passive": 55,
     "replace_words": 1,
-    "semicolons": 40
+    "semicolons": 39
   },
   "docs/feature-audit.md": {
     "long_sentences": 20,

package/docs/contract.md

@@ -43,7 +43,7 @@ answers it - TypeSafe, or the OpenRouter fallback when no TypeSafe key resolves
 skill names plus `none`, and one Noul
 asking whether the turn wants a skill at all - and the winner is appended after
 the armed paragraphs as a hint to look at first, never as an instruction to load
-(`hooks/tezgah_skill_pick.py:41-75` is the whole configuration, wired into
+(`hooks/tezgah_skill_pick.py:41-76` is the whole configuration, wired into
 `context_for` at `hooks/tezgah_context.py::context_for`). Measured cost of the line
 itself: 455-523 characters, about 115-130 tokens of prompt (the section address
 added ~150 characters over the name-only line; `bin/tezgah-skill` is the same

package/docs/environment.md

@@ -122,6 +122,7 @@ the kill switches are files, not variables, and live in
 | Variable | Read by | Default | Effect |
 |---|---|---|---|
 | `TEZGAH_E2E_STRICT` | `tests/e2e_*.py`, `.github/workflows/ci.yml` | unset (a missing prerequisite is a SKIP) | `1` turns an end-to-end script's SKIP into a FAIL; CI sets it. |
+| `TEZGAH_OPENCODE_NO_SQLITE` | `hosts/opencode/plugins/tezgah.js` | unset (node:sqlite when the runtime has it) | `1` makes the opencode plugin read and write the evidence ledger through `python3 hooks/tezgah_store.py evidence ...`, the path a runtime without node:sqlite takes; a test sets it. |
 
 ## Debugging