@r1z4x/tezgah 1.0.0

package/docs/README.md

@@ -0,0 +1,112 @@
+# tezgah docs
+
+Tezgah arms every AI coding assistant you run with one working contract, inside
+the repository roots you configure. These pages are the engineering layer of
+this repository. The [README](../README.md) explains the
+tool to someone deciding whether to install it; `AGENTS.md` says how to check a
+change; these pages explain how the thing actually works, so a session does not
+have to re-derive it by reading 55 Python files. Every page is written for one
+reader with one question in mind, and every non-obvious claim in it carries a
+citation you can open: `path::symbol` into Python code, `path:line` elsewhere.
+
+## Start here
+
+| You are | Read |
+|---|---|
+| an agent mid-task, before touching a rule or a host | [contract](contract.md), then [hosts](hosts.md) |
+| a user in the first session after installing | the [README install section](../README.md#install) (what changed on your machine), then `tezgah-setup --report --live` (every host's hooks run and its gate denies), then [contract](contract.md) for what the session is told |
+| an agent that has to decide whether something is safe to do | [gate](gate.md), [evidence](evidence.md) |
+| a maintainer adding a rule, a host or a mark | [architecture](architecture.md), then the page of the thing you are adding |
+| someone debugging what a session was actually told | [contract](contract.md), [status-line](status-line.md) |
+| someone releasing or repairing an install | [operations](operations.md), [environment](environment.md) |
+| new to the repository | [architecture](architecture.md), then [glossary](glossary.md) |
+
+## The questions this layer answers
+
+| Question | Page |
+|---|---|
+| Why does this exist, and what are its layers? | [architecture](architecture.md) |
+| What runs when, from session start to Stop? | [architecture](architecture.md) |
+| Which layer is tezgah, and which sense of "harness" is which? | [layers](layers.md) |
+| What is a session told, and how is a rule disarmed? | [contract](contract.md) |
+| Why was my command denied? | [gate](gate.md) |
+| What is recorded, and what stops an unverified "done"? | [evidence](evidence.md) |
+| What does each status mark mean? | [status-line](status-line.md) |
+| What is the judgement seam, who may call it and how is it switched off? | [judge](judge.md) |
+| Which model runs which subagent, and how does `tezgah-route` pick one? | [models](models.md) |
+| Where does a research line live, and what does `tezgah-research check` refuse? | [research](research.md) |
+| What does each host get, and what can it observe? | [hosts](hosts.md) |
+| Which skills ship, and how does one reach a host? | [skills](skills.md) |
+| How is one feature audited across its layers, and what does a capability change need to carry? | [feature-audit](feature-audit.md) |
+| How do I check a change, and how do I test it? | [testing](testing.md) |
+| How do I install, upgrade or repair this? | [operations](operations.md) |
+| Which environment variables does tezgah read, and what does each change? | [environment](environment.md) |
+| What does this word mean here? | [glossary](glossary.md) |
+| How is a session meant to run, and what does each tier cost? | [vision](vision.md) |
+
+## How these pages are written
+
+- English. The READMEs are the only translated surface.
+- A page opens with what it is, who reads it and when; it ends with
+  `## Source of truth`, the files it documents, so a reader can re-verify it
+  after a change.
+- A non-obvious claim carries a citation. A claim nobody can point at does not
+  belong on a page: delete it rather than soften it.
+- Code in a Python file is cited by symbol: `path::name` for a top-level def,
+  class or assignment, `path::Class.method` or `path::outer.inner` for a nested
+  one (`hooks/tezgah_gate.py::decision`). It carries no line number, so an edit
+  that moves code above or inside the symbol moves no citation. The sentence says
+  which part of the symbol it means. Everything else stays `path:line`: a
+  JavaScript, TypeScript, JSON, YAML or Markdown target, module-level code outside
+  every def and class, and a range across several symbols. Never name a symbol
+  that does not contain what the sentence cites.
+- `bin/tezgah-docs --citations` checks both forms. It reads every page under `docs/`
+  and the comments and docstrings of the Python code. A string literal, such as a
+  fixture or a captured output, is data and is not read. A symbol citation is
+  resolved against the AST of the file it names. It fails when that file defines
+  no such name. A name without a dot may also name the one method of that name
+  in a class. That is how a test pin names its test. A def local to a function
+  never stands in for it. A `path:line` with a symbol named
+  before it, or right after it in parentheses, must point inside that symbol's
+  body. A bare file name means the one code file of that name. The suite also
+  checks that a cited file exists and that a cited line is inside it
+  (`tests/test_docs.py`). Whether a line still *shows the thing the sentence names*
+  is a judgement, not a regex. So a `path:line` with no symbol beside it is left
+  unjudged rather than guessed at. So is a `path:N` the pattern cannot read
+  (unquoted, or a comma list), but it is counted.
+  On this tree, 2026-10-06: 996 judged (995 of them symbol citations), 577 not
+  judgeable, 85 of those unreadable.
+  The unjudged count is a ratchet. `docs/citations-baseline.json` holds each file's
+  count, and a file above or below it fails. Only `--citations --update` rewrites
+  it, so CI never writes it. The same pass checks the rule ledger and three inventories read
+  by AST: the gate's rule headings and switches ([gate](gate.md)), the judge's
+  callers ([judge](judge.md)), and the kill-switch names. CI runs it, and it exits
+  non-zero on any of them.
+- Two hundred lines is the ceiling. A page that needs more is two pages.
+- The [glossary](glossary.md) is the only place a term is defined; every other
+  page uses the term and links to it there.
+- No page restates the README's user-facing sections (what it enforces, install,
+  benchmark, cost) or the CHANGELOG. Link instead of duplicating.
+
+## Reaching a page without reading this file
+
+`docs/index.json` is the machine-readable index: one entry per page with its
+title, the questions it answers, its audience and its sources.
+
+```sh
+tezgah-docs                 # every page, one line each
+tezgah-docs deny shortcut   # the page(s) that answer a query
+tezgah-docs --json status   # the same, for a program
+tezgah-docs -- --no-verify  # `--` ends the options; a word after it is a query word
+tezgah-docs --citations     # the citations that no longer show what they name
+```
+
+`bin/tezgah-docs` reads that index and prints file paths, so an agent can pick a
+page without guessing and a script can assert the layer is intact. A test keeps
+the index and the directory in step: a page cannot be added without an entry, and
+an entry cannot name a file that is not there.
+
+## The private layer
+
+`docs/research/` is gitignored: local research notes, kept out of the published
+repository. Nothing under it is a source of truth for anything here.

