done-done-axi 0.4.2 → 0.4.4

package/README.md

@@ -1,17 +1,36 @@
 <div align="center">
 
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="docs/media/wordmark-dark.svg">
-  <img src="docs/media/wordmark-light.svg" alt="done-done" width="300">
-</picture>
+<img src="docs/logo.svg" width="72" height="72" alt="done-done logo">
+
+# done-done
 
 ### No proof, no "done".
 
+**[Landing page](https://umeranjum17.github.io/done-done-axi/)**
+
 done-done won't accept "done" without real, fresh proof from your product, captured at the exact commit being called done.
 
 [![Node 22.18+](https://img.shields.io/badge/node-22.18%2B-3fb950?logo=nodedotjs&logoColor=white)](https://nodejs.org) [![Status: early preview](https://img.shields.io/badge/status-early%20preview-d29922)](#whats-next) [![npm: done-done-axi](https://img.shields.io/npm/v/done-done-axi?logo=npm&logoColor=white&label=npm)](https://www.npmjs.com/package/done-done-axi)
 
-<br>
+</div>
+
+## Install in 3 steps
+
+You need Node 22.18 or later and git.
+
+```sh
+npm install -g done-done-axi
+cd your-app && done-done init
+done-done doctor
+```
+
+1. **Install.** This puts `done-done` (and the long name `done-done-axi`) on your PATH. No `sudo`? Add `--prefix ~/.local` and put `~/.local/bin` on your `PATH`.
+2. **Set up your repo.** `init` writes a minimal `.done-done.yaml` and asks you, in a terminal, which coding agent and which judge to use. done-done never picks either for you. Outside a terminal, pass `--agent <agent> --model <model> --judge <agent> --judge-model <model>` instead.
+3. **Check the setup.** `doctor` changes nothing and names each missing piece with the exact command that fixes it.
+
+Then prove something: `done-done verify --outcome "<what a user can now do>"`. [Manual CLI](#manual-cli) below walks through journeys, `check` and `receipt`.
+
+<div align="center">
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="docs/media/flow-dark.svg">
@@ -59,7 +78,7 @@ npx skills add umeranjum17/done-done-axi --skill done-done -a <agent> -y
 
 `<agent>` is `claude-code`, `codex`, `opencode`, `pi` or `gemini-cli`. `-a` and `-y` skip the installer's four prompts and keep it from writing skill folders for agents you do not use.
 
-The skill lands in this project (`.claude/skills/done-done/` for Claude Code, `.agents/skills/done-done/` for Codex, opencode, Pi and Gemini CLI) next to a `skills-lock.json`: commit both so teammates and CI get it too. Or add `-g` to install it once for all your projects (for example `~/.claude/skills/` for Claude Code) and leave the project untouched.
+The skill lands in this project (`.claude/skills/done-done/` for Claude Code, `.agents/skills/done-done/` for Codex, opencode, Pi and Gemini CLI) next to a `skills-lock.json`: commit both so your teammates get it too. Or add `-g` to install it once for all your projects (for example `~/.claude/skills/` for Claude Code) and leave the project untouched.
 
 That is the entire setup - no npm install needed.
 The skill tells your agent to use `done-done` if it is on PATH and otherwise run the npm package through `npx`, so the CLI comes along on demand:
@@ -68,7 +87,7 @@ The skill tells your agent to use `done-done` if it is on PATH and otherwise run
 npx -y done-done-axi --help
 ```
 
-The skill stays a short stub and sends the agent to `--help` and the bare command for current instructions, so an installed copy cannot go stale against a newer CLI.
+The skill is a short stub and sends the agent to `--help` and the bare command for current instructions, so an installed copy cannot go stale against a newer CLI.
 
 Then, in agents that expose skills as slash commands (Claude Code, for example), invoke it directly:
 
@@ -101,7 +120,7 @@ cd your-app
 done-done init
 ```
 
-`init` writes a minimal `.done-done.yaml` (only if you don't already have one) that names your app, and a commented global `~/.done-done/config.yaml` (only if there is none). done-done never picks the coding agent it starts: `init` asks you in a terminal, or takes `--agent <agent> --model <model>`. It never picks the judge either, the agent of its own that `check`, `receipt`, `verify` and `design` always start to look at each capture: `init` asks in a terminal, or takes `--judge <agent> --judge-model <model>`. Any agent and model you choose runs, your coding agent's own too (the judge is a fresh session of its own). The config keys are in the [reference](docs/reference.md#config). A plain `init` never overwrites an existing config. It writes no verify skill: write `.agents/skills/verify-<app>/SKILL.md` by hand, with a launch that never touches real accounts or your own state. Evidence lives outside the repo, in `~/.done-done/evidence/<app>`, so it outlives the checkout that captured it. For an `answerer:pi` judge with no explicit model, done-done uses `openai-codex/gpt-6-luna`; `judge.model` or `agent_config.pi.model` overrides it. Then describe how to capture proof — swap the command for whatever drives your real app and saves screenshots, recordings or logs:
+`init` writes a minimal `.done-done.yaml` (only if you don't already have one) that names your app, and a commented global `~/.done-done/config.yaml` (only if there is none). done-done never picks the coding agent it starts: `init` asks you in a terminal, or takes `--agent <agent> --model <model>`. It never picks the judge either, the agent of its own that `check`, `receipt`, `verify` and `design` always start to look at each capture: `init` asks in a terminal, or takes `--judge <agent> --judge-model <model>`. Any agent and model you choose runs, your coding agent's own too (the judge is a fresh session of its own). The config keys are in the [reference](docs/reference.md#config). A plain `init` never overwrites an existing config. When your coding agent is set, `init` also has it write a verify skill, `.agents/skills/done-done-verify-<app>/SKILL.md`, from the repo's own files (never overwriting one; with no agent set, no skill is written; an older `verify-<app>` skill is renamed to this once). Check its launch never touches real accounts or your own state. Evidence lives outside the repo, in `~/.done-done/evidence/<app>`, so it outlives the checkout that captured it. For an `answerer:pi` judge with no explicit model, done-done uses `openai-codex/gpt-6-luna`; `judge.model` or `agent_config.pi.model` overrides it. Then describe how to capture proof — swap the command for whatever drives your real app and saves screenshots, recordings or logs:
 
 ```yaml
 journeys:
@@ -158,18 +177,29 @@ Run `done-done` with no arguments to see the current config and the next step.
 - ⏱️ **Fresh**: Proof from an older commit fails. Commits that only touch docs can be set to keep it fresh.
 - ♻️ **Not reused**: Proof made only of files already used for a different claim fails, and so does citing the same file twice. A claim is named by `--claim-id <id>`, which defaults to your branch, so rewording it keeps its proof. Several claims on one branch each need their own `--claim-id`.
 - 🧾 **Honest claims**: Reads a pull request's `## Checks` block — from a file, a URL, or stdin — and makes sure every line is filled in.
-- 📌 **Verifiable later**: `receipt` records a passing check against the exact commit and the sha256 of every file it cited; `receipt --verify` re-checks it from any checkout of that commit on the same machine (a merge gate or a fresh clone), or in CI once the evidence folder is copied there ([how](docs/reference.md#where-proof-lives)).
+- 📌 **Verifiable later**: `receipt` records a passing check against the exact commit and the sha256 of every file it cited; `receipt --verify` re-checks it from any checkout of that commit on the same machine (a merge gate or a fresh clone) ([how](docs/reference.md#where-proof-lives)).
 - 👀 **Shows the outcome** (always): `check`, `receipt` and `verify` start done-done's own judge, a fresh, tools-off agent on your own plan or key (Claude Code, opencode, pi or Gemini CLI, or your own OpenAI API key), to say whether each capture is the right screen for the claim (and each text capture, such as a log, JSON or CLI output, the right output), and a wrong one fails. There is no way to turn it off: done-done gives no result without it. The checks above never pass on their own, and a check that cites only files the judge cannot read (a video) stops before the judge, with exit 2. You choose the judge route (`done-done init --judge <agent> --judge-model <model>`, or pick it from the list done-done shows in a terminal; `done-done check --judge <route>` overrides it for one call); for a Pi judge with no explicit model, done-done defaults to `openai-codex/gpt-6-luna` unless `agent_config.pi.model` is set. Any agent and model you choose runs, your coding agent's own too. A judge that fails or times out stops the command with its cause (exit 2; a `verify` run stops with exit 2 and its cause in the run record), and no receipt is written.
 - 🎨 **Looks right**: `done-done design <screens...> [--mock <screen>=<mock>]` has the same judge look at each captured screen, alone or next to its approved mock, and fails it on stretched or squashed images, clipped or squashed text, overlap, elements off-screen, blank or black strips and broken layout, naming each defect and where it is ([how](docs/reference.md#design-check)).
 - 📐 **Fits the screen**: `done-done look <url>` opens a web page in headless Chrome at a 390x844 phone viewport, captures it, and fails the journey that calls it on squashed text, clipped text, elements cut off by an edge or a page wider than the screen, naming each element, with no model ([how](docs/reference.md#look-check)).
 - 🧮 **Honest, cheap claim gate**: `done-done lint <PR URL | report file> <evidence folder>` is a no-model gate on a worker's `## Checks` block, on whenever you call it. It prints `PASS` or `FAIL: <reason>` and exits 1 on a fail: the four lines present, proof naming a command or path, a real repro on a fix PR, evidence files that exist, are non-empty, are newer than the evidence folder and differ from each other, at least one never used by another PR (hashes kept in `~/.done-done/lint.hashes`, every run logged to `lint.log` there), and under 1,000 added non-generated lines ([how](docs/reference.md#lint-check)). `evidence: not proven: <cause>` passes.
+- 🚦 **CI gate, no model**: `done-done gate [<head>]` passes when a receipt committed under `.done-done-receipts/` covers the head, with no judge, config, key or evidence files. CI never runs `check`, `run` or `verify` and never gets a model key; proof runs on your desktop ([how](docs/reference.md#ci-gate)).
 - 🧩 **Page is clean** (with a `dom` block): each captured screen also needs its page-check record. A page that overflows the viewport, logs a console error, has a failed request or shows squashed, clipped or cut-off UI fails, unless an allow list names it ([how](docs/reference.md#dom-assertions)).
-- 🔒 **Safe in CI**: `--trusted-ref origin/main` reads the rules from your main branch, so a pull request can't loosen them.
 
 Every answer is an exit code: **0** pass, **1** fail, **2** usage or config error (including no agent or judge set, a check that fails before its judge, a capture the judge cannot be sent, or a judge that did not answer: never a result), **3** can't tell either way, **4** a `verify`, `maintain` or `rerun` run is still running, or a `verify` run waits at its gate.
 
+## Alone, and with the other tools
+
+done-done works on its own: the CLI and the skill need nothing else. It is one of three tools that each do one job and connect through small written contracts ([Vision](VISION.md)):
+
+- [`sign-off-axi`](https://www.npmjs.com/package/sign-off-axi): the board where agents ask you questions. `done-done signoff` writes a run's gate (when the judge was unsure) or its evidence in sign-off's message format and prints the post command; it never posts. Without sign-off you answer at the terminal with `done-done respond`.
+- [`learn-from-mistakes-axi`](https://www.npmjs.com/package/learn-from-mistakes-axi): the retro tool that finds mistakes your agents keep repeating, with evidence. Neither tool needs the other.
+- [`first-draft-axi`](https://www.npmjs.com/package/first-draft-axi): turns a prompt into design mocks. Pass a mock to `done-done design <screen> --mock <screen>=<mock>` to judge a captured screen next to it.
+
 ## Use with Firstmate or another agent fleet
 
+done-done works the same with or without Firstmate: nothing below is needed to use it, and the skill and CLI behave identically inside or outside a Firstmate home.
+
+
 [Firstmate](https://github.com/kunchenguid/firstmate) hands tasks to agent workers and merges their work. done-done ships what those workers need to prove each task, and what the merge needs to check that proof, in [`integrations/firstmate/`](integrations/firstmate/).
 
 Install the skill once per machine for your workers' agent (the same `-a` values), install the CLI from npm, and copy two files from it into your Firstmate home:
@@ -195,7 +225,7 @@ Another fleet works the same way: add the include text to whatever your workers
 
 ## What's next
 
-So far: `init`, `doctor`, `run` (including `--open` and `--close`), `check`, `receipt`, `verify` (by journey or by your coding agent, with a gate you answer with `respond`), `maintain`, the capture judge (always on), the `design` visual check, the `look` step, the run tools (`status`, `attach`, `logs`, `rerun`, `abort`, `signoff`, `history`) and the opt-in session hooks for Claude Code, Codex, opencode, Gemini CLI and pi. Coming next: help writing the proof steps for your app.
+So far: `init`, `doctor`, `run` (including `--open` and `--close`), `check`, `receipt`, `lint` (a no-model gate on a Checks block), `gate` (a no-model CI check of a committed receipt), `verify` (by journey or by your coding agent, with a gate you answer with `respond`), `maintain`, the capture judge (always on), the `design` visual check, the `look` step, the run tools (`status`, `attach`, `logs`, `rerun`, `abort`, `signoff`, `history`) and the opt-in session hooks for Claude Code, Codex, opencode, Gemini CLI and pi. Coming next: help writing the proof steps for your app.
 
 ## Develop
 
@@ -206,7 +236,7 @@ npm install
 npm install -g --prefix ~/.local .   # optional: links this checkout as done-done on your PATH
 npm test   # builds, then runs the end-to-end tests against throwaway git repos
 npm run build:skill              # regenerate skills/done-done/SKILL.md from src/skill.ts
-npm run build:skill -- --check   # fail if the committed skill is out of date (CI runs this)
+npm run build:skill -- --check   # fail if the committed skill is out of date
 ```
 
 To try an unreleased commit without cloning, run it straight from GitHub (npm 12 needs `--allow-git=all`):
@@ -217,4 +247,6 @@ npx -y --allow-git=all github:umeranjum17/done-done-axi --help
 
 `dist/` is committed, so installing from GitHub needs no build step. `npm test` rebuilds it and fails while the rebuilt `dist/` differs from the commit or has files git does not track, so `git add` the new `dist/` files with your change.
 
-The terminal pictures (hero, run, pass, reasons, config) are real output from the current build, with a stub judge (no model); redraw them with `npx tsc && node docs/media/make.mjs`. The wordmark and the flow picture are hand-made SVGs.
+The terminal pictures (hero, run, pass, reasons, config) are real output from the current build, with a stub judge (no model); redraw them with `npx tsc && node docs/media/make.mjs`. The logo (`docs/logo.svg`) and the flow picture are hand-made SVGs.
+
+The landing page ([`docs/index.html`](docs/index.html), served by GitHub Pages from `main` `/docs`) is static: change it in the same PR as any README change it repeats (install steps, what it checks, the other tools).

package/dist/cli.js

@@ -34,7 +34,7 @@ const JOURNEYS_TEXT = `journeys (.done-done.yaml): the command runs with DONE_DO
 const CHECKS_TEXT = `Checks block (--from): the newest "## Checks" heading, then these four keys, each at the start of a line:
   outcome: <what a user can now do>
   repro: <command that failed before and passes now, or n/a; a fix PR needs one>
-  proof: <the command or path that drove the real product; name the repo's verify-<app> skill, or say "no verify skill">
+  proof: <the command or path that drove the real product; name the repo's done-done-verify-<app> skill, or say "no verify skill">
   evidence: <the evidence file paths, or "not proven: <cause>">`;
 const RUNS_TEXT = `runs: each verify or maintain run lives in $DONE_DONE_HOME/runs/<app>/<run-id> (run.json, events.jsonl, logs/<step>.log,
   agents/<n>-<name>.json for each agent call) and goes on when the command that started it ends;
@@ -53,7 +53,7 @@ const RUNS_TEXT = `runs: each verify or maintain run lives in $DONE_DONE_HOME/ru
   ignored files copied in, and verify runs again there, up to n times. Result: changed (the fix on a done-done/verify-<run-id>
   branch, your HEAD still fails; exit 1) or blocked (dirty checkout, a guard, or every attempt used; exit 1)`;
 const MAINTAIN_TEXT = `maintain reads the verify skill and the source; HEAD, git status and the content of changed files must be the same before and after.
-  locate: the verify skill (.agents/skills/verify-<app>/SKILL.md); none: blocked, create it with done-done init
+  locate: the verify skill (.agents/skills/done-done-verify-<app>/SKILL.md); none: blocked, create it with done-done init
   hygiene: every local link in the skill resolves; features/README.md lists each features/*.md file once
   source-wave: one fresh read-only reader per feature file at the configured agent (agent, agent_config) explains it from source
   reconcile: each file:line the skill or a reader cites must exist (a bare file name matches a tracked file); one tool-less call
@@ -73,7 +73,7 @@ const DOCTOR_TEXT = `doctor changes nothing except the --probe call record (the
   for claude-code an executable claude binary and the judge kit, for answerer:<agent> that agent's CLI and the
   kit, for openai:key OPENAI_API_KEY and the kit; doctor does not call the model; missing when none is set, with the command
   that saves the user's choice).
-  also listed: verify_skill (.agents/skills/verify-<app>/), agent_settings (agent, model, effort,
+  also listed: verify_skill (.agents/skills/done-done-verify-<app>/), agent_settings (agent, model, effort,
   args, path and agent_timeout, each with the file it came from: the global config, .done-done.yaml or default),
   judge_choice (the judge, and how far it is from the author: another agent, another model, or session-only), ffprobe (video evidence only).
   --probe also asks the agent one JSON-schema question (one call at the agent's model: its cheap default where it has one, else its own; set agent_config.<agent>.model to choose; its record goes to
@@ -93,7 +93,7 @@ const FLAGS = {
     '--close <run-id>': 'seal an open run and record the files in its folder',
     '--outcome "<claim>"': 'the outcome the evidence files prove; the files follow as arguments',
     '--from <file | - | PR URL>': 'read the claim from the newest "## Checks" block of a file, stdin or a PR body',
-    '--trusted-ref <ref>': 'read .done-done.yaml from this git ref instead of the working tree (use in CI)',
+    '--trusted-ref <ref>': 'read .done-done.yaml from this git ref instead of the working tree (for scripts)',
     '--judge <route>': 'check with this judge for this call instead of judge.route (same form: claude-code, answerer:opencode, answerer:pi, answerer:gemini or openai:key); its model is that agent\'s default, or judge.model when the route is the configured one',
     '--citation-base <dir>': 'resolve evidence citations against this directory (default: cwd); absolute citations stay unchanged; does not change repo, config or run storage',
     '--claim-id <id>': 'the claim the evidence proves; evidence already used for another claim id is reuse (default: the current branch, or the PR branch with --from <PR URL>; required on a detached HEAD)',
@@ -101,7 +101,7 @@ const FLAGS = {
     '--outcome "<what a user can now do>"': 'the outcome the run must prove',
     '--wait': 'wait until the run ends (the default)',
     '--no-wait': 'start the run and return at once (exit 4); read it later with done-done status',
-    '--foreground': 'run every step in this process instead of a detached runner (use in CI)',
+    '--foreground': 'run every step in this process instead of a detached runner (for scripts)',
     '--run <run-id>': 'the run to show (default: the newest run of this checkout)',
     '--probe': 'ask the configured agent one JSON-schema question and require a valid answer (one call at the agent\'s model: its cheap default where it has one, else its own; set agent_config.<agent>.model to choose)',
     '--mock <screen>=<mock>': 'judge this screen next to its approved mock (repeat per screen; the screen is judged even when not listed)',
@@ -122,7 +122,7 @@ const COMMANDS = {
     init: {
         usage: [
             ['done-done init', 'write a minimal .done-done.yaml (evidence lives outside the repo) and, when absent, a commented ~/.done-done/config.yaml'],
-            ['done-done init', 'have the agent write .agents/skills/verify-<app> from this repo\'s own proof paths (never overwrites; no agent, no skill)'],
+            ['done-done init', 'have the agent write .agents/skills/done-done-verify-<app> from this repo\'s own proof paths (never overwrites; no agent, no skill)'],
             ['done-done init --agent opencode --model opencode-go/muse-spark-1.3-contributor', 'set the coding agent done-done starts and its model (in a terminal, init asks when none is set)'],
             ['done-done init --judge pi --judge-model openai-codex/gpt-6-luna', 'set the judge done-done starts and its model (in a terminal, init asks when none is set)'],
             ['done-done init --hook claude', 'also show this repo\'s done-done state at each Claude Code session start'],
@@ -174,7 +174,7 @@ const COMMANDS = {
         usage: [
             ['done-done verify [<journey>] --outcome "<what a user can now do>" [--claim-id <id>]', 'drive the journey in a run that outlives this command, check its evidence, judge each capture and record a receipt'],
             ['done-done verify --outcome "<claim>" [--feature <name>]', 'with no journey, the author agent drives a verify skill feature and the judge the user set judges its captures'],
-            ['done-done verify [<journey>] --outcome "<claim>" --no-wait | --wait | --foreground', 'return at once, wait until the run ends or waits at its gate (default), or run in this process (CI)'],
+            ['done-done verify [<journey>] --outcome "<claim>" --no-wait | --wait | --foreground', 'return at once, wait until the run ends or waits at its gate (default), or run in this process'],
         ],
         flags: ['--outcome "<what a user can now do>"', '--feature <name>', '--claim-id <id>', '--wait', '--no-wait', '--foreground'],
         more: [RUNS_TEXT],
@@ -198,16 +198,27 @@ const COMMANDS = {
   overflow, squashed text, text clipped by its container and elements cut off by the left, right or top edge, writes the
   screenshot and its .dom.json record, and exits 1 naming each element, kind and text, 0 when there is none. A hit always
   fails: never wrap it in || true. Needs Chrome or Chromium (DONE_DONE_CHROME names the binary)`],
+    },
+    gate: {
+        usage: [['done-done gate [<head>] [--dir <folder>] [--pushed <time>]', 'no-model check for a hosted runner: PASS or FAIL: <reason> for a receipt committed under .done-done-receipts/']],
+        flags: ['--dir <folder>', '--pushed <time>'],
+        more: [`gate: reads git objects only, so it needs no config, judge, model key or evidence files, and a hosted runner never runs check, run or verify.
+  Copy the receipt that receipt wrote (<evidence root>/.done-done/receipts/<head>.json) into .done-done-receipts/ and commit it in a follow-up commit.
+  PASS when a receipt there is a well-formed judged pass, its head is <head> (default HEAD) or an ancestor of it, every file changed since that head is
+  inside the folder, and its time is not after the push (--pushed, default the commit time of <head>). It does not re-hash evidence: that is receipt --verify
+  on the machine that holds it. Needs the history back to the receipt head (fetch-depth: 0). Exit 0 PASS, 1 FAIL, 2 usage error`],
     },
     lint: {
-        usage: [['done-done lint <PR URL | report file> <evidence folder>', 'merge gate on a worker\'s claim: prints PASS or FAIL: <reason>; the rules need no judge, model or config']],
+        usage: [['done-done lint <PR URL | report file> <evidence folder>', 'merge gate on a worker\'s claim: prints PASS or FAIL: <reason>; the rules need no judge or model, and two optional size rules are config keys']],
         flags: [],
         more: [`lint: a deterministic gate that is on whenever you call it. The newest "## Checks" block of the PR body (gh pr view) or report file needs
-  outcome:, repro:, proof: and evidence: lines. proof names a command or path, and the repo's verify-<app> skill, or says "no verify skill"
+  outcome:, repro:, proof: and evidence: lines. proof names a command or path, and the repo's done-done-verify-<app> skill, or says "no verify skill"
   when the repo (the current folder) has none; repro is not n/a on a fix PR. evidence names files in the evidence folder (or absolute):
   each exists, is non-empty and is newer than the folder itself; no two are byte-identical; at least one has a hash no other PR used
   (hash store lint.hashes in ~/.done-done, or $DONE_DONE_HOME). "evidence: not proven: <cause>" passes. A PR with 1,000 or more added
   non-generated lines fails (lockfiles, vendor/, dist/, LICENSE-type files, deletions and moved lines do not count); a bot PR passes.
+  In .done-done.yaml, checks.upstream_catch_up: true also drops a fork's upstream catch-up lines, and checks.moved_from: true drops lines
+  a "moved-from: <owner>/<repo>@<ref> <dst>=<src>" body line says came from a repo of the same owner; both are off by default.
   Every run is appended to lint.log next to the store. Exit 0 PASS, 1 FAIL, 2 usage error. Needs gh for a PR URL`],
     },
     status: {
@@ -572,7 +583,7 @@ function claimFromChecks(body, title, repo, cfg, out) {
         out.push({ level: 'fail', why: 'evidence names no files' });
     return { outcome: f.outcome, files, title };
 }
-// A PR body also names its head branch, which is the claim a CI checkout (a detached HEAD) is checking.
+// A PR body also names its head branch, which is the claim a detached-HEAD checkout is checking.
 function readSource(from) {
     if (from === '-')
         return { body: readFileSync(0, 'utf8') };
@@ -823,7 +834,7 @@ async function cmdCheck(argv) {
 }
 const receiptsDir = (cfg) => join(cfg.evidence.root, '.done-done', 'receipts');
 // A receipt names a cited file relative to the repo, or to an evidence root outside it under this prefix,
-// so any checkout of the repo (or a CI job that restored the evidence root) finds the same file.
+// so any checkout of the repo finds the same file.
 const IN_EVIDENCE = '<evidence root>/';
 function receiptPath(repo, cfg, p) {
     const inRepo = under(repo, p);
@@ -839,6 +850,17 @@ function writeReceipt(cfg, rec) {
     renameSync(`${path}.tmp`, path);
     return path;
 }
+// Why a parsed receipt is not a well-formed passing one (a judge block that names its judge and passes only captures the receipt cites), or null.
+function receiptFault(rec, short) {
+    if (!rec || typeof rec !== 'object' || rec.schema !== 2 || rec.result !== 'pass' || !Array.isArray(rec.files) || !rec.files.length)
+        return `receipt for ${short} is malformed`;
+    if (!rec.files.every((f) => f && typeof f === 'object' && typeof f.path === 'string' && typeof f.sha256 === 'string'))
+        return `receipt for ${short} is malformed`;
+    const j = rec.judge;
+    const badJudge = !j || typeof j !== 'object' || typeof j.route !== 'string' || typeof j.model !== 'string' || !['agent', 'model', 'session-only'].includes(j.independence) || !Array.isArray(j.verdicts) || !j.verdicts.length
+        || !j.verdicts.every((v) => v && v.verdict === 'pass' && rec.files.some((f) => f.path === v.path && f.sha256 === v.sha256));
+    return badJudge ? `receipt for ${short} has a malformed judge block` : null;
+}
 // Verify a recorded receipt for `headArg`, which may be a full sha or a ref (HEAD, a branch or a tag).
 // Read-only, so a missing or changed record is a failure, not a usage error.
 function verifyReceipt(repo, cfg, headArg) {
@@ -861,16 +883,10 @@ function verifyReceipt(repo, cfg, headArg) {
     catch (e) {
         return fail(`receipt for ${short} is malformed (${e.message})`);
     }
-    if (!rec || typeof rec !== 'object' || rec.schema !== 2 || rec.result !== 'pass' || !Array.isArray(rec.files) || !rec.files.length)
-        return fail(`receipt for ${short} is malformed`);
-    if (!rec.files.every((f) => f && typeof f === 'object' && typeof f.path === 'string' && typeof f.sha256 === 'string'))
-        return fail(`receipt for ${short} is malformed`);
-    // The judge block must name its judge, and pass only captures this receipt cites.
+    const fault = receiptFault(rec, short);
+    if (fault)
+        return fail(fault);
     const j = rec.judge;
-    const badJudge = !j || typeof j !== 'object' || typeof j.route !== 'string' || typeof j.model !== 'string' || !['agent', 'model', 'session-only'].includes(j.independence) || !Array.isArray(j.verdicts) || !j.verdicts.length
-        || !j.verdicts.every((v) => v && v.verdict === 'pass' && rec.files.some((f) => f.path === v.path && f.sha256 === v.sha256));
-    if (badJudge)
-        return fail(`receipt for ${short} has a malformed judge block`);
     if (rec.head !== commit)
         return fail(`receipt records head ${String(rec.head).slice(0, 12)}, not ${short}`);
     const now = head(repo);
@@ -935,7 +951,7 @@ function recordReceipt(repo, cfg, r) {
     const rec = { schema: 2, repo: cfg.app, head: r.head.commit, tree: r.head.tree, claim: r.claim ?? '', result: 'pass', at: new Date().toISOString(), files: r.cited, judge: r.judgeBlock };
     const path = writeReceipt(cfg, rec);
     const result = { command: 'receipt', result: 'pass', head: r.head.commit, tree: r.head.tree, claim: rec.claim, files: rec.files.length, receipt: shown(repo, path) };
-    return { code: PASS, result: { ...result, ...(r.judge && { judge: r.judge }), help: [`Verify this receipt (CI or merge): done-done receipt --verify ${r.head.commit}`] } };
+    return { code: PASS, result: { ...result, ...(r.judge && { judge: r.judge }), help: [`Verify this receipt (merge gate): done-done receipt --verify ${r.head.commit}`] } };
 }
 // Why evidence from `from` no longer proves `to`, or '' if it still does.
 function staleness(repo, cfg, from, to) {
@@ -961,10 +977,10 @@ function checkHelp(code, findings, files, { cfg, repo, claim, source, citationBa
     if (judgeLevel && code === INCONCLUSIVE)
         return ['Look at the capture yourself, or capture a clearer screen of the outcome and re-run this check'];
     if (code === PASS) {
-        // The CI gate needs a PR on a remote; without one, a receipt records the pass locally.
+        // The merge gate needs a PR on a remote; without one, a receipt records the pass locally.
         const citationArgs = citationBase === undefined ? '' : ` --citation-base ${arg(citationBase)}`;
         if (spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: repo }).status === 0)
-            return [`Gate CI on this proof: done-done check --from <PR URL> --trusted-ref origin/main${citationArgs}`];
+            return [`Gate the merge on this proof: done-done check --from <PR URL> --trusted-ref origin/main${citationArgs}`];
         const claimArgs = source ? ['--from', source] : ['--outcome', claim ?? '', ...files];
         return [`Record this pass for HEAD: done-done receipt ${claimArgs.map(arg).join(' ')}${citationArgs}`];
     }
@@ -1892,7 +1908,7 @@ function showRun(dir, cfg, command, gone = false) {
                                             : /^locate: no verify skill/.test(run.reason ?? '') ? ['Create the verify skill: done-done init']
                                                 : /^locate:/.test(run.reason ?? '') ? [`Make ${cfg.skill} a real folder inside the repository (not a link), commit, then run again: ${again}`]
                                                     : [`Read the step logs in ${shown(run.repo, join(dir, 'logs'))}`, `Fix the cause, then run again: ${again}`])
-                                : code === PASS ? [`Verify this receipt (CI or merge): done-done receipt --verify ${rec.commit}`]
+                                : code === PASS ? [`Verify this receipt (merge gate): done-done receipt --verify ${rec.commit}`]
                                     : status === 'cancelled' ? [...(run.kind === 'maintain' ? [] : [`Start again from the failed step: done-done rerun --run ${run.run_id}`]), `List past runs: done-done history`]
                                         : [`Read the step logs in ${shown(run.repo, join(dir, 'logs'))}`, ...(run.kind === 'maintain' ? [] : [`Fix the cause, commit, then run again from the failed step: done-done rerun --run ${run.run_id}`]), `Or start a new run: ${again}`];
     emit(result);
@@ -2557,7 +2573,7 @@ function scaffoldProblem(a, tracked, shown) {
     return '';
 }
 function verifySkillMd(app, agent, s, isolated, features, omitted) {
-    const name = `verify-${app}`;
+    const name = `done-done-verify-${app}`;
     const source = cited(s.launch.source);
     const launch = isolated
         ? `${s.launch.steps.trim()}\n\nSafe: ${clause(s.launch.why)} (from \`${source}\`).`
@@ -2624,6 +2640,22 @@ function symlinkOnPath(repo, p) {
     }
     return undefined;
 }
+// An older init wrote verify-<app>; with no `skill:` set, init moves that folder to the prefixed name once, and says so.
+// A prefixed folder that already exists wins, and the old one is left alone.
+function renameLegacySkill(repo, cfg) {
+    const old = `.agents/skills/verify-${cfg.app}`;
+    if (cfg.from.skill || cfg.skill !== old)
+        return undefined;
+    const next = `.agents/skills/done-done-verify-${cfg.app}`;
+    if (existsSync(join(repo, next)) || symlinkOnPath(repo, join(repo, old)) !== undefined)
+        return undefined;
+    renameSync(join(repo, old), join(repo, next));
+    const md = join(repo, next, 'SKILL.md');
+    if (existsSync(md))
+        writeFileSync(md, readFileSync(md, 'utf8').replace(`name: verify-${cfg.app}`, `name: done-done-verify-${cfg.app}`).replace(`name: "verify-${cfg.app}"`, `name: "done-done-verify-${cfg.app}"`));
+    cfg.skill = next;
+    return `${old} -> ${next}`;
+}
 const SCAFFOLD_HELP = 'The verify skill was not written: fix the cause verify_skill names, then re-run: done-done init';
 // All-or-nothing: when any target (SKILL.md, features/README.md, a features file) exists as a file or directory,
 // nothing is written and the paths are named; otherwise every file is written into a temp dir inside the skill's
@@ -3080,6 +3112,7 @@ async function cmdInit(argv) {
     const cfg = loadConfig(repo); // validates the existing project config; malformed -> exit 2, no writes
     if (cfg.skill.split(/[\\/]/).includes('..'))
         throw new UsageError(`verify skill ${cfg.skill} has a .. segment; use a path inside the repo`, 'Set skill to a repo-relative path in .done-done.yaml');
+    const renamed = renameLegacySkill(repo, cfg);
     const spec = values.hook === undefined ? undefined : HOOKS[values.hook];
     const hook = spec?.make(repo); // likewise validated before any write
     // The agent: --agent, else with none set the user's pick in a terminal (asked before any write); never done-done's.
@@ -3156,6 +3189,7 @@ async function cmdInit(argv) {
             app: fresh.app,
             evidence_root: root,
             gitignore: added ? `added ${rel.replace(/\/+$/, '')}/` : 'unchanged',
+            ...(renamed && { skill_renamed: renamed }),
             verify_skill: verify.status,
             ...agentHook.out,
             help: [`Capture proof: done-done run ${journey}, then: ${check}`, ...agentHook.help, ...ag.help, ...jg.help, ...(verify.failed ? [SCAFFOLD_HELP] : []), `Commit ${commitFirst(fresh.skill)}`],
@@ -3195,6 +3229,7 @@ app: ${JSON.stringify(cfg.app)}
         app: cfg.app,
         evidence_root: root,
         gitignore: added ? `added ${rel.replace(/\/+$/, '')}/` : 'unchanged',
+        ...(renamed && { skill_renamed: renamed }),
         verify_skill: verify.status,
         ...agentHook.out,
         help: [
@@ -3478,11 +3513,75 @@ async function cmdLook(argv) {
     });
     return hits.length ? FAIL : PASS;
 }
+// The folder of a branch where a receipt copied from the evidence root is committed, for `gate`.
+const GATE_DIR = '.done-done-receipts';
+// The reason no committed receipt vouches for `tip`, or null when one does. Reads git objects only: no config, no judge, no evidence files.
+function gateFault(repo, tip, dir, pushed) {
+    const short = tip.slice(0, 12);
+    const names = git(repo, '-c', 'core.quotepath=off', 'ls-tree', '-r', '--name-only', tip, '--', dir).split('\n').filter((n) => n.endsWith('.json'));
+    if (!names.length)
+        return `no receipt in ${dir}/ at ${short}`;
+    const reasons = [];
+    for (const name of names) {
+        const why = (() => {
+            let rec;
+            try {
+                rec = JSON.parse(git(repo, 'show', `${tip}:${name}`));
+            }
+            catch (e) {
+                return `${name} is malformed (${e.message})`;
+            }
+            const fault = receiptFault(rec, basename(name));
+            if (fault)
+                return fault;
+            if (name !== `${dir}/${rec.head}.json`)
+                return `${name} does not name its own head ${String(rec.head).slice(0, 12)}`;
+            try {
+                git(repo, 'merge-base', '--is-ancestor', rec.head, tip);
+            }
+            catch {
+                return `receipt head ${rec.head.slice(0, 12)} is not ${short} or an ancestor of it (a shallow checkout needs full history)`;
+            }
+            const outside = git(repo, '-c', 'core.quotepath=off', 'diff', '--name-only', rec.head, tip).split('\n').filter((n) => n && !n.startsWith(`${dir}/`));
+            if (outside.length)
+                return `${named(outside)} changed after receipt head ${rec.head.slice(0, 12)}, so its proof no longer covers ${short}`;
+            const at = Date.parse(rec.at);
+            if (!(Math.floor(at / 1000) <= Math.floor(pushed / 1000)))
+                return `receipt time ${rec.at} is not before the push (${new Date(pushed).toISOString()})`;
+            return null;
+        })();
+        if (!why)
+            return null;
+        reasons.push(why);
+    }
+    return reasons.join('; ');
+}
+// `done-done gate`: the no-model check a hosted runner can run. A receipt committed under GATE_DIR vouches for the head.
+function cmdGate(argv) {
+    const { values, positionals } = parseArgs({ args: argv, options: { dir: { type: 'string' }, pushed: { type: 'string' } }, allowPositionals: true });
+    if (positionals.length > 1)
+        throw new UsageError('gate takes at most one head', 'Re-run as: done-done gate [<head>] [--dir <folder>] [--pushed <time>]');
+    const repo = repoRoot();
+    let tip;
+    try {
+        tip = git(repo, 'rev-parse', '--verify', `${positionals[0] ?? 'HEAD'}^{commit}`);
+    }
+    catch {
+        throw new UsageError(`gate: ${positionals[0]} is not a commit in this checkout`, 'Pass the pull request head sha, or run it in a checkout of that head');
+    }
+    const pushed = values.pushed === undefined ? Number(git(repo, 'log', '-1', '--format=%ct', tip)) * 1000 : Date.parse(values.pushed);
+    if (Number.isNaN(pushed))
+        throw new UsageError(`gate: --pushed ${values.pushed} is not a time`, 'Pass an ISO time such as 2026-10-20T09:05:56Z');
+    const why = gateFault(repo, tip, (values.dir ?? GATE_DIR).replace(/\/+$/, ''), pushed);
+    console.log(why === null ? 'PASS' : `FAIL: ${why}`);
+    return why === null ? PASS : FAIL;
+}
 function cmdLint(argv) {
     const { positionals } = parseArgs({ args: argv, allowPositionals: true });
     if (positionals.length !== 2)
         throw new UsageError('lint needs a PR URL or report file, then the evidence folder', 'Re-run as: done-done lint <PR URL | report file> <evidence folder>');
-    const v = lint(positionals[0], positionals[1], home());
+    const { checks } = loadConfig(process.cwd());
+    const v = lint(positionals[0], positionals[1], home(), checks);
     console.log(v.ok ? 'PASS' : `FAIL: ${v.why}`);
     return v.ok ? PASS : FAIL;
 }
@@ -3611,6 +3710,8 @@ async function main(argv) {
             return await cmdLook(rest);
         if (cmd === 'lint')
             return cmdLint(rest);
+        if (cmd === 'gate')
+            return cmdGate(rest);
         if (cmd === 'status')
             return cmdStatus(rest);
         if (cmd === 'attach')

package/dist/config.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, isAbsolute, join, resolve } from 'node:path';
 import { parse } from 'yaml';
@@ -69,6 +69,8 @@ const KEYS = {
     'secrets.patterns': { scope: 'repo', type: 'regexes' },
     'secrets.allow': { scope: 'repo', type: 'regexes' },
     'checks.fix_title': { scope: 'repo', type: 'string' },
+    'checks.upstream_catch_up': { scope: 'repo', type: 'boolean' },
+    'checks.moved_from': { scope: 'repo', type: 'boolean' },
     'judge.model': { scope: 'global', type: 'string' },
     'judge.route': { scope: 'global', type: 'route' },
     'judge.floor': { scope: 'global', type: 'number' },
@@ -273,7 +275,7 @@ function defaultConfig(repo) {
         base_ref: '',
         evidence: { local_root: join(home(), 'evidence'), root: '', allow_dirty: false, ignore_paths: [] },
         secrets: { patterns: {}, allow: [] },
-        checks: { fix_title: '^(fix|bugfix|hotfix)\\b' },
+        checks: { fix_title: '^(fix|bugfix|hotfix)\\b', upstream_catch_up: false, moved_from: false },
         judge: { route: '', model: '', floor: 0.7, env_file: '' },
         trusted: false,
         from: {},
@@ -287,7 +289,9 @@ export function loadConfig(repo, projectText) {
     apply(cfg, readOptional(globalFile), globalFile, 'global');
     const projectFile = join(repo, '.done-done.yaml');
     apply(cfg, projectText ?? readOptional(projectFile), projectFile, 'repo');
-    cfg.skill ||= `.agents/skills/verify-${cfg.app}`;
+    // A skill dir an older init wrote (verify-<app>) is still read until init renames it to the prefixed name.
+    cfg.skill ||= existsSync(join(repo, `.agents/skills/done-done-verify-${cfg.app}`)) || !existsSync(join(repo, `.agents/skills/verify-${cfg.app}`))
+        ? `.agents/skills/done-done-verify-${cfg.app}` : `.agents/skills/verify-${cfg.app}`;
     const local = tilde(cfg.evidence.local_root);
     cfg.acpx_path = tilde(cfg.acpx_path);
     for (const a of Object.keys(cfg.agent_path_override))

package/dist/lint.js

@@ -1,5 +1,6 @@
 // `done-done lint`: the deterministic merge gate on a worker's claim. It reads the newest "## Checks" block of a PR body
-// or report file and fails an unproven, reused or oversized claim. No judge, no model, no repo config.
+// or report file and fails an unproven, reused or oversized claim. No judge, no model; the repo config only switches on
+// the two optional size rules (checks.upstream_catch_up, checks.moved_from).
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs';
@@ -13,7 +14,6 @@ const gh = (...args) => {
     const r = spawnSync('gh', args, { encoding: 'utf8', timeout: 60_000, maxBuffer: 1 << 28 });
     return { status: r.error ? 1 : r.status, stdout: r.stdout ?? '', stderr: r.error?.message ?? r.stderr ?? '' };
 };
-// Added minus deleted non-generated lines of a unified diff: a line moved between files cancels out.
 function netLines(diff) {
     const net = new Map();
     let generated = false;
@@ -27,15 +27,48 @@ function netLines(diff) {
         if (l[0] === '+' || l[0] === '-')
             net.set(l.slice(1).trim(), (net.get(l.slice(1).trim()) ?? 0) + (l[0] === '+' ? 1 : -1));
     }
-    let total = 0;
-    for (const n of net.values())
-        if (n > 0)
-            total += n;
-    return total;
+    return without(net, new Map());
+}
+// `a` less the lines `b` holds, keeping only what is still added.
+function without(a, b) {
+    const out = new Map();
+    for (const [l, n] of a)
+        if (n - (b.get(l) ?? 0) > 0)
+            out.set(l, n - (b.get(l) ?? 0));
+    return out;
+}
+const total = (n) => [...n.values()].reduce((sum, c) => sum + c, 0);
+const stdout = (r) => (r.status === 0 ? r.stdout.trim() : '');
+// checks.upstream_catch_up: lines the fork's parent repo already shipped are not authored here, so subtract the upstream delta the PR
+// merges in (PR base ... the merge base with the parent's default branch). A plain fork PR merges no new upstream commit, so its delta
+// is empty. Any API failure keeps the full count.
+function upstreamDelta(run, nwo, head, base) {
+    const parent = stdout(run('api', `repos/${nwo}`, '--jq', '.parent | select(.) | .owner.login + ":" + .default_branch'));
+    const tip = parent && stdout(run('api', `repos/${nwo}/compare/${parent}...${head}`, '--jq', '.merge_base_commit.sha'));
+    const diff = tip && run('api', '-H', 'Accept: application/vnd.github.diff', `repos/${nwo}/compare/${base}...${tip}`);
+    return diff && diff.status === 0 ? netLines(diff.stdout) : new Map();
+}
+// checks.moved_from: a body line "moved-from: <owner>/<repo>@<ref> <dst-prefix>=<src-prefix>..." cancels added lines that byte-match
+// the mapped source files in a repo of the PR's own owner; authored lines still count.
+function movedLines(run, nwo, body, paths) {
+    const mv = /^\s*moved-from\s*:\s*([\w.-]+)\/([\w.-]+)@(\S+)\s+(.+)$/m.exec(body);
+    const rules = mv && mv[1] === nwo.split('/')[0] ? mv[4].split(/\s+/).filter((r) => r.includes('=')).map((r) => [r.slice(0, r.indexOf('=')), r.slice(r.indexOf('=') + 1)]) : [];
+    const moved = new Map();
+    for (const p of paths) {
+        const rule = rules.find(([dst]) => p.startsWith(dst));
+        if (!mv || !rule || GENERATED.test(p))
+            continue;
+        const src = run('api', '-H', 'Accept: application/vnd.github.raw', `repos/${mv[1]}/${mv[2]}/contents/${rule[1]}${p.slice(rule[0].length)}?ref=${mv[3]}`);
+        if (src.status === 0)
+            for (const l of src.stdout.split('\n'))
+                if (l.trim())
+                    moved.set(l.trim(), (moved.get(l.trim()) ?? 0) + 1);
+    }
+    return moved;
 }
 const sha256 = (p) => createHash('sha256').update(readFileSync(p)).digest('hex');
 // src: a PR URL or a report file; ev: the folder the evidence names are relative to; dir: where the hash store and log live.
-export function lint(src, ev, dir, run = gh) {
+export function lint(src, ev, dir, rules = {}, run = gh) {
     const log = (v) => {
         mkdirSync(dir, { recursive: true });
         appendFileSync(join(dir, 'lint.log'), `${new Date().toISOString()}\t${src}\t${v.head}\t${v.ok ? 'pass' : 'fail'}\t${v.why}\n`);
@@ -47,7 +80,7 @@ export function lint(src, ev, dir, run = gh) {
         task = basename(dirname(resolve(src)));
     }
     else {
-        const r = run('pr', 'view', src, '--json', 'author,body,title,files,headRefOid,headRefName');
+        const r = run('pr', 'view', src, '--json', 'author,body,title,files,headRefOid,headRefName,baseRefOid');
         if (r.status)
             return log({ ok: false, why: `gh pr view failed: ${r.stderr.trim().split('\n').pop()?.slice(0, 160) || '?'}`, head });
         const pr = JSON.parse(r.stdout);
@@ -60,8 +93,15 @@ export function lint(src, ev, dir, run = gh) {
         let size = (pr.files ?? []).reduce((n, f) => n + (GENERATED.test(f.path ?? '') ? 0 : f.additions ?? 0), 0);
         if (size >= SIZE_LIMIT) {
             const d = run('pr', 'diff', src);
-            if (!d.status)
-                size = netLines(d.stdout);
+            if (!d.status) {
+                let net = netLines(d.stdout);
+                const nwo = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\//.exec(src)?.[1];
+                if (nwo && rules.upstream_catch_up && total(net) >= SIZE_LIMIT)
+                    net = without(net, upstreamDelta(run, nwo, head, pr.baseRefOid ?? ''));
+                if (nwo && rules.moved_from && total(net) >= SIZE_LIMIT)
+                    net = without(net, movedLines(run, nwo, body, (pr.files ?? []).map((f) => f.path ?? '')));
+                size = total(net);
+            }
         }
         if (size >= SIZE_LIMIT)
             return log({ ok: false, why: `${size} added non-generated lines (moved lines excluded): split it (limit ${SIZE_LIMIT})`, head });
@@ -79,9 +119,9 @@ export function lint(src, ev, dir, run = gh) {
     if (!/[/`]|\.\w{2,4}\b|\b(npm|pnpm|yarn|npx|bash|sh|python3?|node|cargo|go|gradle|make|adb|xcrun|done-done)\b/.test(f.proof))
         return fail('proof: names no command or path');
     const skills = join(process.cwd(), '.agents', 'skills');
-    const hasVerify = existsSync(skills) && readdirSync(skills).some((d) => d.startsWith('verify-'));
+    const hasVerify = existsSync(skills) && readdirSync(skills).some((d) => /^(done-done-)?verify-/.test(d));
     if (!f.proof.includes('verify-') && (hasVerify || !/no verify skill/i.test(f.proof)))
-        return fail(`proof: does not name the verify-<app> skill run${hasVerify ? '' : ' (or "no verify skill")'}`);
+        return fail(`proof: does not name the done-done-verify-<app> skill run${hasVerify ? '' : ' (or "no verify skill")'}`);
     if (NOT_APPLICABLE.test(f.repro) && FIX_TITLE.test(title))
         return fail('repro: is n/a on a fix PR');
     if (/^not proven\s*:\s*\S/i.test(f.evidence))

package/dist/look.js

@@ -7,7 +7,7 @@ import { domRecord, LOOK, SQUASHED_TEXT } from './dom.js';
 import { findBin } from './agents.js';
 // done-done look: opens one page in headless Chrome at a phone viewport over the DevTools protocol (Node's own
 // WebSocket, no browser library), writes the screenshot and its page-check record next to it, and returns the record.
-// Chrome runs without its sandbox so it starts in containers and CI: point look at your own app, not untrusted sites.
+// Chrome runs without its sandbox so it starts in containers: point look at your own app, not untrusted sites.
 const BROWSERS = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
 const WAIT = 30_000;
 export async function look(url, capture, width, height) {