code-jig 0.12.0__py3-none-any.whl

codejig/_core/skills/redacao/checar.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+import statistics
+import sys
+import urllib.parse
+import urllib.request
+
+LT = os.environ.get("LANGUAGETOOL_URL", "http://127.0.0.1:8010")
+SKIP_RULES = {"WHITESPACE_RULE", "UPPERCASE_SENTENCE_START", "FORMAL_PRA_PARA", "REMOVER_EU_NÓS"}
+
+
+def prose(text):
+    text = re.sub(r"\A---\n.*?\n---\n", "", text, flags=re.S)
+    text = re.sub(r"```.*?```", "", text, flags=re.S)
+    url = r"\((?:[^()]|\([^()]*\))*\)"
+    text = re.sub(r"!\[[^\]]*\]" + url, "", text)
+    text = re.sub(r"\[([^\]]*)\]" + url, r"\1", text)
+    text = re.sub(r"`[^`]*`", "X", text)
+    lines = [l for l in text.splitlines() if l.strip() and not l.startswith(("#", ">"))]
+    return [l.strip() for l in lines]
+
+
+def ritmo(paragraphs):
+    body = " ".join(paragraphs)
+    sentences = [s for s in re.split(r"(?<=[.!?])\s+", body) if len(s.split()) > 1]
+    sl = [len(s.split()) for s in sentences]
+    pl = [len(p.split()) for p in paragraphs]
+    words = sum(pl)
+    cv = lambda xs: statistics.stdev(xs) / statistics.mean(xs) if len(xs) > 1 else 0.0
+    return {
+        "palavras": words,
+        "frases": len(sl),
+        "cv_frase": round(cv(sl), 2),
+        "paragrafos": pl,
+        "cv_paragrafo": round(cv(pl), 2),
+        "eu_por_100": round(100 * len(re.findall(r"\b(eu|meu|minha|me|comigo)\b", body, re.I)) / max(words, 1), 1),
+        "digitos_por_100": round(100 * len(re.findall(r"\d+", body)) / max(words, 1), 1),
+    }
+
+
+def languagetool(paragraphs):
+    data = urllib.parse.urlencode({"language": "pt-BR", "text": "\n\n".join(paragraphs)}).encode()
+    with urllib.request.urlopen(f"{LT}/v2/check", data, timeout=60) as r:
+        matches = json.load(r)["matches"]
+    for m in matches:
+        if m["rule"]["id"] in SKIP_RULES or m["rule"]["id"].startswith("PT_BARBARISMS"):
+            continue
+        ctx = m["context"]
+        frag = ctx["text"][ctx["offset"] : ctx["offset"] + ctx["length"]]
+        fix = ", ".join(x["value"] for x in m["replacements"][:3])
+        yield f'{m["rule"]["id"]}: "{frag}" -> {fix or "?"} ({m["message"]})'
+
+
+def demo():
+    p = prose("---\nt: x\n---\n# H\n\nEu fiz `a` e [b](u_(x)).\n\n> nota\n\nOutra frase curta. E mais uma aqui.\n")
+    assert p == ["Eu fiz X e b.", "Outra frase curta. E mais uma aqui."], p
+    r = ritmo(p)
+    assert r["palavras"] == 12 and r["frases"] == 3 and r["eu_por_100"] == 8.3, r
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        sys.exit("uso: checar.py artigo.md   (ou --demo)")
+    if sys.argv[1] == "--demo":
+        demo()
+        sys.exit(0)
+    paragraphs = prose(open(sys.argv[1], encoding="utf-8").read())
+    print(json.dumps(ritmo(paragraphs), ensure_ascii=False))
+    try:
+        for line in languagetool(paragraphs):
+            print(line)
+    except OSError as e:
+        print(f"LanguageTool fora do ar em {LT} ({e}); suba com: podman run -d --rm --name languagetool -p 127.0.0.1:8010:8010 docker.io/erikvl87/languagetool")

codejig/_core/skills/redacao/reference.md