package/docs/architecture.md

@@ -0,0 +1,226 @@
+# Architecture
+
+This page answers one question: how tezgah is built, and what runs when a
+session starts. It is written for the maintainer adding a rule, a [host](glossary.md#host)
+or a [mark](glossary.md#mark), and for any session that has to reason about why
+the thing behaved the way it did instead of re-deriving it from the Python. Read
+it before [gate](gate.md), [evidence](evidence.md) or [hosts](hosts.md); those
+pages assume the layers named here.
+
+## One idea
+
+tezgah is a working contract — rules about honesty, minimal code, and evidence —
+written once as plain strings, injected into six coding-agent hosts, and backed
+by two mechanisms that make the contract checkable rather than merely stated: a
+[gate](glossary.md#gate) that refuses a tool call before it runs, and an evidence
+[ledger](glossary.md#ledger) that records what actually ran so a "done" claim can
+be contradicted. Everything else in the repository exists to keep those three
+things — one text, one gate, one ledger — shared rather than copied.
+
+## The layers, bottom-up
+
+### `hooks/` — the shared Python core
+
+The core is host-independent: it answers in tezgah's own vocabulary and knows
+nothing about a host's event names or output envelope.
+
+| Module | Owns | Point at |
+|---|---|---|
+| `tezgah_context.py` | the one builder of injected text; event normalisation to `session_start`/`user_prompt`/`subagent_start`/`post_compact`; the status segments and the used marks | `hooks/tezgah_context.py:2-7`, `hooks/tezgah_context.py::context_for` |
+| `tezgah_policy.py` | the contract itself, as strings: `CORE`, the conditional paragraphs, the pointer line, the per-turn reminder, and the long-form blocks the on-demand skill mirrors | `hooks/tezgah_policy.py:2-16`, `hooks/tezgah_policy.py::CORE`, `hooks/tezgah_policy.py::CONDITIONAL_KEYS` |
+| `tezgah_gate.py` | the tool gate: explorer refusal, the one-time grep nudge, attribution and test-disable denies, loop/retry ceilings | `hooks/tezgah_gate.py:2-91`, `hooks/tezgah_gate.py::decision` |
+| `tezgah_integrity.py` | the evidence ledger, redaction, the anti-shortcut parser and the Stop rule | `hooks/tezgah_integrity.py:2-24`, `hooks/tezgah_integrity.py::note_tool`, `hooks/tezgah_integrity.py::stop_reason` |
+| `tezgah_guard.py` | the one catch around an entry point's call into the core, so a crash costs an envelope rather than a session, and the `crash` ledger row that keeps it countable | `hooks/tezgah_guard.py:2-26`, `hooks/tezgah_guard.py::safe` |
+| `tezgah_paths.py` | where tezgah is armed: [roots](glossary.md#root) and the linked worktrees of a repository under one, kill switches, the config dir, and the writable cache dir - the fallback resolved on use rather than at import, so a gated call does not pay for `tempfile`, `shutil` or `sqlite3` | `hooks/tezgah_paths.py:2-14`, `hooks/tezgah_paths.py::cache_dir`, `hooks/tezgah_paths.py::fallback_cache` |
+| `tezgah_snapshot.py` | pre-write bytes of every file a write is about to change, and the one explicit restore | `hooks/tezgah_snapshot.py:2-18`, `hooks/tezgah_snapshot.py::capture` |
+| `tezgah_untrusted.py` | the untrusted-content label on a result from outside the user and workspace, and the taint notice on the next effect | `hooks/tezgah_untrusted.py:2-22`, `hooks/tezgah_untrusted.py::marks` |
+| `tezgah_agents.py` | per-repo subagent definitions generated into each host that has an agent surface | `hooks/tezgah_agents.py:2-22`, `hooks/tezgah_agents.py::sync_root` |
+| `tezgah_research.py` | the in-repo research workspace and the check that a protocol predates its results | `hooks/tezgah_research.py:2-85`, `hooks/tezgah_research.py::check` |
+| `tezgah_index.py` | the detached graph auto-index worker (flock-guarded, bounded retry) | `hooks/tezgah_index.py:2-18`, `hooks/tezgah_index.py::main` |
+
+`hooks/projects-*.py` are the Claude/dsh event entry points, not core: they hold
+only the envelope (see the event sequence below).
+
+### `hosts/<name>/` — the adapters
+
+A host adapter translates one host's event names and output schema into the
+core's vocabulary and translates the answer back. It contains no rule text and
+no gate logic; the imports are the proof. Codex is the most readable example:
+its hook maps `SessionStart`/`UserPromptSubmit`/`SubagentStart`/`PostCompact` to
+the core's events (`hosts/codex/hook.py::EVENTS`), imports the builder, gate,
+integrity and untrusted modules from `hooks/` (`hosts/codex/hook.py:25-39`), and
+passes Codex's tool names through a translation table before calling the gate
+(`hosts/codex/hook.py::GATE_TOOLS`, `hosts/codex/hook.py::gate_name`, `decision` at `hosts/codex/hook.py::gate_reason`). omp is
+the same split in another language: the TypeScript extension is "only the
+bridge" and substitutes the absolute path of
+the Python half (`hosts/omp/tezgah-hook.ts.in:5-7`), whose `handle()` dispatches
+every event (`hosts/omp/hook.py::handle`). Cursor (`hosts/cursor/hook.py:2-40`) and
+opencode (`hosts/opencode/plugins/tezgah.js:1-57`) follow the same rule; opencode
+is the one host whose plugin cannot call the core in process, so it shells out
+through `bin/tezgah-context` and `bin/tezgah-capture` instead of copying it
+(`hosts/opencode/plugins/tezgah.js:5-8,33-35`).
+
+### `bin/` — the CLIs and the installer
+
+`bin/tezgah-setup` is the installer and the only writer of host wiring: it arms
+every detected host, regenerates the generated contract files and the subagent
+sets, and reports what is armed (`bin/tezgah-setup:2-33`). The rest are the small
+stable CLIs the contract cites by absolute path because a session shell has no
+interactive PATH: `bin/tezgah-status` (the checklist in any host,
+`bin/tezgah-status:2-16`), `bin/tezgah-rollback`,
+`bin/tezgah-capture`, `bin/tezgah-context`, `bin/tezgah-index`,
+`bin/tezgah-agents`, and the optional `bin/consult` / `bin/codegen`.
+
+### The surfaces
+
+A surface draws the marks; it never decides them. `statusline.py` is the Claude
+and Cursor status line, and resolves the checkout from its own symlink before
+importing the core (`statusline.py:20-29`). `hosts/opencode/tui/tezgah-tui.tsx` is
+the opencode TUI plugin, which is event-driven and shells out to
+`bin/tezgah-status` rather than rendering its own segments
+(`hosts/opencode/tui/tezgah-tui.tsx:1-19`). `hosts/dsh/statusline/lib/index.js`
+serves the same line to the dsh Web UI behind dsh's own authenticated API, and
+declares which measures that host can observe (`hosts/dsh/statusline/lib/index.js:1-18`).
+
+## What runs when
+
+One session, in order. Each step names the file that handles the event on Claude
+(the reference adapter) and the core function it calls.
+
+1. **SessionStart** — `hooks/projects-auto-init.py` (`hooks/hooks.json:2-4`) calls
+   `context_for("session_start", …)` (`hooks/tezgah_context.py::context_for`), which builds
+   the always-on CORE (`hooks/tezgah_context.py::core_for`) plus this repo's live state:
+   the graph index status and the detached index spawn (`hooks/tezgah_context.py::context_for`),
+   the open plans, the sibling checkouts of a `git worktree` with their open plan
+   and research line counts (`sibling_line`, `hooks/tezgah_context.py::sibling_line`),
+   the lessons ledger, and the active kill switches. The CORE is
+   dropped when the host's own file already carries it (`TEZGAH_CORE_IN_FILE`,
+   declared by that manifest row: `~/.claude/CLAUDE.md` on Claude). Outside a
+   configured root it returns `None` and the session is untouched
+   (`hooks/tezgah_context.py::context_for`).
+2. **UserPromptSubmit** — the same file, `context_for("user_prompt", …)`
+   (`hooks/tezgah_context.py::context_for`): a turn marker for the loop guard, the per-turn
+   reminder, the conditional paragraph(s) this prompt arms
+   (`classify_prompt`, `hooks/tezgah_context.py::classify_prompt`), one line naming what moved
+   since the previous turn (`hooks/tezgah_context.py::state_delta`), up to three older
+   lessons the prompt shares words with (`relevant_lessons`, ranked by
+   `hooks/tezgah_rank.py`, or, with the opt-in `embed-mrl`/`embed-m2v` feature,
+   BM25's order plus a line by meaning above the model's cosine floor, by
+   `hooks/tezgah_embed.py`, and nothing at all while no line is older than the
+   session block's last five, see
+   [operations.md](operations.md#opt-in-embedding-relevance); each once per
+   session, remembered in the turn stamp and forgotten at a compaction),
+   and the stale-index notice (`hooks/tezgah_context.py::index_notice`).
+3. **PreToolUse** — `hooks/projects-pretooluse.py::main` calls `decision` and emits
+   the deny envelope (`hooks/projects-pretooluse.py::main`). The gate is the same
+   object on every host: `hosts/omp/hook.py::handle`, `hosts/codex/hook.py::gate_reason`.
+4. **PostToolUse** — `hooks/projects-posttooluse.py::main` writes the evidence row
+   through `note_tool` (`hooks/projects-posttooluse.py::main`), records the used
+   kind for the status line (`tezgah_context.record`, `hooks/projects-posttooluse.py::main`),
+   and attaches the untrusted-content label when the result came from outside.
+5. **Stop** — `hooks/projects-stop.py::main` calls `stop_reason`, which reads the
+   ledger and can refuse the turn (`hooks/tezgah_integrity.py::stop_reason`). omp and
+   Codex reach the same function from their own Stop events
+   (`hosts/omp/hook.py::handle`).
+
+`SubagentStart` and `PostCompact` reuse steps 1 and 2 with their own event key;
+on `subagent_start` the payload is the short brief, not the whole CORE
+(`hooks/tezgah_context.py::context_for`).
+
+## The two-tier text model
+
+| Tier | What it is | Assembled at | Paid |
+|---|---|---|---|
+| Always-on CORE | the rules every session carries: reply language, integrity, loop discipline, attribution, scope | `hooks/tezgah_policy.py::CORE`, injected by `hooks/tezgah_context.py::core_for` | once per session |
+| Conditional paragraphs | spec, consult, research, product, graph — armed by task class, in full once per session and one line on a later match | `hooks/tezgah_policy.py::CONDITIONAL_KEYS`, armed at `hooks/tezgah_context.py::context_for`, repeated as `hooks/tezgah_context.py::armed_again` | the first matching turn in full; again after a compaction or `ARMED_RESURFACE` turns |
+| Pointer line | one line per conditional rule, so a host that never sees the paragraph still knows the rule exists | `hooks/tezgah_policy.py::POINTERS`, appended at `hooks/tezgah_context.py::context_for` | once per session |
+| Per-turn reminder | the compact `<harness-reminder>` envelope | `hooks/tezgah_policy.py::PROMPT_REMINDER`, injected at `hooks/tezgah_context.py::context_for` | every user turn |
+| On-demand full contract | the deep detail — orchestration, codegen, the exact kill switches — as a skill, not a hook payload | `skills/tezgah-contract/SKILL.md`, hand-kept against the long-form blocks of `hooks/tezgah_policy.py` (`tests/test_setup.py::ContractParity`) | only when loaded |
+
+A host that carries the CORE in a static file does not pay for it twice: omp's
+managed `RULES.md` already holds it (`bin/tezgah-setup::STATIC_RULES`, `bin/tezgah-setup::rules_block`), so its session hook
+passes `with_core=False` and injects only the live state
+(`hosts/omp/hook.py::handle`, `hooks/tezgah_context.py::context_for`). opencode's
+always-on file is written from the same policy by the installer
+(`bin/tezgah-setup::opencode_contract`). The
+sum of every block is bounded per event, and when the bound is crossed the
+lowest-value blocks are dropped in a fixed order rather than the rules
+(`hooks/tezgah_context.py::DROP_ORDER`, `hooks/tezgah_context.py::budgeted`).
+
+## State: where it lives, who writes it
+
+| 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 |
+| 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 |
+
+The cache dir is resolved once per process and falls back to a temp dir on a
+sandboxed host, so one session's state never splits across two files
+(`hooks/tezgah_paths.py::cache_dir`). Per-repo state — `.tezgah/plans/open/`,
+`.tezgah/lessons.md`, `.tezgah/research/` — lives in the repository, and the
+checkout is the source from which the plugin copy is made. Each checkout of a
+repository keeps its own: a linked `git worktree` gets its own `.tezgah`, locks
+and private git repository, never a share of the main checkout's. It sees the
+others read-only - the session-start line above and `tezgah-research --all` -
+through `worktrees`, which lists `<main>/.git/worktrees/*/gitdir` with no git
+fork and skips an entry whose checkout is gone, as git's own `prunable` does
+(`hooks/tezgah_paths.py::worktrees`).
+
+## Invariants
+
+- **One definition per concept.** The contract text lives only in
+  `hooks/tezgah_policy.py`; adapters carry envelopes (`hooks/projects-auto-init.py:2-7`).
+  Host-specific copies exist only where a host cannot load Python, and those are
+  generated from the policy, not hand-kept (`bin/tezgah-setup::opencode_contract_text`).
+  Two hand-kept mirrors are the named exceptions, and a test pins each one to
+  the policy. `skills/tezgah-contract/SKILL.md` mirrors the long-form blocks
+  (`tests/test_setup.py::ContractParity`). The policy keeps no joined constant,
+  and the cost report measures the skill file itself
+  (`bin/tezgah-setup::context_budget`). `output-styles/tezgah.md` mirrors CORE.
+  Text derived from CORE, such as the subagent brief, is cut from it by rule
+  (`hooks/tezgah_context.py::BRIEF_SENTENCES`) and never re-written.
+- **A hook never takes a session down.** Every call an entry point makes into
+  the core goes through `tezgah_guard.safe`, which returns `None` and files a
+  `crash` row rather than letting the exception out: a fault costs one envelope,
+  and on omp - where the bridge turns a crash or one 10 s timeout into a
+  session-wide disable - it is what keeps the gate, the ledger and the status
+  line armed (`hooks/tezgah_guard.py::safe`, `hooks/projects-pretooluse.py::main`).
+  A host that cannot call the core in process gets the same rule in its own
+  language: opencode's plugin runs every awaited core CLI through one `collect`
+  helper with a 10 s deadline (`SPAWN_DEADLINE_MS`,
+  `hosts/opencode/plugins/tezgah.js:108-178`). Both fail open, because a core
+  that has crashed has refused nothing.
+- **The root boundary.** Every hook is inert outside a configured root:
+  a linked `git worktree` counts as inside when its main checkout is, read from
+  its `.git` pointer file rather than a git fork (`worktree_top`,
+  `hooks/tezgah_paths.py::worktree_top`), and answers its own top level so every path
+  stays under the base `root_for` returns (`hooks/tezgah_paths.py::root_for`);
+  `context_for` returns `None` (`hooks/tezgah_context.py::context_for`), the gate only acts
+  inside one (`hooks/tezgah_gate.py::decision`), and the status line is the single
+  deliberate exception, because a globally loaded rules file must still show that
+  it is armed (`hosts/omp/hook.py:40-43`).
+- **No cross-host drift.** A host shares the core, never a copy of it. Adding a
+  rule means editing the policy; adding behaviour means editing `hooks/` and
+  letting every adapter inherit it.
+- **The kill switch is the label.** Each always-on rule starts with a bold label
+  and a switch drops exactly its paragraph, so a label edit fails a test instead
+  of silently disabling a rule (`hooks/tezgah_context.py::CORE_RULES`).
+
+## Source of truth
+
+- `hooks/tezgah_context.py`, `hooks/tezgah_policy.py`, `hooks/tezgah_gate.py`,
+  `hooks/tezgah_integrity.py`, `hooks/tezgah_paths.py`, `hooks/tezgah_snapshot.py`,
+  `hooks/tezgah_untrusted.py`, `hooks/tezgah_agents.py`, `hooks/tezgah_research.py`,
+  `hooks/tezgah_index.py`
+- `hooks/hooks.json`, `hooks/projects-auto-init.py`, `hooks/projects-pretooluse.py`,
+  `hooks/projects-posttooluse.py`, `hooks/projects-stop.py`
+- `hosts/codex/hook.py`, `hosts/omp/hook.py`, `hosts/omp/tezgah-hook.ts.in`,
+  `hosts/cursor/hook.py`, `hosts/opencode/plugins/tezgah.js`,
+  `hosts/dsh/hooks.json`
+- `bin/tezgah-setup`, `bin/tezgah-status`, `statusline.py`,
+  `hosts/opencode/tui/tezgah-tui.tsx`, `hosts/dsh/statusline/lib/index.js`
+- `skills/tezgah-contract/SKILL.md`, `README.md` (Supported hosts)

package/docs/citations-baseline.json

@@ -0,0 +1,59 @@
+{
+  "bin/tezgah-docs": {
+    "unjudged": 2
+  },
+  "bin/tezgah-setup": {
+    "unjudged": 1
+  },
+  "docs/architecture.md": {
+    "unjudged": 25
+  },
+  "docs/contract.md": {
+    "unjudged": 5
+  },
+  "docs/environment.md": {
+    "unjudged": 8
+  },
+  "docs/evidence.md": {
+    "unjudged": 18
+  },
+  "docs/feature-audit.md": {
+    "unjudged": 2
+  },
+  "docs/gate.md": {
+    "unjudged": 40
+  },
+  "docs/glossary.md": {
+    "unjudged": 12
+  },
+  "docs/hosts.md": {
+    "unjudged": 62
+  },
+  "docs/layers.md": {
+    "unjudged": 14
+  },
+  "docs/operations.md": {
+    "unjudged": 21
+  },
+  "docs/skills.md": {
+    "unjudged": 7
+  },
+  "docs/status-line.md": {
+    "unjudged": 9
+  },
+  "docs/testing.md": {
+    "unjudged": 42
+  },
+  "hooks/tezgah_gate.py": {
+    "unjudged": 1
+  },
+  "tests/e2e_packaged_install.py": {
+    "unjudged": 1
+  },
+  "tests/test_docs.py": {
+    "unjudged": 4
+  },
+  "tests/test_encoding.py": {
+    "unjudged": 5
+  }
+}

package/docs/clarity-baseline.json

@@ -0,0 +1,116 @@
+{
+  "CHANGELOG.md": {
+    "long_sentences": 0,
+    "passive": 2,
+    "replace_words": 0,
+    "semicolons": 0
+  },
+  "docs/README.md": {
+    "long_sentences": 6,
+    "passive": 7,
+    "replace_words": 1,
+    "semicolons": 4
+  },
+  "docs/architecture.md": {
+    "long_sentences": 20,
+    "passive": 12,
+    "replace_words": 0,
+    "semicolons": 9
+  },
+  "docs/contract.md": {
+    "long_sentences": 40,
+    "passive": 26,
+    "replace_words": 0,
+    "semicolons": 30
+  },
+  "docs/environment.md": {
+    "long_sentences": 3,
+    "passive": 2,
+    "replace_words": 0,
+    "semicolons": 3
+  },
+  "docs/evidence.md": {
+    "long_sentences": 109,
+    "passive": 57,
+    "replace_words": 1,
+    "semicolons": 40
+  },
+  "docs/feature-audit.md": {
+    "long_sentences": 20,
+    "passive": 5,
+    "replace_words": 0,
+    "semicolons": 11
+  },
+  "docs/gate.md": {
+    "long_sentences": 67,
+    "passive": 32,
+    "replace_words": 1,
+    "semicolons": 46
+  },
+  "docs/glossary.md": {
+    "long_sentences": 51,
+    "passive": 19,
+    "replace_words": 0,
+    "semicolons": 14
+  },
+  "docs/hosts.md": {
+    "long_sentences": 36,
+    "passive": 19,
+    "replace_words": 0,
+    "semicolons": 18
+  },
+  "docs/judge.md": {
+    "long_sentences": 28,
+    "passive": 15,
+    "replace_words": 0,
+    "semicolons": 17
+  },
+  "docs/layers.md": {
+    "long_sentences": 20,
+    "passive": 16,
+    "replace_words": 0,
+    "semicolons": 6
+  },
+  "docs/models.md": {
+    "long_sentences": 19,
+    "passive": 8,
+    "replace_words": 0,
+    "semicolons": 9
+  },
+  "docs/operations.md": {
+    "long_sentences": 67,
+    "passive": 21,
+    "replace_words": 3,
+    "semicolons": 42
+  },
+  "docs/research.md": {
+    "long_sentences": 107,
+    "passive": 59,
+    "replace_words": 1,
+    "semicolons": 77
+  },
+  "docs/skills.md": {
+    "long_sentences": 31,
+    "passive": 16,
+    "replace_words": 0,
+    "semicolons": 14
+  },
+  "docs/status-line.md": {
+    "long_sentences": 44,
+    "passive": 19,
+    "replace_words": 0,
+    "semicolons": 26
+  },
+  "docs/testing.md": {
+    "long_sentences": 24,
+    "passive": 12,
+    "replace_words": 0,
+    "semicolons": 11
+  },
+  "docs/vision.md": {
+    "long_sentences": 9,
+    "passive": 7,
+    "replace_words": 1,
+    "semicolons": 12
+  }
+}