@@ -0,0 +1,118 @@
+# Redação: reference
+
+## What a technical article is
+
+A blog post about how something was built is an *explanation* in Diátaxis terms: it answers "why is it like this", not "how do I do X". It can show code, but it is not a tutorial and should not turn into numbered steps. Source: https://diataxis.fr/explanation/
+
+Classic style (Pinker, *The Sense of Style*): the writer shows the reader something in the world, as one equal to another. No warm-up, no persuasion tricks, no talking about the text itself.
+
+## Structure
+
+- **Open with a fact, not a preamble.** The first two sentences carry a concrete thing: a number, a bug, a scene. Never "Neste post vou falar sobre", never "No cenário atual".
+- **Concrete before abstract.** Show the code, the number or the failure, then name the principle. A principle with no example goes.
+- **Headings say what the section shows.** "A URL decide o idioma" beats "Internacionalização". No "Introdução", no "Conclusão".
+- **A number when the number is the point.** "Rápido" means nothing; "12 páginas em 4,9 s" means something. But a paragraph with three numbers, two file names and a commit hash is a changelog: keep the one number the reader will remember and link the rest.
+- **Say what is missing.** An honest gap makes the rest credible. A list of virtues with no cost reads as an ad.
+- **End on the next concrete thing**, a limit or an open question. No summary of what the reader just read, no moral, no call to action ("Faz isso no seu site").
+- **Someone is talking.** The author has opinions, gets annoyed, is wrong, is unsure. A text where every sentence is a verified neutral fact has no one in it.
+
+## Portuguese (pt-BR)
+
+Each rule with a bad → good pair.
+
+| Rule | Ruim | Bom |
+|---|---|---|
+| Verb over noun (nominalização) | realizar a implementação do cache | implementar o cache |
+| No gerundismo | vamos estar analisando | vamos analisar |
+| "Onde" only for places | o teste onde o erro aparece | o teste em que o erro aparece |
+| No "a nível de" | a nível de arquitetura | na arquitetura |
+| No "o mesmo" as pronoun | abri o arquivo e editei o mesmo | abri o arquivo e o editei |
+| Active voice with a subject | foi decidido que o CI roda o lint | decidi que o CI roda o lint |
+| "Se" impessoal sparingly | percebe-se que o build falha | o build falha |
+| Short sentences, one idea each | a sentence of 45 words with three "que" | split it |
+| Crase | devido à isso / referente a página | devido a isso / referente à página |
+| Hyphen, 2009 agreement | auto-avaliação, anti-padrão | autoavaliação, antipadrão |
+| Decimal comma, unit spaced | 4.9s, 50 % | 4,9 s, 50% |
+
+English terms: use the word the Brazilian developer says (*build*, *deploy*, *commit*, *bundle*, *lint*). Do not italicise them and do not force a translation nobody uses ("implantação" for deploy reads like a manual). Translate when Portuguese has a word in daily use: *teste*, *ilha* (Astro island), *janela*, *acessibilidade*. Code identifiers go in backticks and are never translated.
+
+Person: first person singular for a personal blog ("eu medi"). "A gente" fits a casual register; pick one and keep it. Address the reader as "você".
+
+## AI tells
+
+Habits that make prose worse, whoever wrote it. Remove on sight. Full list in English: https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing (the `humanizer` skill covers it, if installed).
+
+- **Contrast that only adds weight**: "não é apenas X, é Y", "não se trata de X, mas de Y", "mais do que X, é Y". State Y.
+- **Stock words**: crucial, fundamental, essencial, robusto, jornada, mergulhar, desvendar, no cenário atual, em um mundo, vale ressaltar, é importante destacar, em suma, em resumo, por fim mas não menos importante, transformador, potencializar, alavancar, ecossistema (outside its technical sense).
+- **Triads by reflex**: three adjectives or three clauses where the meaning has one or two.
+- **Dashes as the universal connector**: use a comma, a colon, parentheses or a full stop. At most one pair of dashes per article, and only for a real aside.
+- **Closing one-liners**: a paragraph that ends with a short sentence repeating its point ("E isso faz toda a diferença.").
+- **Staged run-up**: "A verdade é que", "O ponto é", "Aqui está o segredo:".
+- **Bold labels and decorative lists**: prose that became bullets with a bolded first word. An article is paragraphs; a list only for things that are genuinely a list.
+- **Connector piles**: "além disso", "dessa forma", "nesse sentido" opening consecutive paragraphs.
+- **Inflated significance**: "um marco", "revolucionou", "mudou completamente". Say what changed and by how much.
+- **Talking about the text**: "neste artigo", "como vimos acima", "vamos explorar".
+
+### Structural tells
+
+Avoiding the words above is not enough: a model that drops "crucial" and every dash still writes in its own shape. These came from a draft that had none of the word-level tells and still read as machine-made from the first line.
+
+- **Even rhythm.** Every paragraph four to six sentences of similar length, each built the same way (claim, evidence, consequence). Vary on purpose: a one-line paragraph next to a long one, a long sentence that wanders when the thought wanders, a fragment.
+- **Inventory paragraphs.** "Um confere... Outro garante... Outro checa... E tem um que...", "Pra mim, X quer dizer cinco coisas", a list of facts walked through in prose. Pick the one example that matters and tell it.
+- **Fact density.** Identifiers, counts and commit hashes in every paragraph. The reader cannot hold them; link the commit, keep the story.
+- **Narrator without a person.** No opinion, no joke, no doubt, no "eu achava". Everything reported, nothing felt.
+- **Borrowed informality.** "tá" and "pra" sprinkled over formal syntax. The register is the author's, taken from their own text, and it holds through the whole article.
+- **Researched trivia.** A book's publication year, a spec's exact threshold, commit counts per year: facts the author never lived and would never say. A fact belongs when the author did it, used it or hit it.
+- **Swallowed scope.** The article grew to hold everything the apuração found. One idea per post; the rest is the next pauta.
+
+### On AI detectors
+
+Detectors are classifiers trained on model output. They flag predictable, even prose, and they also flag formal or non-native human writing: seven detectors marked 61% of TOEFL essays by human writers as AI (Liang et al., 2023: https://arxiv.org/abs/2304.02819). Do not chase a score and never rewrite to fool one. A flagged draft is a symptom that the author is missing from the text; the fix is the entrevista, not synonyms.
+
+## Checklist before the editor's last aprova
+
+1. Every number and name is in the fact sheet with a source.
+2. The first two sentences carry a concrete fact.
+3. No heading is generic.
+4. No paragraph ends in a one-line moral.
+5. None of the AI tells above. Search the text for "não é apenas", "crucial", "-", "além disso", "jornada".
+6. Every paragraph is one line in the file (no hard wrap).
+7. At least one honest limit is stated.
+8. Code in backticks, identifiers untranslated, decimal comma in prose.
+9. Every section carries something from the entrevista or the author's own text, and no feeling, habit or reason was invented for them.
+10. Paragraph lengths vary; no three paragraphs in a row share the same shape.
+11. The word count is within the pauta's target, and the scope is still the author's idea.
+12. No closing summary section and no call to action.
+
+## Reading list
+
+Portuguese, writing:
+
+- Othon M. Garcia, *Comunicação em Prosa Moderna* (FGV). The Brazilian classic on building a paragraph and an argument.
+- *Manual de Redação da Presidência da República*, 3ª ed.: https://www.gov.br/planalto/pt-br/conheca-a-presidencia/manual-de-redacao-da-presidencia-da-republica. Clarity, concision, the "o mesmo" and gerund rules.
+- *Manual de Comunicação da Secom do Senado*: https://www12.senado.leg.br/manualdecomunicacao. A newsroom style guide with one entry per style question (datas, maiúsculas) and a guide on using AI in writing.
+- Microsoft pt-BR localization style guide (in the list): https://learn.microsoft.com/en-us/globalization/reference/microsoft-style-guides. How a large tech company handles English terms, "você" and capitalisation in Portuguese.
+
+Portuguese, technical writing worth reading:
+
+- Fabio Akita: https://akitaonrails.com/. Long-form, opinionated, full of numbers and real setups.
+- Elton Minetto: https://eltonminetto.dev/. Short, direct Go and architecture posts.
+- Lucas Santos: https://lsantos.dev/. Clear explanations of Node.js and TypeScript.
+- Building Nubank: https://building.nubank.com/pt-br/. Engineering blog that writes for engineers, not recruiters.
+- TabNews: https://www.tabnews.com.br/. Uneven, but shows what Brazilian developers actually read and discuss.
+
+English, on writing:
+
+- Google Technical Writing One and Two: https://developers.google.com/tech-writing
+- Paul Graham, "Write Simply": https://paulgraham.com/simply.html
+- Julia Evans, "Some tactics for writing in public": https://jvns.ca/blog/2023/08/07/tactics-for-writing-in-public/
+- Dan Luu, "Writing non-advice": https://danluu.com/writing-non-advice/
+- Steven Pinker, *The Sense of Style* (2014).
+
+References often cited in articles about reliability:
+
+- Google SRE book: https://sre.google/sre-book/table-of-contents/
+- Kent C. Dodds, the testing trophy: https://kentcdodds.com/blog/the-testing-trophy-and-testing-classifications
+- Ham Vocke, "The Practical Test Pyramid": https://martinfowler.com/articles/practical-test-pyramid.html
+- Core Web Vitals: https://web.dev/articles/vitals
+- WCAG 2.2: https://www.w3.org/TR/WCAG22/

codejig/_core/skills/regression-tests/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: regression-tests
+description: Use when fixing a bug, changing behaviour or adding a feature in code that has tests, or when the user asks whether a change is covered by tests, wants regression tests, or wants coverage of the changed lines.
+---
+
+# Regression tests
+
+Every behaviour change ships with a test that fails without the change and passes with it.
+
+## Bug fix
+
+1. Write the smallest test that reproduces the bug through the public interface.
+2. Run it and watch it fail for the reason in the bug report, not for a typo or a missing import.
+3. Fix the code, not the test.
+4. Run the test, then the whole suite.
+
+## New or changed behaviour
+
+Write the test first, watch it fail, implement, watch it pass. When the change comes from a requirement, tag the test with its ID (see the `hld-trace` skill).
+
+## Follow the repo
+
+Put tests where the repo already keeps them, with its framework, naming and fixtures. Do not add a test framework the repo does not use.
+
+## Coverage of the changed lines
+
+[diff-cover](https://github.com/Bachmann1234/diff_cover) reads a Cobertura XML report and lists the changed lines no test executes. Install it with `pip install diff-cover`.
+
+| Stack | Produce `coverage.xml` |
+|---|---|
+| Python | `coverage run -m pytest`, then `coverage xml` (in PowerShell 5.1, which has no `&&`: `coverage run -m pytest; coverage xml`) |
+| .NET | `DOTNET_CLI_TELEMETRY_OPTOUT=1 dotnet test --collect:"XPlat Code Coverage"` writes `TestResults/*/coverage.cobertura.xml` |
+| Node with c8 | `npx c8 --reporter=cobertura npm test` writes `coverage/cobertura-coverage.xml` |
+| Vitest | `npx vitest run --coverage --coverage.reporter=cobertura` writes `coverage/cobertura-coverage.xml` |
+| Jest | `npx jest --coverage --coverageReporters=cobertura` writes `coverage/cobertura-coverage.xml` |
+
+Windows PowerShell has no `NAME=value command` form: write the variable first in the same command, for example `$env:DOTNET_CLI_TELEMETRY_OPTOUT = '1'; dotnet test --collect:"XPlat Code Coverage"`.
+
+Then:
+
+```
+diff-cover <report.xml> --compare-branch=origin/main --include-untracked
+```
+
+Pass several reports at once for a multi-stack repo. Every uncovered changed line is either covered by a new test or explained: generated code, logging, a branch that only a real outage reaches.
+
+## Is the test good enough
+
+A test that never fails proves nothing. For important logic, run mutation testing on the changed files (the `bug-hunt` skill): a surviving mutant is a regression the tests would miss.
+
+## Report
+
+Name the test that failed before the change and passes after it, the full suite result, and each changed line diff-cover listed with the test that now covers it or the reason it stays uncovered.

codejig/_core/skills/remove-ai-attribution/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: remove-ai-attribution
+description: "Use when AI attribution leaked into git history - \"Co-authored-by: Codex\", \"Co-Authored-By: Claude\", \"Generated with\" lines in commit messages - and must be removed without changing anything else, when the user asks to scrub or purge AI or co-author marks from commits, or when a push is refused because \"commit messages carry AI attribution\"."
+---
+
+# Remove AI attribution
+
+A safety net, not the rule: the rule (no AI attribution anywhere) is in the base instructions, and the git gate strips trailers before they land. Use this only when attribution already reached commits.
+
+`code-jig scrub` decides everything; do not re-derive its work from git logs. It rewrites commit messages only, only on commits by the user (`git config user.email`, every `codejig.email`, and each `--author`), checks that trees, authors, committers and dates are unchanged, restores every ref if that check fails, and is deterministic: the same history gives the same new SHAs on every clone.
+
+## Procedure
+
+1. `code-jig scrub --dry-run` in the repo lists the commits that carry attribution. Nothing listed: stop.
+2. Show the list and get a yes for this repo.
+3. `code-jig scrub`. It saves a backup bundle in the git directory first and prints its path: that is the safe point. Keep the path in the reply. It rewrites local branches and tags, prints one `git push --force-with-lease=...` command per branch, and never pushes.
+4. Pushing rewrites shared history. Get a yes for each push command, then run it exactly as printed: the lease refuses the push if someone pushed in the meantime.
+5. Other clones: never repair them by hand. In each one, with a yes, run this procedure from step 1. Scrub gives the same SHAs there, so after `git fetch`, `git status -sb` shows the branch even with its upstream and there is nothing to push. Anything else (ahead, behind or diverged) means that clone has its own commits: stop and ask the user.
+6. Old commits stay reachable by SHA on the server (and in pull request refs) until the host garbage-collects them. Say so; removing them needs the hosting admin or recreating the repository, which only the user decides.
+
+## Undo
+
+Before pushing, the backup restores every branch and tag: `git fetch --update-head-ok <bundle> "+refs/heads/*:refs/heads/*" "+refs/tags/*:refs/tags/*"`. After pushing, restoring needs another lease-protected push, which only the user decides.
+
+## Common mistakes
+
+| Mistake | Instead |
+|---|---|
+| Rewriting other people's commits | Only the user's identities; pass `--author` for an old address of the user, never for someone else. |
+| `git push --force` | Only the printed `--force-with-lease` commands. |
+| `--no-verify` to get past the gate | Scrub, then push normally. |
+| Resetting other clones to the remote | Run this procedure in each clone (step 5); a clone that differs is the user's call. |
+| Deleting the backup bundle | Keep it until every clone matches the remote. |

codejig/_core/skills/skill-validate/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: skill-validate
+description: Use when a SKILL.md is about to ship or was just edited, when a skill is reviewed or audited, when a skill seems ignored, skipped or misread by agents, or when the user says "validate this skill", "lint the skill", "check my skill", "is this skill any good".
+---
+
+# Validate a skill
+
+Three passes. A script decides everything a pattern can decide; a reviewer from another model family decides the rest, in a fresh context, because the author of a skill already knows what it meant to say.
+
+## Pass 1: mechanical
+
+```sh
+code-jig lint-skill path/to/skill-dir
+```
+
+`FAIL` breaks loading or a hard rule and exits 1. `WARN` is a judgement call. Run pass 2 whatever pass 1 says: its FAILs go in the report with everything else.
+
+## Pass 2: judgement
+
+This skill asks for a subagent: call `spawn_agent` with `agent_type` `reviewer` and a message holding the full SKILL.md text and this rubric, then wait for it. Do not fork this conversation into it, and do not judge the rubric yourself instead.
+
+| # | Rule |
+|---|---|
+| 1 | The description states triggering conditions only. A description that summarises the workflow becomes a shortcut agents take instead of reading the body. |
+| 2 | Every rule the skill enforces is reachable from the body, not only from the description. |
+| 3 | Guidance matches the failure: a rule broken under pressure needs a prohibition and the excuses it answers; wrong-shaped output needs a recipe naming the parts in order; an omitted element needs a slot in a template. |
+| 4 | No clause that reopens a rule ("unless it matters", "where appropriate"). |
+| 5 | No narrative: no session logs, dated stories, "we found this once". |
+| 6 | Reference an agent can act on, not the author's reasoning. |
+| 7 | One worked example, not the same pattern repeated per language. |
+| 8 | Flowcharts only for non-obvious decisions; tables and lists carry reference. |
+| 9 | Words a searching agent would type appear early: error strings, symptoms, tool and command names. |
+| 10 | Heavy reference and scripts sit in their own files, named from SKILL.md. |
+
+Require one line per rule, `N | PASS or FAIL | shortest quote that decides it | one-line fix`, then `VERDICT: ship` or `VERDICT: fix N, N`. Prose instead of rows means the contract was not stated firmly enough: restate it and spawn again.
+
+## Pass 3: Codex runs it
+
+A skill that reads well can still name tools Codex does not have, or never trigger. After pass 2 says `VERDICT: ship` and the skill is installed (`code-jig install`); when pass 2 says fix, skip pass 3 and report it as skipped because pass 2 failed:
+
+```sh
+code-jig skill-check path/to/skill-dir --review --live
+```
+
+It needs an `evals.toml` next to SKILL.md with at least one `[[case]]` (`prompt`, and any of `commands`, `output`, `spawns`, `fixture`, `commits`, `sandbox`). It runs a Codex review on the `review` tier, then each case through `codex exec`, and writes `.skill-check` when everything passes. In the code-jig repository that stamp is required in the same commit as the skill.
+
+## Report
+
+Merge all three passes into one table: every FAIL and WARN, every rubric row, the Codex review verdict and each live case. Validation edits nothing in the skill; the only file it writes is the `.skill-check` stamp from pass 3. When the user asks for the fixes, apply them and run all three passes again.
+
+## Common mistakes
+
+| Mistake | Instead |
+|---|---|
+| Judging in the context that wrote the skill | Pass 2 runs in a fresh `reviewer`. |
+| Treating every WARN as a defect | A reference skill may be long; the word count prompts a split, it does not demand one. |
+| Accepting "looks good" | The contract is rows with quotes. No quote means it was not read. |
+| Skipping pass 2 | No pattern can see a description that summarises the workflow, the defect that costs the most. |

codejig/_core/skills/web-consensus/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: web-consensus
+description: Use when a question has to be settled against the live web rather than from memory - researching a topic, proving or disproving a claim, checking whether something is still true, a sourced second opinion on a factual question - or when the user says "research", "prove it", "with sources", "check if this is true", "still accurate?".
+---
+
+# Web consensus
+
+Cheap researchers gather evidence in parallel, a reviewer from another model family attacks it, the disputed points are researched again from scratch, a script checks every link and quote, and a judge on the strongest model writes the verdict from sources only.
+
+## Who does what
+
+| Step | Subagent role | Runs on |
+|---|---|---|
+| Evidence, cold verification | `explorer`, one per angle or question, in parallel | `bulk` tier: fast and cheap |
+| Challenge | `reviewer` | `review` tier: another model family |
+| Link and quote check | `code-jig check-sources` | no model |
+| Verdict | `judge` | `deep` tier: the strongest model |
+
+This skill asks for subagents: every role in the table runs through `spawn_agent` with that `agent_type`, even when you wait for its result before the next step, because the point is a different model and a fresh context, not speed. Each subagent gets its own brief and nothing about the others, so no role can quietly agree with another, and never a fork of this conversation. You only route: write the evidence files, run the script, pass material between roles. Run the whole flow even when the answer looks obvious or one page settles it: "it's a simple fact", "the docs already say it" and "one search is enough" are the answers from memory this skill replaces. If `spawn_agent` is not available in this session, stop and say so: a consensus from one model playing every role is not this skill's output, so do not play the roles yourself.
+
+## Flow
+
+1. **Evidence.** One `explorer` per angle. Each returns claim / URL / exact quote triples and nothing else. Write them to `evidence-<angle>.jsonl` in the workspace, one JSON object per line: `{"claim": "...", "url": "...", "quote": "..."}`.
+   - `direct`: the question as asked.
+   - `disconfirming`: the strongest evidence that the expected answer is wrong: corrections, retractions, errata, dissenting primary sources.
+   - `primary-source`: official docs, specifications, source code, changelogs and papers only.
+   - `academic`, when the question has a research literature: papers, reproductions, negative results.
+
+   Vary the wording of the searches between angles. The same index returns very different results for differently worded questions.
+
+2. **Check.** `code-jig check-sources "evidence-*.jsonl"` (the command expands the pattern itself, so the same line works in PowerShell). It fetches each URL once and reports per claim: `ok` (the page contains the quote), `quote-missing`, `dead`, `blocked` (401/403/429: usually bot-blocking, not absence), `unreadable` (PDF or binary: quote unverified). It needs the network: in a sandbox, ask for escalation on the first run, not after a refusal. When the workspace is read-only, pipe the lines in and pass `-` as the file (`printf '%s\n' "$line1" "$line2" | code-jig check-sources -`, in PowerShell `$lines | code-jig check-sources -`), and hand the evidence to the later roles inline in their briefs. One run covers every file. When it runs, the final reply quotes its summary line (`N claims: ...`) exactly as printed. If it still cannot run, nothing is checked: say so, the verdict's first line is `UNVERIFIED:` and no claim is agreed.
+
+3. **Challenge.** A `reviewer` reads the evidence files and the check report, and is told not to search. Its brief asks for a sweep before anything else: one line per claim, in order, none skipped or merged. `MISMATCH` when the quote does not contain what the claim asserts, `DOUBT` when the quote alone cannot tell (a number, a name, a baseline or a causal link it never states), `OK` only when the quote plainly carries the whole claim, each claim judged against its own quote. The sweep comes first because a reviewer that picks its findings first stops at the few defects that caught its eye. Tell it that a wrong flag costs one rebuttal while a fabrication it lets pass reaches the user as fact, so it flags every claim its quote does not plainly establish, and never invents a mismatch. Then it lists the questions that would settle each dispute.
+
+4. **Cold verification.** For each of those questions, a fresh `explorer` gets only the question: no evidence and no challenge. Write its triples to `evidence-cold.jsonl` and run the check on it. When the challenge lists no disputes, skip this step and say so in the report; there is then only the first check report.
+
+5. **Verdict.** A `judge` gets the question, every evidence file, every check report (one, or two after cold verification) and the challenge. It answers in a short paragraph, then lists agreed, disputed and unsourced claims with URL and quote, its confidence, and what new evidence would change the answer. Relay the verdict; do not rewrite it, and never add that sources are independent.
+
+## Rules
+
+- A claim can only be agreed when `check-sources` says `ok`, or `unreadable` with the quote confirmed by a second source.
+- The searcher never dictates the answer alone. Evidence files from the same search are not independent sources; say how many distinct sites agree.
+- Prefer primary sources over secondary ones, and recent over old when the subject moves.
+- When results look stale, ask the user to start the session with live search (`codex -c web_search="live"`).
+- If web search is not available in this session, say so and stop. Do not answer from memory.
+
+## Common mistakes
+
+| Mistake | Instead |
+|---|---|
+| Answering from one search because the question looks easy | Run every step; the user asked for sources checked by roles that did not write them. |
+| Forking this conversation into a researcher | A fresh brief; a fork re-reads everything and inherits your bias. |
+| Judging in the main session | The `judge` role exists so the verdict runs on the strongest model whatever tier this session uses. |
+| Treating `blocked` as `dead` | Say it was blocked; find a second source or quote it as unverified. |
+| Paraphrasing in the `quote` field | The check needs the exact words on the page. |