diff --git a/.github/fork-ci-tests.txt b/.github/fork-ci-tests.txt index caefbecbc100a..c13beb6db27fc 100644 --- a/.github/fork-ci-tests.txt +++ b/.github/fork-ci-tests.txt @@ -19,6 +19,7 @@ fork-ci/actions/docs-scope/docs-scope.test.py fork-ci/actions/gradle-cache/gradle_cache.test.py fork-ci/actions/job-changed/job-changed.test.py +fork-ci/actions/pr-queue/lens.test.py # Upstream's tests, run where fork-tests.yml follows upstream's ci.yml. .github/scripts/check-nightly-release.test.cjs run by .github/workflows/fork-tests.yml diff --git a/.github/scripts/fork-ci-tests.test.cjs b/.github/scripts/fork-ci-tests.test.cjs index 3ce9bf2e938b0..da0290dc92daa 100644 --- a/.github/scripts/fork-ci-tests.test.cjs +++ b/.github/scripts/fork-ci-tests.test.cjs @@ -1,4 +1,5 @@ const assert = require("node:assert/strict"); +const childProcess = require("node:child_process"); const fs = require("node:fs"); const os = require("node:os"); const path = require("node:path"); @@ -112,3 +113,33 @@ test("the composite actions' tests under fork-ci are found too, and a missing fo fs.rmSync(root, { recursive: true, force: true }); } }); + +test("an unlisted test under .github/scripts or fork-ci fails the run", () => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "fork-ci-tests-")); + try { + const write = (file, text) => { + fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true }); + fs.writeFileSync(path.join(root, file), text); + }; + const script = fs.readFileSync(require.resolve("./fork-ci-tests.cjs")); + write(".github/scripts/fork-ci-tests.cjs", script); + write(".github/fork-ci-tests.txt", "# nothing listed\n"); + write(".github/scripts/s.test.sh", ""); + write("fork-ci/actions/x/a.test.py", ""); + const env = { ...process.env }; + delete env.GITHUB_STEP_SUMMARY; + const run = childProcess.spawnSync("node", [".github/scripts/fork-ci-tests.cjs"], { + cwd: root, + env, + encoding: "utf8", + }); + assert.equal(run.status, 1, run.stdout + run.stderr); + for (const file of [".github/scripts/s.test.sh", "fork-ci/actions/x/a.test.py"]) + assert.ok( + run.stdout.includes(`${file} is not in .github/fork-ci-tests.txt`), + `${file} not reported: ${run.stdout}`, + ); + } finally { + fs.rmSync(root, { recursive: true, force: true }); + } +}); diff --git a/fork-ci/actions/pr-queue/README.md b/fork-ci/actions/pr-queue/README.md new file mode 100644 index 0000000000000..cc374876c8b82 --- /dev/null +++ b/fork-ci/actions/pr-queue/README.md @@ -0,0 +1,110 @@ +# pr-queue + +A merge queue for a repository whose branch ruleset requires pull requests to be +up to date with their base branch. After each push to the base branch it brings +exactly one waiting pull request up to date, and it turns auto-merge back on +only for a head that holds exactly the change the review read. + +This folder is built in four stacked pull requests: + +1. the review rules and the config (`lens.py`, `config.py`): this part; +2. the queue itself (`pr_queue.py`); +3. armed pull requests that cannot merge (a red required check, or one that + ended without passing or never reported) are told once and passed over; +4. the "red only because the base was red" rule, the reusable workflow + `.github/workflows/fork-pr-queue.yml`, `action.yml` and the usage sections + of this file. + +## Config + +One JSON file in the project's repository. Unknown keys, a key written twice, a +missing required key, an empty `required_checks` or a value of the wrong type is +an error: the queue then exits non-zero and touches no pull request. + +```json +{ + "required_checks": ["build", "test", "review-check"], + "merge_method": "squash", + "delete_branch": true, + "bot_logins": ["coderabbitai", "github-actions", "copilot"], + "lens_author_associations": ["OWNER", "COLLABORATOR"], + "override": { "prefix": "tool ready --head", "author_association": "OWNER" }, + "ready_command": "tool ready {pr}", + "push_command": "tool push", + "lens_format_doc": "docs/review.md, section Lens comments", + "head_check": "review-check" +} +``` + +| Key | Required | Meaning | +| -------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `required_checks` | yes | Exactly the checks the branch ruleset requires. Not empty. | +| `merge_method` | yes | `merge`, `squash` or `rebase`: how auto-merge is turned back on. | +| `delete_branch` | yes | Whether auto-merge deletes the branch after merging. | +| `bot_logins` | yes | Logins whose comments never count as a lens. Any login ending in `[bot]` is a bot too. May be empty. | +| `lens_author_associations` | yes | Whose comments count as lens comments: GitHub's author association of the comment, from `OWNER`, `MEMBER`, `COLLABORATOR`. Everyone else's comments are ignored (Lens comments). `MEMBER` and `COLLABORATOR` do not mean write access: list only those whose holders may all vouch for a head. | +| `override` | yes | The comment that vouches for a head when the lenses read older commits: ` <40-hex sha>: `, posted with this author association (`OWNER`, `MEMBER` or `COLLABORATOR`, with the same caveat) and never edited. | +| `ready_command` | yes | The command people run to re-arm a pull request after a lens read; `{pr}` is the number. Only quoted in the queue's comments. | +| `push_command` | yes | The command people run to push a fixed branch. Only quoted in comments. | +| `lens_format_doc` | yes | Where the project documents its lens comments. Only quoted in comments. | +| `head_check` | yes | The required check that fails a head no lens read; it must be one of `required_checks`. The queue acts only on pull requests that are behind: without this check, a push to an armed pull request that is already up to date merges unread. | +| `wait_seconds` | no | How long to wait for GitHub to show the updated head (default 60). | +| `poll_seconds` | no | How often to look meanwhile (default 5). | +| `list_limit` | no | How many open pull requests to read (default 50). | + +## Lens comments + +A review is posted as lens comments: one comment per review angle, whose +first line is its header. + +``` +lens: correctness · reviewer: · read at: +``` + +`Lens:`, `**Lens:**`, `## lens:` and `- lens:` work too; the separator may be +`·`, `,`, `—` or nothing, and `` is the full 40-hex commit sha. A shorter +sha reads nothing: a force-push can bring a new commit with the same prefix. The +sha need not still be a commit of the pull request (a rebase drops it); the +queue re-arms only a head whose change is exactly the change read there. Each +lens's newest comment counts. The reviewed head is the one commit every lens's +newest read names, or a newer override comment's sha (config `override`). A +pull request with no lens comments is not reviewed, and the queue then vouches +only for the head it found. + +Only comments and reviews that GitHub records as written by one of +`lens_author_associations` count: anyone can comment on a public repository, +so everyone else's comments are neither reads nor reports. The run log names +each lens-looking comment it ignored this way and its author association, so a +wrong `lens_author_associations` shows there. A lens comment edited after +posting, or hidden (minimized), reads nothing until that lens posts a new +comment: an edit can move `read at` to a head nobody read, and hiding old review +rounds must not make a reviewed pull request look unreviewed (the queue would +then vouch for whatever head it found). A lens a later round drops therefore +needs an override, or its old comment deleted. A hidden override counts +nothing. GitHub shows no hidden state for reviews, so a review counts as shown. + +The grammar is fixed: a project writes its lens reports this way, it does not +configure another way. It fails closed. A comment that looks like a lens report +but is not exactly one valid read counts as a lens that read nothing, so the +queue never takes a reviewed pull request for an unreviewed one. Looking like a +report means any of: `lens:`, `read at`, `safe to merge`, a `## ... lens` +heading near the top, or two `covered:`/`checks:` lines. A comment that is no +report says so on its first line, `not a lens: ...`. That clears it unless one of +its lines is a lens header or a `lens:` field with a sha. + +## Where the rules come from + +`lens.py` is a port of a production queue's review rules, behaviour for +behaviour. `testdata/lens-corpus.jsonl` holds every call that project's lens +tests made to its copy, with that copy's answer; `lens.test.py` replays all of +them against `lens.py`. Logins and the project name in the corpus were +replaced, and the replaced corpus was checked against the source copy before it +was committed. A rule change here must keep the corpus green or say in its pull +request why a recorded answer changes. + +The port differs on purpose in three ways, and the replay checks each recorded +answer that changes for its reason. The source's repository is private, so its +comments carry no author association: the replay gives them `OWNER` and +unedited. A read shorter than 40 hex, and a lens comment edited after posting, +read nothing here (54 recorded answers). The source's `full_sha`, which matched +a short read to the pull request's commits, is gone. diff --git a/fork-ci/actions/pr-queue/config.py b/fork-ci/actions/pr-queue/config.py new file mode 100644 index 0000000000000..c4ef42a6a8add --- /dev/null +++ b/fork-ci/actions/pr-queue/config.py @@ -0,0 +1,125 @@ +"""The merge queue's project facts: one JSON file in the project's repository (README.md, "Config"). + +Strict on purpose: an unknown key (a typo such as `required_check`), a key written twice, a missing required key, an +empty `required_checks` or a value of the wrong type is an error, and the queue then touches no PR. A queue that read a +wrong list of required checks would update, wait for or pass over the wrong PRs, so there are no guessed defaults for +anything a project must decide; only timings have defaults. +""" +import json +from dataclasses import dataclass + +MERGE_METHODS = ('merge', 'squash', 'rebase') +# GitHub's CommentAuthorAssociation values a stranger cannot get: the repository's owner, a member of its organisation, +# an invited collaborator. Not CONTRIBUTOR, FIRST_TIME_CONTRIBUTOR, FIRST_TIMER or NONE, which anyone gets by commenting +# or by having a commit merged. MEMBER and COLLABORATOR say nothing about the permission (an organisation member may +# only read the repository): a project lists only the associations whose holders may all vouch for a head. +ASSOCIATIONS = ('OWNER', 'MEMBER', 'COLLABORATOR') + + +class ConfigError(Exception): + pass + + +@dataclass(frozen=True) +class Config: + required_checks: frozenset + merge_method: str + delete_branch: bool + bot_logins: tuple + lens_author_associations: tuple + override_prefix: str + override_association: str + ready_command: str + push_command: str + lens_format_doc: str + head_check: str + wait_seconds: int = 60 + poll_seconds: int = 5 + list_limit: int = 50 + + def ready(self, n): + """The command that re-arms PR n after a lens read, as the project writes it.""" + return self.ready_command.replace('{pr}', str(n)) + + +def _text(v): + return isinstance(v, str) and v.strip() == v and v != '' and '\n' not in v + + +def _associations(v): + return isinstance(v, list) and v != [] and all(a in ASSOCIATIONS for a in v) and len(set(v)) == len(v) + + +def _no_duplicates(pairs): + """json.loads keeps the last of a key written twice (say a merge-conflict fix left two `required_checks`): refuse.""" + keys = [k for k, _ in pairs] + twice = sorted({k for k in keys if keys.count(k) > 1}) + if twice: + raise ConfigError(f'key written twice: {", ".join(twice)}') + return dict(pairs) + + +def _int(lo, hi): + return lambda v: isinstance(v, int) and not isinstance(v, bool) and lo <= v <= hi + + +# key: (required, check, what a valid value is) +KEYS = { + 'required_checks': (True, lambda v: isinstance(v, list) and v != [] and all(map(_text, v)) and len(set(v)) == len(v), + 'a non-empty list of distinct check names (exactly the branch ruleset\'s required checks)'), + 'merge_method': (True, lambda v: v in MERGE_METHODS, f'one of {", ".join(MERGE_METHODS)}'), + 'delete_branch': (True, lambda v: isinstance(v, bool), 'true or false'), + 'bot_logins': (True, lambda v: isinstance(v, list) and all(map(_text, v)), + 'a list of logins whose comments never count as a lens (may be empty; `*[bot]` always counts as a bot)'), + 'lens_author_associations': (True, _associations, f'a non-empty list of distinct author associations from ' + f'{", ".join(ASSOCIATIONS)}: only their comments count as lens comments'), + 'override': (True, lambda v: isinstance(v, dict) and set(v) == {'prefix', 'author_association'} + and _text(v['prefix']) and v['author_association'] in ASSOCIATIONS, + f'{{"prefix": "", "author_association": one of {", ".join(ASSOCIATIONS)}}}'), + 'ready_command': (True, lambda v: _text(v) and '{pr}' in v, 'the re-arm command with {pr} for the PR number'), + 'push_command': (True, _text, 'the command that pushes a fixed branch'), + 'lens_format_doc': (True, _text, 'where the project documents its lens comments'), + 'head_check': (True, _text, 'the required check that fails a head no lens read (without one, a push to an armed ' + 'PR that is already up to date merges unread)'), + 'wait_seconds': (False, _int(5, 600), 'whole seconds, 5-600'), + 'poll_seconds': (False, _int(1, 60), 'whole seconds, 1-60'), + 'list_limit': (False, _int(1, 100), 'how many open PRs the queue reads, 1-100'), +} + + +def parse(text, where='config'): + """A Config from the JSON text, or ConfigError naming every problem at once.""" + try: + raw = json.loads(text, object_pairs_hook=_no_duplicates) + except ConfigError as e: + raise ConfigError(f'{where}: {e}') from None + except ValueError as e: + raise ConfigError(f'{where}: not JSON: {e}') from None + if not isinstance(raw, dict): + raise ConfigError(f'{where}: must be a JSON object') + problems = [f'unknown key {k!r} (known: {", ".join(KEYS)})' for k in raw if k not in KEYS] + for key, (required, ok, what) in KEYS.items(): + if key not in raw: + if required: + problems.append(f'{key} is missing: {what}') + elif not ok(raw[key]): + problems.append(f'{key} is {json.dumps(raw[key])[:80]}: must be {what}') + if not problems and raw['head_check'] not in raw['required_checks']: + problems.append(f'head_check {raw["head_check"]!r} is not one of required_checks') + if not problems and raw.get('poll_seconds', 5) > raw.get('wait_seconds', 60): + problems.append('poll_seconds is longer than wait_seconds') + if problems: + raise ConfigError(f'{where}: ' + '; '.join(problems)) + override = raw.pop('override') + return Config(required_checks=frozenset(raw.pop('required_checks')), bot_logins=tuple(raw.pop('bot_logins')), + lens_author_associations=tuple(raw.pop('lens_author_associations')), + override_prefix=override['prefix'], override_association=override['author_association'], **raw) + + +def load(path): + try: + with open(path, encoding='utf-8') as f: + text = f.read() + except OSError as e: + raise ConfigError(f'{path}: cannot read it: {e}') from None + return parse(text, path) diff --git a/fork-ci/actions/pr-queue/lens.py b/fork-ci/actions/pr-queue/lens.py new file mode 100644 index 0000000000000..abd6fdb24ee03 --- /dev/null +++ b/fork-ci/actions/pr-queue/lens.py @@ -0,0 +1,319 @@ +"""Which head a pull request's review vouched for: the lens-comment rules of the merge queue (pr_queue.py). + +A lens is one review angle, posted as one PR comment whose FIRST line is its header: + + lens: · reviewer: · read at: + +also `Lens:`, `**Lens:**`, `## lens:`, `- lens:`. This grammar is fixed (README.md, "Lens comments"): it is the one +format the queue reads, and a project that writes its lens reports differently must change its reports, not this +file. What differs per project comes from the config (config.py): whose comments count at all (author associations; +which logins are bots), and the override comment (` <40-hex sha>: ...`, posted by an account with one author +association and never edited) that vouches for a head when the lenses read older commits. + +Only what GitHub records decides who wrote a comment: one by an account without a configured lens association (anyone +can comment on a public repository) or by a bot is ignored entirely, neither a read nor a lens that read nothing (the +run log names each such lens-looking comment). Among the rest, fail closed throughout: a comment that LOOKS like a lens +report but is not exactly one valid read, or a lens comment edited after posting or hidden (minimized), counts as a +lens that read nothing, so the queue never takes a reviewed PR for an unreviewed one. A hidden override counts nothing. A read is a full 40-hex sha: a shorter one could be matched by a commit pushed later. +""" +import re + +# One normaliser (norm_line) reads every line alike, plain or in a fence, a quote or an indented block: quote, list and +# heading markers, emphasis, backticks, pipes, links and HTML tags go first, so no Markdown shape hides a header or a +# `read at`. A header line (header_line) is a normalised line starting `lens:` with a hex `read at` in it. A first line +# that is indented 4+ spaces, quoted or a fence is never the header (lens_header), but its header line still counts as +# one (lens_problem: fail closed). +LENS_RE = re.compile(r'lens\s*:\s*(.*)', re.I) +# The name ends at the first field: ` · reviewer:` or ` · read at:` (also `read at `; the separator may also be +# `,` `—` or none). A bare `reviewer` or `read at` stays in the name (`data-integrity reviewer 1` and `... 2` are two +# lenses). +FIELD_RE = re.compile(r'\s*(?:[·,—]\s*)?\b(?:reviewer\s*:|read[\s-]*at\b\s*(?::|[0-9a-f]{7}))', re.I) +READ_AT_RE = re.compile(r'\bread[\s-]*at\b\s*:?\s*([0-9a-f]{7,40})\b', re.I) +FULL_SHA = re.compile(r'[0-9a-f]{40}') +NO_HEADER = 'comment without a first-line lens header' +EDITED = 'edited after posting: post a new comment instead' +HIDDEN = 'hidden: post a new comment instead' +EMBEDDED = 'holds a lens header line' # lens_problem: `not a lens:` cannot clear it +# What a lens report looks like (ONE rule on normalised lines): on a plain line (outside code blocks and quotes) a +# `lens:`, a `read at:` or `read at `, `safe to merge`, or in its first TOP_LINES plain lines a Markdown heading +# naming a lens (LOOKS_HEADING_RE reads the raw line: normalising drops `#`), or two `covered:`/`checks:` field lines; +# on ANY line, fenced, indented or quoted too, a `read at` with a hex sha, a header line or a `lens:` field with any hex +# sha (loose_header). Such a comment without a valid first-line header is a lens that read nothing. So is a comment +# with two or more header lines (one comment per lens). A round, fix or note comment says so on its first line, +# `not a lens: ...`; that clears it only when none of its lines is a header line or a `lens:` field with a sha. +LOOKS_RE = re.compile(r'\blens\s*:|\bread[\s-]*at\b\s*(?::|[0-9a-f]{7})|\bsafe\s+to\s+merge\b', re.I) +NOT_A_LENS_RE = re.compile(r'not\s+a\s+lens\s*:', re.I) +FIELD_LINE_RE = re.compile(r'(?:covered|checks)\s*:', re.I) +LOOKS_HEADING_RE = re.compile(r' {0,3}#{1,6}[ \t].*\blens\b', re.I) +TOP_LINES = 5 +# Any hex sha with a digit (7-40 hex, not part of a longer word): `abc1234`, never `defaced` or `facade1x`. +HEX_RE = re.compile(r'(?`, also a `` placeholder), links `[x](y)` -> x, `*` and + backticks, `|` -> space, `_` at a word edge (`_lens_` -> lens; `pr_queue` stays).""" + # [^<>] and [^\[\]] / [^()]: a match cannot start inside another one, so unclosed brackets cost linear time, not + # time that grows with the square of the text (an unclosed `[` x 64 KB took minutes) + text = re.sub(r']*>', '', text) + text = re.sub(r'!?\[([^\[\]]*)\]\([^()]*\)', r'\1', text) + text = re.sub(r'[*`]', '', text).replace('|', ' ') + return re.sub(r'(?|[-+•](?=\s|$)|\d{1,9}[.)](?=\s|$)|#{1,6}(?=\s|$)|~{3,}|\[[ xX]\](?=\s|$))\s*', '', s) + return s.strip() + + +def opens_plain(line): + """The line is no code block, quote or fence (at most 3 leading spaces): only such a first line is a header.""" + return not re.match(r' {4}|\t|[ ]{0,3}(>|`{3}|~{3})', line) + + +def lens_key(name): + """One key per lens across rounds: the whole name, only case and whitespace normalised, minus a trailing round + marker (`r2`, `re-check`, `lens`) and Markdown emphasis around it. Everything else is the lens's identity: + 'data-integrity (DI-1)' and 'data-integrity (DI-2)' are different lenses; 'data-integrity DI-1 r2' = + 'Data-integrity DI-1'.""" + n, prev = name.lower(), None + while n != prev: + prev = n + n = ' '.join(n.split()).strip('*_`') + n = re.sub(r'\s+(r\d+|lens|re-?check)$', '', n) + return n or 'unnamed' + + +def names_a_lens(name): + """A header's name names a lens: it has a letter or digit, is no `<...>` template placeholder and is more than a + round marker (`r4`, `re-check`). Otherwise two such headers would share one key and the newer read would stand for + both.""" + key = lens_key(name) + return bool(re.search(r'[^\W_]', key)) and not re.search(r'<[^<>]*>', name) \ + and not re.fullmatch(r'unnamed|r\d+|lens|re-?check', key) + + +def lens_header(body): + """(name, sha or None) of a comment's lens header, or None. The header is the first non-blank line, if it opens + plain and its normalised form is a `lens: ...` line whose name names a lens.""" + first = next((line for line in (body or '').splitlines() if line.strip()), '') + if not opens_plain(first): + return None + line = norm_line(first) + m = LENS_RE.match(line) + if not m: + return None + rest = m.group(1) + field = FIELD_RE.search(rest) + name = rest[:field.start()] if field else rest + if not names_a_lens(name): + return None + at = READ_AT_RE.search(line) + return name, (at.group(1).lower() if at else None) + + +def plain_lines(body): + """The comment's lines outside fenced blocks, 4-space/tab indented blocks and quotes.""" + out, fence = [], None + for line in (body or '').splitlines(): + m = re.match(r' {0,3}(`{3,}|~{3,})', line) + if fence: + if m and m.group(1)[0] == fence[0] and len(m.group(1)) >= len(fence): + fence = None + continue + if m: + fence = m.group(1) + elif line.strip() and not re.match(r' {4}|\t|[ ]{0,3}>', line): + out.append(line) + return out + + +def header_line(line): + """A normalised line that is a lens header with a hex `read at`. A `` template line is none.""" + return bool(LENS_RE.match(line) and READ_AT_RE.search(line)) + + +def loose_header(line): + """A normalised line with a `lens:` field (at its start or after other text) naming any hex sha after it, however + the read is written (`read at commit X`, `reviewed at: X`, `read_at: X`, a commit URL, `(X)`). Never a valid + read; lens_problem flags it.""" + m = re.search(r'\blens\s*:(.*)', re.sub(r'\bnot\s+a\s+lens\s*:', ' ', line, flags=re.I), re.I) # opt-out: no field + return bool(m and HEX_RE.search(m.group(1))) + + +def no_lens_text(text): + """Text that can never count as a lens read, name a lens or look like a lens report (lens_problem), for anything + the queue quotes into a comment (gh errors): no `read at`, no `lens:`, no `safe to merge`.""" + text = clean_inline(text) + text = re.sub(r'\bread([\s-]*)at\b', r'read\1@', text, flags=re.I) + text = re.sub(r'\bsafe(\s+)to(\s+)merge\b', r'safe\1to\2land', text, flags=re.I) + return re.sub(r'\blens(\s*):', r'lens\1-', text, flags=re.I) + + +def check_state(c): + """'ok', 'running' or the failing result's name, for one statusCheckRollup item: a CheckRun (status/conclusion) or a + commit StatusContext (state). Only an unfinished check is running: TIMED_OUT, CANCELLED, STARTUP_FAILURE, + ACTION_REQUIRED, STALE... are failing, never 'running'.""" + if c.get('__typename') == 'StatusContext' or 'conclusion' not in c: + st = (c.get('state') or '').upper() + return 'running' if st in ('', 'PENDING', 'EXPECTED') else 'ok' if st == 'SUCCESS' else st + concl = (c.get('conclusion') or '').upper() + return 'running' if not concl else 'ok' if concl in OK_CONCLUSIONS else concl + + +def latest_checks(rollup): + """The newest item per check (workflow + name, or status context). The rollup lists every run of a check on the + head: a run cancelled because a newer one replaced it stays in it, and must not outvote that newer run. An item that + has not started yet counts as the newest.""" + newest = {} + for c in rollup or []: + key = (c.get('__typename'), c.get('workflowName') or '', c.get('name') or c.get('context') or '') + when = c.get('startedAt') or '9999' + if key not in newest or when >= newest[key][0]: + newest[key] = (when, c) + return [c for _, c in newest.values()] + + +class Review: + """The rules that read a PR's comments, with the project's bot logins and override comment (config.py).""" + + def __init__(self, bot_logins, override_prefix, override_association, lens_associations, log=print): + self.bots = tuple(b.lower() for b in bot_logins) + self.override_re = re.compile(re.escape(override_prefix) + r' ([0-9a-f]{40}):') + self.override_association = override_association + self.lens_associations = tuple(lens_associations) + self.log, self.logged = log, set() + + def is_bot(self, post): + login = ((post.get('author') or {}).get('login') or '').lower() + return login in self.bots or login.endswith('[bot]') + + def counts(self, post): + """The comment or review takes part in the review at all: GitHub records its author with one of the configured + lens associations. Everyone else's posts are ignored entirely: a stranger's lens-looking comment neither + vouches for a head nor blocks one. Hidden (minimized) posts of these authors still take part, as lenses that + read nothing (lens_entries): hiding old rounds is routine, and must not make a reviewed PR look unreviewed.""" + return post.get('authorAssociation') in self.lens_associations + + @staticmethod + def hidden(post): + """Hidden (minimized). gh gives no isMinimized for reviews, so a review counts as shown.""" + return post.get('isMinimized') is True + + def override_sha(self, post): + """The sha a valid override comment vouches for, else None. Text proves nothing, so only what GitHub itself + records counts: written by an account with the configured author association, never edited since + (includesCreatedEdit false) and not hidden. A missing includesCreatedEdit counts as not valid.""" + if post.get('authorAssociation') != self.override_association or post.get('includesCreatedEdit') is not False \ + or self.hidden(post): + return None + m = self.override_re.match(post.get('body') or '') + return m.group(1) if m else None + + def lens_problem(self, post): + """Why a comment that looks like a lens report is not one valid lens read (None: it is one, or it does not look + like a lens report). An override comment never counts. Every line is read normalised, in code blocks and + quotes too. Two or more header lines, a first-line header that names no lens, or a header line that is not the + first plain line: flagged, and `not a lens:` cannot clear it (the text holds EMBEDDED).""" + body = post.get('body') or '' + if self.override_re.match(body): + return None + lines = body.splitlines() + first = next((line for line in lines if line.strip()), '') + normed, start = [norm_line(line) for line in lines], f'starts with {first.strip()[:60]!r}' + at = next((i for i, line in enumerate(lines) if line.strip()), 0) + # a header line, or (after the first line) a line starting `lens:` with a sha in any form (a second lens's + # loosely written read behind a valid header). Only at the line start: `lens:` in mid-line is often a mention. + headers = sum(header_line(line) or (i > at and bool((m := LENS_RE.match(line)) and HEX_RE.search(m.group(1)))) + for i, line in enumerate(normed)) + if headers > 1: + return f'{EMBEDDED} {headers} times (post one comment per lens), {start}' + if lens_header(body): + return None + if opens_plain(first) and LENS_RE.match(norm_line(first)): + return f'its first-line header names no lens (a placeholder, a round or nothing), {start}' + if headers: + return f'{EMBEDDED} that is not its first plain line (a later line, a code block, quote or table), {start}' + if any(loose_header(line) for line in normed): + return f'{EMBEDDED} (a lens line with a sha not written `read at: `), {start}' + if opens_plain(first) and NOT_A_LENS_RE.match(norm_line(first)): + return None + plain = plain_lines(body) + if sum(bool(FIELD_LINE_RE.match(norm_line(line))) for line in plain) >= 2: # fields of a headerless report + return start + if any(READ_AT_RE.search(line) for line in normed) or any(LOOKS_RE.search(norm_line(line)) for line in plain) \ + or any(LOOKS_HEADING_RE.match(line) for line in plain[:TOP_LINES]): + return start + return None + + def lens_posts(self, pr): + """[(when, index, post)] of the PR's comments and reviews, bots skipped.""" + posts = [(c.get('createdAt') or '', c) for c in pr.get('comments') or []] + posts += [(r.get('submittedAt') or '', r) for r in pr.get('reviews') or []] + return [(when, i, post) for i, (when, post) in enumerate(posts) if not self.is_bot(post)] + + def lens_entries(self, pr): + """{lens key: ((when, index), sha or None, why or None)}: each lens's NEWEST header, from the posts that count + (counts). A comment that looks like a lens report but is not one valid read (lens_problem) is an entry of its + own with no sha: it read nothing until it is re-posted as one comment per lens with a first-line header, or an + override covers it. A lens comment edited after posting (includesCreatedEdit not false: GitHub records that it + changed, not what) or hidden (minimized) read nothing until that lens posts a new comment. A lens-looking post + that does not count is logged (log only, never a comment), so a wrong lens_author_associations shows in the + run.""" + found = {} + for when, i, post in self.lens_posts(pr): + where = post.get('url') or f'by {(post.get("author") or {}).get("login") or "?"} at {when or "?"}' + if not self.counts(post): # the author first: a stranger's text is only ever read in part, for the log + head = {**post, 'body': (post.get('body') or '')[:STRANGER_SCAN]} + if where not in self.logged and (self.lens_problem(head) or lens_header(head['body'])): + self.logged.add(where) + association = post.get('authorAssociation') + self.log(f'ignored a lens-looking post {where}: ' + f'{"author association " + association if association else "no author association"} ' + f'is not one of lens_author_associations ({", ".join(self.lens_associations)})') + continue + problem = self.lens_problem(post) + header = None if problem else lens_header(post.get('body') or '') + if problem: + hidden = ', hidden' if self.hidden(post) else '' + found[f'{NO_HEADER} ({where}, {problem}{hidden})'] = ((when, i), None, None) + continue + if not header: + continue + key = lens_key(header[0]) + if key not in found or (when, i) >= found[key][0]: + why = HIDDEN if self.hidden(post) else EDITED if post.get('includesCreatedEdit') is not False else None + found[key] = ((when, i), None, why) if why else ((when, i), header[1], None) + return found + + def reviewed_head(self, pr): + """(reviewed, sha, why). Not reviewed (no lens comments): (False, None, ...). Reviewed: the one full 40-hex sha + every lens's newest read names. A shorter read names nothing: the queue can only match a prefix against the + commits GitHub lists now, and after a force-push a new commit can be made to share the prefix of the dropped + one that was read. A full sha need not be a commit of the PR now (a rebase or force-push drops the read + commit; GitHub keeps it, and the queue compares content). An override covers each lens whose newest read is + older than it. Lenses that name different commits, a short sha or none: sha None.""" + found = self.lens_entries(pr) + overrides = [((when, i), sha) for when, i, post in self.lens_posts(pr) for sha in [self.override_sha(post)] + if sha] + if not found: + return False, None, 'no lens comments' + newest = max(overrides) if overrides else None + reads = {k: (newest[1] if newest and at < newest[0] else sha if FULL_SHA.fullmatch(sha or '') else None) + for k, (at, sha, _) in found.items()} + shas = set(reads.values()) + if len(shas) == 1 and None not in shas: + return True, shas.pop(), 'every lens read it' + + def gap(k): + _, sha, why = found[k] + return why or (f'{sha[:12]}: not a full 40-hex sha' if sha else 'no sha: no single commit of this PR') + listed = ', '.join(f'{k} {v[:12] if v else "(" + gap(k) + ")"}' for k, v in sorted(reads.items())) + return True, None, f'the lenses did not all read one head: {listed}' diff --git a/fork-ci/actions/pr-queue/lens.test.py b/fork-ci/actions/pr-queue/lens.test.py new file mode 100644 index 0000000000000..2f3e80a1019a0 --- /dev/null +++ b/fork-ci/actions/pr-queue/lens.test.py @@ -0,0 +1,320 @@ +"""Tests of lens.py and config.py (run: python3 fork-ci/actions/pr-queue/lens.test.py). + +testdata/lens-corpus.jsonl holds, one case per line, every call the source project's lens tests made to its copy of +these rules, with that copy's answer (README.md, "Where the rules come from"): 2021 cases, replayed here against lens.py. Logins and the +project name in it were replaced (owner, proj); the replaced corpus was checked against the source copy before it was +committed, with the source's override prefix set to `proj ready --head`. Where the port differs from the source on +purpose, the replay says so (Corpus). +""" +import copy, json, os, re, sys, unittest + +sys.dont_write_bytecode = True # no __pycache__ next to the scripts + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) +import config # noqa: E402 +import lens # noqa: E402 + +CORPUS = os.path.join(HERE, 'testdata', 'lens-corpus.jsonl') +SOURCE = lens.Review(('coderabbitai', 'github-actions', 'copilot'), 'proj ready --head', 'OWNER', ('OWNER',)) +SHA_A, SHA_B, SHA_C = 'a' * 40, 'b' * 40, 'c' * 40 +VALID = { + 'required_checks': ['build', 'test'], 'merge_method': 'squash', 'delete_branch': True, + 'bot_logins': ['review-bot'], 'lens_author_associations': ['OWNER'], + 'override': {'prefix': 'tool ready --head', 'author_association': 'OWNER'}, + 'ready_command': 'tool ready {pr}', 'push_command': 'tool push', 'lens_format_doc': 'docs/review.md', + 'head_check': 'test', +} +# The port's deliberate changes to recorded reviewed_head answers (README.md, "Where the rules come from"): a read +# shorter than 40 hex, or a lens comment edited after posting, is a lens that read nothing. +SHORT_READ = re.compile(r'read[\s*`_-]*at\b[\s*`:_[]*([0-9a-f]{7,39})(?![0-9a-z])', re.I) +CHANGED = ('not a full 40-hex sha', lens.EDITED) + + +def post(body, login='someone', when='2026-01-01T00:00:00Z', **extra): + """A comment as gh shows it, by default from the owner and never edited; a field set to ... is left out.""" + p = {'body': body, 'author': {'login': login}, 'createdAt': when, 'authorAssociation': 'OWNER', + 'includesCreatedEdit': False, **extra} + return {k: v for k, v in p.items() if v is not ...} + + +def stranger(body, when='2026-01-02T00:00:00Z', association='NONE', **extra): + return post(body, login='drive-by', when=when, authorAssociation=association, **extra) + + +def pr(*comments, head=SHA_B, commits=(SHA_A, SHA_B)): + return {'headRefOid': head, 'comments': list(comments), 'reviews': [], 'commits': [{'oid': c} for c in commits]} + + +def as_owner(pr): + """A recorded PR whose posts carry no GitHub author fields: the source's repository is private, so every one was + written by an account with write access; posts that carry a field keep what was recorded.""" + pr = copy.deepcopy(pr) + for p in (pr.get('comments') or []) + (pr.get('reviews') or []): + if 'authorAssociation' not in p and 'includesCreatedEdit' not in p: + p.update(authorAssociation='OWNER', includesCreatedEdit=False) + return pr + + +class Corpus(unittest.TestCase): + def test_every_recorded_call_gives_the_source_answer(self): + """Every recorded answer, except: full_sha is gone (short reads name nothing), and a reviewed_head case whose + input holds a short read or an edited lens comment may only change to no head, for that reason.""" + with open(CORPUS, encoding='utf-8') as f: + cases = [json.loads(line) for line in f] + self.assertEqual(len(cases), 2021) + fns = {'lens_problem': SOURCE.lens_problem, 'reviewed_head': lambda pr: SOURCE.reviewed_head(as_owner(pr)), + 'override_sha': SOURCE.override_sha, 'lens_header': lens.lens_header, 'no_lens_text': lens.no_lens_text, + 'latest_checks': lens.latest_checks, 'check_state': lens.check_state, 'lens_key': lens.lens_key} + self.assertEqual({c['fn'] for c in cases}, set(fns) | {'full_sha'}) + wrong, changed = [], 0 + for c in (c for c in cases if c['fn'] in fns): + got = json.loads(json.dumps(fns[c['fn']](*c['args']))) + if got == c['out']: + continue + posts = (c['args'][0].get('comments') or []) + (c['args'][0].get('reviews') or []) \ + if c['fn'] == 'reviewed_head' else [] + cause = any(SHORT_READ.search(p.get('body') or '') or p.get('includesCreatedEdit') for p in posts) + if cause and got[:2] == [True, None] and any(w in got[2] for w in CHANGED): + changed += 1 + continue + wrong.append(f'{c["fn"]}{json.dumps(c["args"])[:160]}: got {got!r}, source {c["out"]!r}') + self.assertEqual(wrong, [], f'{len(wrong)} of {len(cases)} differ; first: {wrong[:3]}') + self.assertEqual(changed, 54, 'answers changed on purpose (a short read or an edited lens comment)') + + +class Gaps(unittest.TestCase): + """Rules the corpus does not pin (a mutation of each passed it).""" + def test_a_lens_heading_counts_only_in_the_first_five_plain_lines(self): + top = ['Summary', 'one', 'two', 'three'] + self.assertIsNotNone(SOURCE.lens_problem(post('\n'.join(top + ['## Lens correctness', 'text'])))) + self.assertIsNone(SOURCE.lens_problem(post('\n'.join(top + ['four', '## Lens correctness', 'text'])))) + + def test_a_hex_word_without_a_digit_is_no_sha(self): + self.assertIsNone(SOURCE.lens_problem(post('Notes\n```\nlens: effaced\n```'))) + self.assertIn(lens.EMBEDDED, SOURCE.lens_problem(post('Notes\n```\nlens: effaced1\n```'))) + + +class ProjectRules(unittest.TestCase): + """What the config changes: the override comment and the bot logins.""" + def test_the_configured_override_prefix_counts_and_another_does_not(self): + r = lens.Review((), 'tool ready --head', 'OWNER', ('OWNER',)) + mine = post(f'tool ready --head {SHA_B}: read the merge', authorAssociation='OWNER', includesCreatedEdit=False) + other = dict(mine, body=f'proj ready --head {SHA_B}: read the merge') + self.assertEqual(r.override_sha(mine), SHA_B) + self.assertIsNone(r.override_sha(other)) + + def test_an_override_counts_only_from_the_configured_association_and_unedited(self): + r = lens.Review((), 'tool ready --head', 'MEMBER', ('MEMBER',)) + body = f'tool ready --head {SHA_B}: read it' + self.assertEqual(r.override_sha(post(body, authorAssociation='MEMBER', includesCreatedEdit=False)), SHA_B) + for bad in ({'authorAssociation': 'OWNER', 'includesCreatedEdit': False}, # not the configured one + {'authorAssociation': 'MEMBER', 'includesCreatedEdit': True}, # edited after posting + {'authorAssociation': 'MEMBER', 'includesCreatedEdit': ...}): # GitHub did not say + self.assertIsNone(r.override_sha(post(body, **bad)), bad) + + def test_an_override_covers_older_lens_reads(self): + r = lens.Review((), 'tool ready --head', 'OWNER', ('OWNER',)) + p = pr(post(f'lens: correctness · reviewer: x · read at: {SHA_A}', when='2026-01-01T00:00:00Z'), + post(f'tool ready --head {SHA_B}: read the rest', when='2026-01-02T00:00:00Z', + authorAssociation='OWNER', includesCreatedEdit=False)) + self.assertEqual(r.reviewed_head(p), (True, SHA_B, 'every lens read it')) + + def test_a_configured_bot_and_any_login_ending_in_bot_never_count(self): + r = lens.Review(('Review-Bot',), 'tool ready --head', 'OWNER', ('OWNER',)) + body = f'lens: correctness · reviewer: x · read at: {SHA_A}' + for login in ('review-bot', 'helper[bot]'): + self.assertEqual(r.reviewed_head(pr(post(body, login=login))), (False, None, 'no lens comments'), login) + self.assertEqual(r.reviewed_head(pr(post(body))), (True, SHA_A, 'every lens read it')) + + def test_lenses_that_read_different_heads_name_no_head(self): + p = pr(post(f'lens: correctness · reviewer: x · read at: {SHA_A}'), + post(f'lens: data-integrity · reviewer: y · read at: {SHA_B}')) + reviewed, sha, why = SOURCE.reviewed_head(p) + self.assertEqual((reviewed, sha), (True, None)) + self.assertIn('did not all read one head', why) + + +class WhoCounts(unittest.TestCase): + """Only posts GitHub records as written by a configured lens association, shown and never edited, are reads.""" + R = lens.Review((), 'tool ready --head', 'OWNER', ('OWNER', 'COLLABORATOR'), log=lambda line: None) + OWN = post(f'lens: correctness · reviewer: x · read at: {SHA_A}', when='2026-01-01T00:00:00Z') + + def head(self, *posts, commits=(SHA_A, SHA_B)): + return self.R.reviewed_head(pr(*posts, commits=commits)) + + def test_a_strangers_lens_comment_never_moves_the_read_head(self): # the blocker: a forged read of a later push + forged = f'lens: correctness · reviewer: x · read at: {SHA_B}' + for association in ('NONE', 'CONTRIBUTOR', 'FIRST_TIME_CONTRIBUTOR', 'FIRST_TIMER', 'MEMBER', ...): + self.assertEqual(self.head(self.OWN, stranger(forged, association=association)), + (True, SHA_A, 'every lens read it'), association) + self.assertEqual(self.head(stranger(forged)), (False, None, 'no lens comments')) # nor makes one reviewed + collaborator = post(forged, when='2026-01-02T00:00:00Z', authorAssociation='COLLABORATOR') + self.assertEqual(self.head(self.OWN, collaborator), (True, SHA_B, 'every lens read it'), + 'a configured association counts') + + def test_a_strangers_look_alike_or_junk_comment_neither_vouches_nor_blocks(self): # the denial of service + for junk in ('lgtm, safe to merge', 'looks fine, read at: deadbee1', f'read at: {SHA_A[:7]}', + f'lens: correctness · reviewer: x · read at: {SHA_A[:7]}', f'lens: other · read at: {SHA_B}'): + self.assertEqual(self.head(self.OWN, stranger(junk)), (True, SHA_A, 'every lens read it'), junk) + self.assertIsNotNone(self.R.lens_problem(post('lgtm, safe to merge')), 'the same text from the owner blocks') + + def test_a_hidden_lens_comment_reads_nothing_until_that_lens_posts_again(self): + # hidden (minimized) is how old review rounds are tidied away, so hiding must never make a reviewed PR look + # unreviewed: an unreviewed PR vouches for whatever head it has (the queue's "no lens comments" path) + hidden = dict(self.OWN, isMinimized=True) + reviewed, sha, why = self.head(hidden) + self.assertEqual((reviewed, sha), (True, None), 'every lens comment hidden must not read as "no lens comments"') + self.assertIn(f'correctness ({lens.HIDDEN})', why) + newer = post(f'lens: correctness · reviewer: x · read at: {SHA_B}', when='2026-01-02T00:00:00Z') + self.assertEqual(self.head(self.OWN, newer), (True, SHA_B, 'every lens read it')) + self.assertEqual(self.head(self.OWN, dict(newer, isMinimized=True))[:2], (True, None), + 'a hidden newest read does not bring the older read back') + self.assertEqual(self.head(hidden, newer), (True, SHA_B, 'every lens read it'), 'a new comment of the lens counts') + for junk in ('lgtm, safe to merge', f'lens: correctness · read at {SHA_B[:7]}'): # hidden look-alikes block too + self.assertEqual(self.head(post(junk, isMinimized=True))[:2], (True, None), junk) + + def test_hidden_posts_that_never_counted_stay_ignored(self): + self.assertEqual(self.head(post('thanks, merging soon', isMinimized=True)), (False, None, 'no lens comments')) + forged = stranger(f'lens: correctness · reviewer: x · read at: {SHA_B}', isMinimized=True) + self.assertEqual(self.head(forged), (False, None, 'no lens comments')) + self.assertEqual(self.head(self.OWN, forged), (True, SHA_A, 'every lens read it')) + + def test_a_hidden_override_does_not_count(self): # README: hidden comments count nothing + over = post(f'tool ready --head {SHA_B}: read the rest', when='2026-01-02T00:00:00Z') + self.assertEqual(self.head(self.OWN, over), (True, SHA_B, 'every lens read it')) + self.assertEqual(self.head(self.OWN, dict(over, isMinimized=True)), (True, SHA_A, 'every lens read it')) + + def test_a_strangers_huge_comment_costs_no_time(self): # SEC-2 r3 major: anyone can post 64 KB of `[` + import time + shapes = ('[' * 65536, ' data change applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["**Approach (design / root cause lens, own view first, then the PR body):** I agree with the approach.\n\n```\nlens: design / root cause · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: correctness · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: data-integrity DI-1 · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["**Not a lens:** fix round\n## Lens findings and fixes\nread at: b0b0b0b"], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: no** (2 majors, both small fixes)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: no** (2 majors, both small fixes)\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: yes** (no findings)"], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: yes** (security lens: no blocker, no major. 3 minors, 6 nits.)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: yes** (security lens: no blocker, no major. 3 minors, 6 nits.)\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["**Safe to merge: yes**\n\nlens: correctness · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["> lens: correctness · read at: b0b0b0b\n> safe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["> lens: correctness · reviewer: x · read at: b0b0b0b\nAgreed with the above."], "fn": "lens_header", "out": null} +{"args": ["> proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"], "fn": "lens_header", "out": null} +{"args": ["A brief for the next round:\n\n```\nlens: correctness · read at: b0b0b0b\n```"], "fn": "lens_header", "out": null} +{"args": ["A brief, the template:\n\n```\nlens: · reviewer: · read at: \n```"], "fn": "lens_header", "out": null} +{"args": ["Brief for the lenses, post this:\n```\nlens: · reviewer: () · read at: \ncovered: \n```"], "fn": "lens_header", "out": null} +{"args": ["Checked it all.\n\nsafe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-1 · reviewer: lens-542-di-1 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"], "fn": "lens_header", "out": null} +{"args": ["DI-1 lens (Opus xhigh), read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-2 · reviewer: lens-542-di-2 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"], "fn": "lens_header", "out": null} +{"args": ["DI-2 lens (Opus xhigh), read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nsafe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["DI-2 lens (Opus xhigh), read at: abc0abc\nsafe to merge: yes\n\n> lens: correctness · reviewer: x (t) · read at: abc0abc\n\nI agree with that."], "fn": "lens_header", "out": null} +{"args": ["DI-2 lens (Opus xhigh), read at: abc0abc\nsafe to merge: yes\n\n```\nlens: correctness · reviewer: x (t) · read at: abc0abc\n```\n\nI agree with that."], "fn": "lens_header", "out": null} +{"args": ["LGTM, thanks"], "fn": "lens_header", "out": null} +{"args": ["Lens: correctness r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "b0b0b0b"]} +{"args": ["Look:\n\n lens: correctness · read at: b0b0b0b"], "fn": "lens_header", "out": null} +{"args": ["Merged main into it; the lenses come next."], "fn": "lens_header", "out": null} +{"args": ["Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n lens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n | field | value |\n |---|---|\n | lens | correctness |\n | read at | abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> lens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> | field | value |\n> |---|---|\n> | lens | correctness |\n> | read at | abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Report:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["Round 2 notes\nthe tests lens read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["Round 3 fixes\nlens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["Safe to merge: no\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["Safe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["Safe to merge: no\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."], "fn": "lens_header", "out": null} +{"args": ["Safe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["Summary first\n**Lens:** correctness"], "fn": "lens_header", "out": null} +{"args": ["Thanks, round 7 checked.\n\nScope: the round diff.\nContext line.\nMore context.\nEven more.\n## Correctness lens (Opus high)\ncovered: proj.py lens_problem\nchecks: 40 shapes\nfinding: major proj.py:1100 x"], "fn": "lens_header", "out": null} +{"args": ["\n\nlens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["```\nlens: concurrency\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · read at: b0b0b0b\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: 0a60d2aab6a60f0c26846f117d59369047afaeb4\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: 508f89d19d21adc3cd262aff7c427d313d86d428\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: correctness · reviewer: x · read at: d6d662c\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: data-integrity DI-1 · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"], "fn": "lens_header", "out": null} +{"args": ["```\nlens: design / root cause · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"], "fn": "lens_header", "out": null} +{"args": ["le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: · reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: · reviewer: lens-a · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: · reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: · reviewer: lens-b · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: · reviewer: x · read at: b0b0b0b"], "fn": "lens_header", "out": null} +{"args": ["lens: Data-integrity DI-1 · reviewer: a (t1) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["Data-integrity DI-1", "abc0abc"]} +{"args": ["lens: Item and data integrity · reviewer: x"], "fn": "lens_header", "out": ["Item and data integrity", null]} +{"args": ["lens: · reviewer: a · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["lens: a · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["a", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]} +{"args": ["lens: b · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"], "fn": "lens_header", "out": ["b", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"]} +{"args": ["lens: c · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["c", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]} +{"args": ["lens: c · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"], "fn": "lens_header", "out": ["c", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"]} +{"args": ["lens: correctness (pr_queue.py) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness (pr_queue.py)", "abc0abc"]} +{"args": ["lens: correctness (proj.py) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness (proj.py)", "abc0abc"]} +{"args": ["lens: correctness (proj.py) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness (proj.py) r2", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: a (t1) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: a (t1) · read at: abc0abc\nfindings: none\ncovered: X.java"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: a (t1) · read at: b0b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b0b"]} +{"args": ["lens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none\nquoting the old round, read at: abc0abc\nlens design said: fine"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: a · read at: 1234567"], "fn": "lens_header", "out": ["correctness", "1234567"]} +{"args": ["lens: correctness · reviewer: a"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)"], "fn": "lens_header", "out": ["correctness", "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 1234567\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": ["correctness", "1234567"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 174ef306ca6cad085421ddc32c85f24f3df04d7d\nfindings: none"], "fn": "lens_header", "out": ["correctness", "174ef306ca6cad085421ddc32c85f24f3df04d7d"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 4336224\nfindings: none"], "fn": "lens_header", "out": ["correctness", "4336224"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 479578f\nfindings: none"], "fn": "lens_header", "out": ["correctness", "479578f"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 850e438\nfindings: none"], "fn": "lens_header", "out": ["correctness", "850e438"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: 9e5089f\nfindings: none"], "fn": "lens_header", "out": ["correctness", "9e5089f"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: a1a1a1a1a1a1\nfindings: none"], "fn": "lens_header", "out": ["correctness", "a1a1a1a1a1a1"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["correctness", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: abc0abc\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none"], "fn": "lens_header", "out": ["correctness", "bbd7144"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none"], "fn": "lens_header", "out": ["correctness", "d4d4d4d"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: e00b0ad\nfindings: none"], "fn": "lens_header", "out": ["correctness", "e00b0ad"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: e3e2107\nfindings: none"], "fn": "lens_header", "out": ["correctness", "e3e2107"]} +{"args": ["lens: correctness · reviewer: x (t) · read at: f511b8f\nfindings: none"], "fn": "lens_header", "out": ["correctness", "f511b8f"]} +{"args": ["lens: correctness · reviewer: x · read at commit b0b0b0b"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none"], "fn": "lens_header", "out": ["correctness", "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c"]} +{"args": ["lens: correctness · reviewer: x · read at: 26103a9\nfindings: none"], "fn": "lens_header", "out": ["correctness", "26103a9"]} +{"args": ["lens: correctness · reviewer: x · read at: 32bd303\nfindings: none"], "fn": "lens_header", "out": ["correctness", "32bd303"]} +{"args": ["lens: correctness · reviewer: x · read at: 4ddc4f7\nfindings: none"], "fn": "lens_header", "out": ["correctness", "4ddc4f7"]} +{"args": ["lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none"], "fn": "lens_header", "out": ["correctness", "a1a1a1a"]} +{"args": ["lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["correctness", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]} +{"args": ["lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\nRe the r7 report (lens: data-integrity DI-2 · read at abc0abc): fixed."], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"], "fn": "lens_header", "out": ["correctness", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"]} +{"args": ["lens: correctness · reviewer: x · read at: d588959\nfindings: none"], "fn": "lens_header", "out": ["correctness", "d588959"]} +{"args": ["lens: correctness · reviewer: x · read at: dededededededededededededededededededede"], "fn": "lens_header", "out": ["correctness", "dededededededededededededededededededede"]} +{"args": ["lens: correctness · reviewer: x · read at: eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\nfindings: none"], "fn": "lens_header", "out": ["correctness", "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"]} +{"args": ["lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none"], "fn": "lens_header", "out": ["correctness", "fca2958366443b7664d2c47b4995e562b7d7aeee"]} +{"args": ["lens: correctness · reviewer: x"], "fn": "lens_header", "out": ["correctness", null]} +{"args": ["lens: correctness r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "b0b0b0b"]} +{"args": ["lens: correctness r2 · reviewer: x · read at: a9cc126\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "a9cc126"]} +{"args": ["lens: correctness r2 · reviewer: x · read at: b00c8cc0dbfdf05db516667eec0cdab343796b14\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "b00c8cc0dbfdf05db516667eec0cdab343796b14"]} +{"args": ["lens: correctness r2 · reviewer: x · read at: b2b2b2b\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "b2b2b2b"]} +{"args": ["lens: correctness r2 · reviewer: x · read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3\nfindings: none"], "fn": "lens_header", "out": ["correctness r2", "c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3"]} +{"args": ["lens: correctness, read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": ["lens: correctness, read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["correctness", "b0b0b0b"]} +{"args": ["lens: data-integrity (DI-1 of 2) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-1 of 2)", "abc0abc"]} +{"args": ["lens: data-integrity (DI-1 of 2) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-1 of 2) r2", "b0b0b0b"]} +{"args": ["lens: data-integrity (DI-1) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-1)", "abc0abc"]} +{"args": ["lens: data-integrity (DI-1) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-1) r2", "b0b0b0b"]} +{"args": ["lens: data-integrity (DI-2 of 2) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-2 of 2)", "abc0abc"]} +{"args": ["lens: data-integrity (DI-2) · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity (DI-2)", "abc0abc"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: 479578f\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "479578f"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: 6954cd9\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "6954cd9"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: 850e4380baa37266616c13e019733e2dba5776c7\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "850e4380baa37266616c13e019733e2dba5776c7"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: a1a1a1afffff\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "a1a1a1afffff"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "abc0abc"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "bbd7144382c36a1194a24c6d22234a5956385f0d"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "d4d4d4d"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: e00b0adda0ed29bba6af45d1b263405d45db9ddf\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "e00b0adda0ed29bba6af45d1b263405d45db9ddf"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: e3e2107\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "e3e2107"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x (t) · read at: f511b8f3e86e\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "f511b8f3e86e"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "a1a1a1a1a"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"], "fn": "lens_header", "out": ["data-integrity DI-1", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: data-integrity DI-1 · reviewer: x · read at: b2b2b2b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "b2b2b2b"]} +{"args": ["lens: data-integrity DI-1 · reviewer: y (t) · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]} +{"args": ["lens: data-integrity DI-1 r2 · reviewer: a (t1) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1 r2", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: data-integrity DI-1 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-1 r4", "b0b0b0b"]} +{"args": ["lens: data-integrity DI-2 · reviewer: x (t) · read at: 6954cd96eca1cd34fc2c9df1c65284687d7aa8c6\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-2", "6954cd96eca1cd34fc2c9df1c65284687d7aa8c6"]} +{"args": ["lens: data-integrity DI-2 · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-2", "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"]} +{"args": ["lens: data-integrity DI-2 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity DI-2 r4", "b0b0b0b"]} +{"args": ["lens: data-integrity · reviewer: twin 1 · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity", "abc0abc"]} +{"args": ["lens: data-integrity · reviewer: twin 2 · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity", "b0b0b0b"]} +{"args": ["lens: data-integrity — DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity — DI-1", "abc0abc"]} +{"args": ["lens: data-integrity — DI-1 r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity — DI-1 r2", "b0b0b0b"]} +{"args": ["lens: data-integrity — DI-2 · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity — DI-2", "abc0abc"]} +{"args": ["lens: data-integrity reviewer 1 · reviewer: x · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity reviewer 1", "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"]} +{"args": ["lens: data-integrity reviewer 2 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": ["data-integrity reviewer 2", "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"]} +{"args": ["lens: data-integrity, DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity, DI-1", "abc0abc"]} +{"args": ["lens: data-integrity, DI-1 r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["data-integrity, DI-1 r2", "b0b0b0b"]} +{"args": ["lens: data-integrity, DI-2 · reviewer: x (t) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["data-integrity, DI-2", "abc0abc"]} +{"args": ["lens: design / root cause · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": ["design / root cause", "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"]} +{"args": ["lens: design · reviewer: a (t1) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["design", "abc0abc"]} +{"args": ["lens: design · reviewer: x · read at: aaaaaaa\nfindings: none"], "fn": "lens_header", "out": ["design", "aaaaaaa"]} +{"args": ["lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none"], "fn": "lens_header", "out": ["di-1", "26103a90a5e13f5abecba90fcd6020e98c4a1998"]} +{"args": ["lens: di-1 · reviewer: x · read at: 4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d\nfindings: none"], "fn": "lens_header", "out": ["di-1", "4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d"]} +{"args": ["lens: di-1 · reviewer: x · read at: 9a9f350\nfindings: none"], "fn": "lens_header", "out": ["di-1", "9a9f350"]} +{"args": ["lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none"], "fn": "lens_header", "out": ["di-1", "a1a1a1a"]} +{"args": ["lens: di-1 r2 · reviewer: x · read at: a9cc1269ff51a60311faa036b4971f5478e03a35\nfindings: none"], "fn": "lens_header", "out": ["di-1 r2", "a9cc1269ff51a60311faa036b4971f5478e03a35"]} +{"args": ["lens: di-1 r2 · reviewer: x · read at: b00c8cc\nfindings: none"], "fn": "lens_header", "out": ["di-1 r2", "b00c8cc"]} +{"args": ["lens: di-1 re-check · reviewer: a (t1) · read at: b0b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["di-1 re-check", "b0b0b0b0b"]} +{"args": ["lens: r4 · reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: r4 · reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["lens: tests · reviewer: a (t1) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": ["tests", "abc0abc"]} +{"args": ["lens: tests · reviewer: x (t) · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": ["tests", "b0b0b0b"]} +{"args": ["lens: x · y"], "fn": "lens_header", "out": ["x · y", null]} +{"args": ["looks fine"], "fn": "lens_header", "out": null} +{"args": ["not a lens: ## Lens design r1\n\nlens: design · reviewer: x · read at: b0b0b0b\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: ## Lens design+tests r1 (Opus high)\n\nlens: design+tests · reviewer: x (Opus high) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nfinding: major a.py:3 x -> y (high)\n"], "fn": "lens_header", "out": null} +{"args": ["not a lens: a brief for the next round:\n\n```\nlens: correctness · read at: b0b0b0b\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: a reply\n\n> lens: correctness · read at: b0b0b0b\n> safe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["not a lens: a reply\n\n> the tests lens said: safe to merge: yes"], "fn": "lens_header", "out": null} +{"args": ["not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: \n lens: data-integrity DI-1 r3 · reviewer: b · read at: \n"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nReport:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying a report\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"], "fn": "lens_header", "out": null} +{"args": ["not a lens: round 5 fixes (commit b0b0b0b). Each finding, then the fix. Safe to merge after CI."], "fn": "lens_header", "out": null} +{"args": ["not a lens: round 5 fixes. DI-1 said safe to merge: yes, read at abc0abc"], "fn": "lens_header", "out": null} +{"args": ["not a lens: round notes"], "fn": "lens_header", "out": null} +{"args": ["not a lens: the brief for round 8\n\nReport:\n\n lens: · reviewer: () · read at: \n covered: "], "fn": "lens_header", "out": null} +{"args": ["not a lens: the brief for round 8\n\nReport:\n\n> lens: · reviewer: () · read at: \n> covered: "], "fn": "lens_header", "out": null} +{"args": ["not a lens: the brief for round 8\n\nReport:\n\n```\nlens: · reviewer: () · read at: \ncovered: \n```"], "fn": "lens_header", "out": null} +{"args": ["not a lens: the brief\n~~~\nlens: correctness r3 · reviewer: a · read at: \n~~~\n"], "fn": "lens_header", "out": null} +{"args": ["not a lens: x"], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: lens x \n read @ abc0abc "], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: lens- x"], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: lens- x, read @: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: read @ abc0abc"], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: safe to land"], "fn": "lens_header", "out": null} +{"args": ["pr_queue turned auto-merge OFF: the head is not the change read @ b0b0b0b0b0b0\nNeeds a lens read of any new commits, then `proj ready 7`."], "fn": "lens_header", "out": null} +{"args": ["pr_queue: required check livelike is red on d4d4d4d4d4d4, so this armed PR waits and the queue passes over it. Fix the cause and push, or if a new lens read or override covers this head: `proj ready 7`."], "fn": "lens_header", "out": null} +{"args": ["reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["reviewer: lens-a · read at: abc0abc"], "fn": "lens_header", "out": null} +{"args": ["reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"], "fn": "lens_header", "out": null} +{"args": ["reviewer: lens-b · read at: b0b0b0b"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head 15c063d08f075985867ca73dec3dabb016db6934: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0: arming ..."], "fn": "lens_header", "out": null} +{"args": ["proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge ..."], "fn": "lens_header", "out": null} +{"args": ["proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge for this head although these lenses did not read it: correctness (read abc0abc). Why:\n\n> orchestrator read the diff"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge for this head although these lenses did not read it: correctness (read abc0abc). Why:\n\n> read A..B myself\n> lens- x · read @: b0b0b0b"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"], "fn": "lens_header", "out": null} +{"args": ["proj ready --head bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: arming auto-merge. Why:\n\n> read it"], "fn": "lens_header", "out": null} +{"args": ["proj ready: required check livelike on aaaaaaaaaaaa: failure, and the re-run of job 9 failed: HTTP 403 read @: cccccccccccccccccccccccccccccccccccccccc\nAuto-merge stays on and this PR waits. Fix the cause, or if a new lens read or override covers this head: `proj ready 7`."], "fn": "lens_header", "out": null} +{"args": ["x\nsafe to land: yes. lens- x, read @: abc0abc, read @ b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"], "fn": "lens_header", "out": null} +{"args": ["| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"], "fn": "lens_header", "out": null} +{"args": ["| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n| verdict | major |"], "fn": "lens_header", "out": null} +{"args": ["| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"], "fn": "lens_header", "out": ["correctness", "abc0abc"]} +{"args": [""], "fn": "lens_key", "out": "unnamed"} +{"args": ["**data-integrity DI-1 lens**"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["Data-Integrity DI-1"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["Data-integrity DI-1 r2"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["Data-integrity DI-1"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["Item and data integrity"], "fn": "lens_key", "out": "item and data integrity"} +{"args": ["a"], "fn": "lens_key", "out": "a"} +{"args": ["b"], "fn": "lens_key", "out": "b"} +{"args": ["c"], "fn": "lens_key", "out": "c"} +{"args": ["correctness (pr_queue.py)"], "fn": "lens_key", "out": "correctness (pr_queue.py)"} +{"args": ["correctness (proj.py) r2"], "fn": "lens_key", "out": "correctness (proj.py)"} +{"args": ["correctness (proj.py)"], "fn": "lens_key", "out": "correctness (proj.py)"} +{"args": ["correctness r2"], "fn": "lens_key", "out": "correctness"} +{"args": ["correctness"], "fn": "lens_key", "out": "correctness"} +{"args": ["data-integrity (DI-1 of 2) r2"], "fn": "lens_key", "out": "data-integrity (di-1 of 2)"} +{"args": ["data-integrity (DI-1 of 2)"], "fn": "lens_key", "out": "data-integrity (di-1 of 2)"} +{"args": ["data-integrity (DI-1) r2"], "fn": "lens_key", "out": "data-integrity (di-1)"} +{"args": ["data-integrity (DI-1)"], "fn": "lens_key", "out": "data-integrity (di-1)"} +{"args": ["data-integrity (DI-2 of 2)"], "fn": "lens_key", "out": "data-integrity (di-2 of 2)"} +{"args": ["data-integrity (DI-2)"], "fn": "lens_key", "out": "data-integrity (di-2)"} +{"args": ["data-integrity DI-1 (Opus xhigh)"], "fn": "lens_key", "out": "data-integrity di-1 (opus xhigh)"} +{"args": ["data-integrity DI-1 r2"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-1 r3 re-check"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-1 r3"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-1 r4"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-1 re-check"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-1"], "fn": "lens_key", "out": "data-integrity di-1"} +{"args": ["data-integrity DI-2 r4"], "fn": "lens_key", "out": "data-integrity di-2"} +{"args": ["data-integrity DI-2"], "fn": "lens_key", "out": "data-integrity di-2"} +{"args": ["data-integrity — DI-1 r2"], "fn": "lens_key", "out": "data-integrity — di-1"} +{"args": ["data-integrity — DI-1"], "fn": "lens_key", "out": "data-integrity — di-1"} +{"args": ["data-integrity — DI-2"], "fn": "lens_key", "out": "data-integrity — di-2"} +{"args": ["data-integrity reviewer 1"], "fn": "lens_key", "out": "data-integrity reviewer 1"} +{"args": ["data-integrity reviewer 2"], "fn": "lens_key", "out": "data-integrity reviewer 2"} +{"args": ["data-integrity"], "fn": "lens_key", "out": "data-integrity"} +{"args": ["data-integrity, DI-1 r2"], "fn": "lens_key", "out": "data-integrity, di-1"} +{"args": ["data-integrity, DI-1"], "fn": "lens_key", "out": "data-integrity, di-1"} +{"args": ["data-integrity, DI-2"], "fn": "lens_key", "out": "data-integrity, di-2"} +{"args": ["design / root cause"], "fn": "lens_key", "out": "design / root cause"} +{"args": ["design"], "fn": "lens_key", "out": "design"} +{"args": ["di-1 r2"], "fn": "lens_key", "out": "di-1"} +{"args": ["di-1 re-check"], "fn": "lens_key", "out": "di-1"} +{"args": ["di-1"], "fn": "lens_key", "out": "di-1"} +{"args": ["r4"], "fn": "lens_key", "out": "r4"} +{"args": ["tests"], "fn": "lens_key", "out": "tests"} +{"args": ["x · y"], "fn": "lens_key", "out": "x · y"} +{"args": [{"body": "## Lens correctness (Opus xhigh)\nsafe to merge: yes"}], "fn": "lens_problem", "out": "starts with '## Lens correctness (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: 491f7ed919af9c405b9fb73c6a0fdd368b86c6ee\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\nfindings: none"}], "fn": "lens_problem", "out": "starts with '## Lens correctness r1 (Opus xhigh)'"} +{"args": [{"body": "## Lens correctness\nsafe to merge: yes"}], "fn": "lens_problem", "out": "starts with '## Lens correctness'"} +{"args": [{"body": "* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "**Approach (correctness lens, own view first, then the PR body):** I agree with the approach.\n\n```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (correctness lens, own view first, then the PR bo'"} +{"args": [{"body": "**Approach (design / root cause lens, own view first, then the PR body):** I agree with the approach.\n\n```\nlens: design / root cause · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (design / root cause lens, own view first, then t'"} +{"args": [{"body": "**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: correctness · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (design lens, own view first, then MIGRATIONS.md)'"} +{"args": [{"body": "**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: data-integrity DI-1 · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (design lens, own view first, then MIGRATIONS.md)'"} +{"args": [{"body": "**Not a lens:** fix round\n## Lens findings and fixes\nread at: b0b0b0b"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "**Safe to merge: no** (2 majors, both small fixes)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: no** (2 majors, both small fixes)'"} +{"args": [{"body": "**Safe to merge: no** (2 majors, both small fixes)\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: no** (2 majors, both small fixes)'"} +{"args": [{"body": "**Safe to merge: yes** (no findings)"}], "fn": "lens_problem", "out": "starts with '**Safe to merge: yes** (no findings)'"} +{"args": [{"body": "**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: yes** (security lens: no blocker)'"} +{"args": [{"body": "**Safe to merge: yes** (security lens: no blocker, no major. 3 minors, 6 nits.)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: yes** (security lens: no blocker, no major.'"} +{"args": [{"body": "**Safe to merge: yes** (security lens: no blocker, no major. 3 minors, 6 nits.)\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: yes** (security lens: no blocker, no major.'"} +{"args": [{"body": "**Safe to merge: yes**\n\nlens: correctness · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: yes**'"} +{"args": [{"body": "+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "> lens: correctness · read at: b0b0b0b\n> safe to merge: yes"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '> lens: correctness · read at: b0b0b0b'"} +{"args": [{"body": "> lens: correctness · reviewer: x · read at: b0b0b0b\nAgreed with the above."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '> lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "> proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "A brief for the next round:\n\n```\nlens: correctness · read at: b0b0b0b\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'A brief for the next round:'"} +{"args": [{"body": "A brief, the template:\n\n```\nlens: · reviewer: · read at: \n```"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "Brief for the lenses, post this:\n```\nlens: · reviewer: () · read at: \ncovered: \n```"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "Briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Briefs for r3, each lens posts:'"} +{"args": [{"body": "Checked it all.\n\nsafe to merge: yes"}], "fn": "lens_problem", "out": "starts with 'Checked it all.'"} +{"args": [{"body": "DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-1 · reviewer: lens-542-di-1 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d98635'"} +{"args": [{"body": "DI-1 lens (Opus xhigh), read at: abc0abc"}], "fn": "lens_problem", "out": "starts with 'DI-1 lens (Opus xhigh), read at: abc0abc'"} +{"args": [{"body": "DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-2 · reviewer: lens-542-di-2 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d98635'"} +{"args": [{"body": "DI-2 lens (Opus xhigh), read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nsafe to merge: yes"}], "fn": "lens_problem", "out": "starts with 'DI-2 lens (Opus xhigh), read at: abc0abc0abc0abc0abc0abc0abc'"} +{"args": [{"body": "DI-2 lens (Opus xhigh), read at: abc0abc\nsafe to merge: yes\n\n> lens: correctness · reviewer: x (t) · read at: abc0abc\n\nI agree with that."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read at: abc0abc'"} +{"args": [{"body": "DI-2 lens (Opus xhigh), read at: abc0abc\nsafe to merge: yes\n\n```\nlens: correctness · reviewer: x (t) · read at: abc0abc\n```\n\nI agree with that."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read at: abc0abc'"} +{"args": [{"body": "LGTM, thanks"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "Lens: correctness r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "Look:\n\n lens: correctness · read at: b0b0b0b"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Look:'"} +{"args": [{"body": "Merged main into it; the lenses come next."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "Orchestrator: briefs for round 3 (each lens posts its own comment).\n\n```\nBrief for both lenses. The first line of your comment:\n\nlens: data-integrity DI-1 r3 · reviewer: lens-r3-di1 (Opus xhigh) · read at: b0b0b0b\nlens: correctness r3 · reviewer: lens-r3-c (Opus high) · read at: b0b0b0b\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Orchestrator: briefs for round 3 (each lens posts its own co'"} +{"args": [{"body": "Orchestrator: briefs for round 3 (each lens posts its own comment).\n\n```\nBrief for both lenses. The first line of your comment:\n```md\nlens: data-integrity DI-1 r3 · reviewer: lens-r3-di1 (Opus xhigh) · read at: b0b0b0b\nlens: correctness r3 · reviewer: lens-r3-c (Opus high) · read at: b0b0b0b\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Orchestrator: briefs for round 3 (each lens posts its own co'"} +{"args": [{"body": "Orchestrator: briefs for round 3 (each lens posts its own comment).\n\n````text\nBrief for both lenses. The first line of your comment:\n```\nlens: data-integrity DI-1 r3 · reviewer: lens-r3-di1 (Opus xhigh) · read at: b0b0b0b\nlens: correctness r3 · reviewer: lens-r3-c (Opus high) · read at: b0b0b0b\n```\n````"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Orchestrator: briefs for round 3 (each lens posts its own co'"} +{"args": [{"body": "Orchestrator: r2 briefs for the lenses (each posts its own comment):\n\n```\nlens: correctness r2 · reviewer: lens-r2-c (Opus xhigh) · read at: b0b0b0b\nlens: data-integrity DI-1 r2 · reviewer: lens-r2-di1 (Opus xhigh) · read at: b0b0b0b\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Orchestrator: r2 briefs for the lenses (each posts its own c'"} +{"args": [{"body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report: lens: correctness · reviewer: lens-x (Opus xhigh) · '"} +{"args": [{"body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report: lens: correctness · reviewer: lens-x (Opus xhigh) · '"} +{"args": [{"body": "Report:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\n findings: none\n \n lens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major t.py:3 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n lens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n | field | value |\n |---|---|\n | lens | correctness |\n | read at | abc0abc |"}], "fn": "lens_problem", "out": "starts with 'Report:'"} +{"args": [{"body": "Report:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\n> findings: none\n> \n> lens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major t.py:3 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> lens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> | field | value |\n> |---|---|\n> | lens | correctness |\n> | read at | abc0abc |"}], "fn": "lens_problem", "out": "starts with 'Report:'"} +{"args": [{"body": "Report:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none\n\nlens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major t.py:3 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\nlens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n```"}], "fn": "lens_problem", "out": "starts with 'Report:'"} +{"args": [{"body": "Report:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none\n\nlens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major t.py:3 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Report:\n\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"}], "fn": "lens_problem", "out": "starts with 'Report:'"} +{"args": [{"body": "Report:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:'"} +{"args": [{"body": "Round 2 notes\nthe tests lens read at abc0abc"}], "fn": "lens_problem", "out": "starts with 'Round 2 notes'"} +{"args": [{"body": "Round 3 fixes\nlens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Round 3 fixes'"} +{"args": [{"body": "Safe to merge: no\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Safe to merge: no'"} +{"args": [{"body": "Safe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Safe to merge: no'"} +{"args": [{"body": "Safe to merge: no\n\nlens: data-integrity DI-1 · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Safe to merge: no'"} +{"args": [{"body": "Safe to merge: yes"}], "fn": "lens_problem", "out": "starts with 'Safe to merge: yes'"} +{"args": [{"body": "Summary first\n**Lens:** correctness"}], "fn": "lens_problem", "out": "starts with 'Summary first'"} +{"args": [{"body": "Thanks, round 7 checked.\n\nScope: the round diff.\nContext line.\nMore context.\nEven more.\n## Correctness lens (Opus high)\ncovered: proj.py lens_problem\nchecks: 40 shapes\nfinding: major proj.py:1100 x"}], "fn": "lens_problem", "out": "starts with 'Thanks, round 7 checked.'"} +{"args": [{"body": "\n\nlens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with '\\ufefflens: correctness · read at: abc0abc'"} +{"args": [{"body": "_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "```\nlens: concurrency\n```"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "```\nlens: correctness · read at: b0b0b0b\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: 0a60d2aab6a60f0c26846f117d59369047afaeb4\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: 508f89d19d21adc3cd262aff7c427d313d86d428\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: correctness · reviewer: x · read at: d6d662c\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: data-integrity DI-1 · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "```\nlens: design / root cause · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```'"} +{"args": [{"body": "le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: · reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: lens-a (Opus xhigh) · read at: abc0'"} +{"args": [{"body": "lens: · reviewer: lens-a · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: lens-a · read at: abc0abc0abc0abc0a'"} +{"args": [{"body": "lens: · reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: lens-b (Opus xhigh) · read at: b0b0'"} +{"args": [{"body": "lens: · reviewer: lens-b · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: lens-b · read at: b0b0b0b0b0b0b0b0b'"} +{"args": [{"body": "lens: · reviewer: x · read at: b0b0b0b"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: Data-integrity DI-1 · reviewer: a (t1) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: Item and data integrity · reviewer: x"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: · reviewer: a · read at: abc0abc"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: · reviewer: a · read at: abc0abc'"} +{"args": [{"body": "lens: a · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: b · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: c · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: c · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness (pr_queue.py) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness (proj.py) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness (proj.py) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: abc0abc\nfindings: none\ncovered: X.java"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: b0b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none\nlens: design · reviewer: a (t1) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: a (t1) · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: a (t1) · read at: b0b0b0b\nfindings: none\nquoting the old round, read at: abc0abc\nlens design said: fine"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a · read at: 1234567"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: a"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none\n\n---\n\nlens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major t.py:3 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: lens-x (Opus xhigh) · read at:'"} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none\n\nlens: tests · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major t.py:3 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: lens-x (Opus xhigh) · read at:'"} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 1234567\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 174ef306ca6cad085421ddc32c85f24f3df04d7d\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 4336224\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 479578f\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 850e438\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 9e5089f\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: a1a1a1a1a1a1\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nlens: tests · reviewer: x (t) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x (t) · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: e00b0ad\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: e3e2107\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: f511b8f\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at commit b0b0b0b"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 26103a9\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 32bd303\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 4ddc4f7\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\nRe the r7 report (lens: data-integrity DI-2 · read at abc0abc): fixed."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n- lens: tests · reviewer: y · read at (abc0abc)\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n- lens: tests · reviewer: y · read at commit abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n- lens: tests · reviewer: y · read_at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n- lens: tests · reviewer: y · reviewed at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n> lens: tests · reviewer: y · read at (abc0abc)\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n> lens: tests · reviewer: y · read at commit abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n> lens: tests · reviewer: y · read_at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n> lens: tests · reviewer: y · reviewed at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n```\nlens: tests · reviewer: y · read at (abc0abc)\n```\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n```\nlens: tests · reviewer: y · read at commit abc0abc\n```\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n```\nlens: tests · reviewer: y · read_at: abc0abc\n```\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\n```\nlens: tests · reviewer: y · reviewed at: abc0abc\n```\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\nlens: tests · reviewer: y · read at (abc0abc)\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\nlens: tests · reviewer: y · read at commit abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\nlens: tests · reviewer: y · read_at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: b0b0b0b\ncovered: a.py\nfindings: none\n\nRelay of the tests report (it could not post):\n\nlens: tests · reviewer: y · reviewed at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'lens: correctness · reviewer: x · read at: b0b0b0b'"} +{"args": [{"body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: d588959\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: dededededededededededededededededededede"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: a9cc126\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: b00c8cc0dbfdf05db516667eec0cdab343796b14\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: b2b2b2b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness, read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: correctness, read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1 of 2) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1 of 2) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-2 of 2) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity (DI-2) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 479578f\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 6954cd9\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 850e4380baa37266616c13e019733e2dba5776c7\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: a1a1a1afffff\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e00b0adda0ed29bba6af45d1b263405d45db9ddf\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e3e2107\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: f511b8f3e86e\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: b2b2b2b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: y (t) · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 r2 · reviewer: a (t1) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: 6954cd96eca1cd34fc2c9df1c65284687d7aa8c6\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity · reviewer: twin 1 · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity · reviewer: twin 2 · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity — DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity — DI-1 r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity — DI-2 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity reviewer 1 · reviewer: x · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity reviewer 2 · reviewer: x · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity, DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity, DI-1 r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: data-integrity, DI-2 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: design / root cause · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: design · reviewer: a (t1) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: design · reviewer: x · read at: aaaaaaa\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 9a9f350\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 r2 · reviewer: x · read at: a9cc1269ff51a60311faa036b4971f5478e03a35\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 r2 · reviewer: x · read at: b00c8cc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: di-1 re-check · reviewer: a (t1) · read at: b0b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: r4 · reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: r4 · reviewer: lens-a (Opus xhigh) · read at: abc0abc0'"} +{"args": [{"body": "lens: r4 · reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": "its first-line header names no lens (a placeholder, a round or nothing), starts with 'lens: r4 · reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0'"} +{"args": [{"body": "lens: tests · reviewer: a (t1) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: tests · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "lens: x · y"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "looks fine"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: ## Lens design r1\n\nlens: design · reviewer: x · read at: b0b0b0b\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: ## Lens design r1'"} +{"args": [{"body": "not a lens: ## Lens design+tests r1 (Opus high)\n\nlens: design+tests · reviewer: x (Opus high) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nfinding: major a.py:3 x -> y (high)\n"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: ## Lens design+tests r1 (Opus high)'"} +{"args": [{"body": "not a lens: a brief for the next round:\n\n```\nlens: correctness · read at: b0b0b0b\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: a brief for the next round:'"} +{"args": [{"body": "not a lens: a reply\n\n> lens: correctness · read at: b0b0b0b\n> safe to merge: yes"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: a reply'"} +{"args": [{"body": "not a lens: a reply\n\n> the tests lens said: safe to merge: yes"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: \n lens: data-integrity DI-1 r3 · reviewer: b · read at: \n"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n"}], "fn": "lens_problem", "out": "holds a lens header line 2 times (post one comment per lens), starts with 'not a lens: briefs for r3, each lens posts:'"} +{"args": [{"body": "not a lens: relaying a report\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying a report\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at (abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0)\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at commit abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at: https://github.com/owner/proj/commit/abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read at:abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · reviewed at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "lens_problem", "out": "holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report'"} +{"args": [{"body": "not a lens: round 5 fixes (commit b0b0b0b). Each finding, then the fix. Safe to merge after CI."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: round 5 fixes. DI-1 said safe to merge: yes, read at abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: round notes"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: the brief for round 8\n\nReport:\n\n lens: · reviewer: () · read at: \n covered: "}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: the brief for round 8\n\nReport:\n\n> lens: · reviewer: () · read at: \n> covered: "}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: the brief for round 8\n\nReport:\n\n```\nlens: · reviewer: () · read at: \ncovered: \n```"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: the brief\n~~~\nlens: correctness r3 · reviewer: a · read at: \n~~~\n"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "not a lens: x"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: lens x \n read @ abc0abc "}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: lens- x"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: lens- x, read @: abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: read @ abc0abc"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: safe to land"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue turned auto-merge OFF: the head is not the change read @ b0b0b0b0b0b0\nNeeds a lens read of any new commits, then `proj ready 7`."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "pr_queue: required check livelike is red on d4d4d4d4d4d4, so this armed PR waits and the queue passes over it. Fix the cause and push, or if a new lens read or override covers this head: `proj ready 7`."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "lens_problem", "out": "starts with 'reviewer: lens-a (Opus xhigh) · read at: abc0abc0abc0abc0abc'"} +{"args": [{"body": "reviewer: lens-a · read at: abc0abc"}], "fn": "lens_problem", "out": "starts with 'reviewer: lens-a · read at: abc0abc'"} +{"args": [{"body": "reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0\nfindings: none"}], "fn": "lens_problem", "out": "starts with 'reviewer: lens-b (Opus xhigh) · read at: b0b0b0b0b0b0b0b0b0b'"} +{"args": [{"body": "reviewer: lens-b · read at: b0b0b0b"}], "fn": "lens_problem", "out": "starts with 'reviewer: lens-b · read at: b0b0b0b'"} +{"args": [{"body": "proj ready --head 15c063d08f075985867ca73dec3dabb016db6934: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0: arming ..."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge ..."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge for this head although these lenses did not read it: correctness (read abc0abc). Why:\n\n> orchestrator read the diff"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge for this head although these lenses did not read it: correctness (read abc0abc). Why:\n\n> read A..B myself\n> lens- x · read @: b0b0b0b"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready --head bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: arming auto-merge. Why:\n\n> read it"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "proj ready: required check livelike on aaaaaaaaaaaa: failure, and the re-run of job 9 failed: HTTP 403 read @: cccccccccccccccccccccccccccccccccccccccc\nAuto-merge stays on and this PR waits. Fix the cause, or if a new lens read or override covers this head: `proj ready 7`."}], "fn": "lens_problem", "out": null} +{"args": [{"body": "x\nsafe to land: yes. lens- x, read @: abc0abc, read @ b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}], "fn": "lens_problem", "out": null} +{"args": [{"body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"}], "fn": "lens_problem", "out": "starts with '| field | value |'"} +{"args": [{"body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n| verdict | major |"}], "fn": "lens_problem", "out": "starts with '| field | value |'"} +{"args": [{"body": "| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "lens_problem", "out": null} +{"args": ["read at abc0abc"], "fn": "no_lens_text", "out": "read @ abc0abc"} +{"args": ["GitHub does not have the commit read at dededededede (any more), so it was not updated. Merge main into it yourself and `proj push`."], "fn": "no_lens_text", "out": "GitHub does not have the commit read @ dededededede (any more), so it was not updated. Merge main into it yourself and proj push."} +{"args": ["Safe to merge: yes. lens: x, read at: abc0abc, Read At b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"], "fn": "no_lens_text", "out": "safe to land: yes. lens- x, read @: abc0abc, read @ b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"} +{"args": ["[read at](u) abc0abc"], "fn": "no_lens_text", "out": "read @ abc0abc"} +{"args": ["_lens_: x"], "fn": "no_lens_text", "out": "lens- x"} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; no lens comments, so it was not re-armed: which head the review vouches for is unclear."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; no lens comments, so it was not re-armed: which head the review vouches for is unclear."} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; the head 0b3be1cf2a94 could not be shown to be the change read at 0b3be1c."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; the head 0b3be1cf2a94 could not be shown to be the change read @ 0b3be1c."} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; the head 18334b910e93 could not be shown to be the change read at 0b3be1cf2a94."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 0b3be1cf2a94; the head 18334b910e93 could not be shown to be the change read @ 0b3be1cf2a94."} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 15c063d08f07; the head f9425266a46e could not be shown to be the change read at 15c063d08f07."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 15c063d08f07; the head f9425266a46e could not be shown to be the change read @ 15c063d08f07."} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 26103a90a5e1; the head b00c8cc0dbfd could not be shown to be the change read at a9cc1269ff51."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 26103a90a5e1; the head b00c8cc0dbfd could not be shown to be the change read @ a9cc1269ff51."} +{"args": ["a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 26103a90a5e1; the lenses did not all read one head: correctness a9cc1269ff51, di-1 26103a90a5e1, so it was not re-armed: which head the review vouches for is unclear."], "fn": "no_lens_text", "out": "a pr_queue run that was stopped half-way or could not finish turned auto-merge off at 26103a90a5e1; the lenses did not all read one head: correctness a9cc1269ff51, di-1 26103a90a5e1, so it was not re-armed: which head the review vouches for is unclear."} +{"args": ["comment without a first-line lens header (by owner at 2026-11-07T14:20:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d98635'), comment without a first-line lens header (by owner at 2026-11-07T14:21:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d98635')"], "fn": "no_lens_text", "out": "comment without a first-line lens header (by owner at 2026-11-07T14:20:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-1 lens (Opus xhigh), read @: 63509d9863509d9863509d98635'), comment without a first-line lens header (by owner at 2026-11-07T14:21:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read @: 63509d9863509d9863509d98635')"} +{"args": ["correctness (read abc0abc)"], "fn": "no_lens_text", "out": "correctness (read abc0abc)"} +{"args": ["failure again after one re-run (job 10)"], "fn": "no_lens_text", "out": "failure again after one re-run (job 10)"} +{"args": ["failure, and job 9 names no workflow run to re-run"], "fn": "no_lens_text", "out": "failure, and job 9 names no workflow run to re-run"} +{"args": ["failure, and the re-run of job 9 failed: HTTP 403 read at: cccccccccccccccccccccccccccccccccccccccc"], "fn": "no_lens_text", "out": "failure, and the re-run of job 9 failed: HTTP 403 read @: cccccccccccccccccccccccccccccccccccccccc"} +{"args": ["gh pr update-branch failed: HTTP 502, read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3"], "fn": "no_lens_text", "out": "gh pr update-branch failed: HTTP 502, read @: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3"} +{"args": ["le**ns**: x, read at: abc0abc"], "fn": "no_lens_text", "out": "lens- x, read @: abc0abc"} +{"args": ["no finished run to judge after 0 h of watching"], "fn": "no_lens_text", "out": "no finished run to judge after 0 h of watching"} +{"args": ["nothing follows this check, the watcher did not start: no user manager"], "fn": "no_lens_text", "out": "nothing follows this check, the watcher did not start: no user manager"} +{"args": ["orchestrator read the diff"], "fn": "no_lens_text", "out": "orchestrator read the diff"} +{"args": ["read A..B myself\nlens: x · read at: b0b0b0b"], "fn": "no_lens_text", "out": "read A..B myself\nlens- x · read @: b0b0b0b"} +{"args": ["safe to merge"], "fn": "no_lens_text", "out": "safe to land"} +{"args": ["the head is not the change read at b0b0b0b0b0b0"], "fn": "no_lens_text", "out": "the head is not the change read @ b0b0b0b0b0b0"} +{"args": ["the lenses did not all read one head: a aaaaaaaaaaaa, b bbbbbbbbbbbb"], "fn": "no_lens_text", "out": "the lenses did not all read one head: a aaaaaaaaaaaa, b bbbbbbbbbbbb"} +{"args": ["the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs `proj ready 7 --head --why \"...\"`."], "fn": "no_lens_text", "out": "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs proj ready 7 --head --why \"...\"."} +{"args": ["the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs `proj ready 7 --head --why \"...\"`."], "fn": "no_lens_text", "out": "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs proj ready 7 --head --why \"...\"."} +{"args": ["the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-09T01:00:00Z, starts with '## Lens correctness') (no sha: no single commit of this PR)"], "fn": "no_lens_text", "out": "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-09T01:00:00Z, starts with '## Lens correctness') (no sha: no single commit of this PR)"} +{"args": ["the lenses did not all read one head: comment without a first-line lens header (by owner at t, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs `proj ready 7 --head --why \"...\"`."], "fn": "no_lens_text", "out": "the lenses did not all read one head: comment without a first-line lens header (by owner at t, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '') (no sha: no single commit of this PR), so it was not updated: which head the review vouched for is unclear. A comment that looks like a lens report counts only with the skill proj-review section 4 header as its first plain line (not in a code block): re-post it that way, or an orchestrator who read the head runs proj ready 7 --head --why \"...\"."} +{"args": ["the lenses did not all read one head: correctness d5889596ac70, di-1 (9a9f350: no single commit of this PR), so it was not updated: which head the review vouched for is unclear."], "fn": "no_lens_text", "out": "the lenses did not all read one head: correctness d5889596ac70, di-1 (9a9f350: no single commit of this PR), so it was not updated: which head the review vouched for is unclear."} +{"args": ["the new head 12f03bfe8853 is not exactly the change read at 5a87817c48c5 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head 12f03bfe8853 is not exactly the change read @ 5a87817c48c5 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head 5fd5b641efb0 is not exactly the change read at d5889596ac70 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head 5fd5b641efb0 is not exactly the change read @ d5889596ac70 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head 7190dec5f5c6 is not exactly the change read at e3e2107c7baf merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head 7190dec5f5c6 is not exactly the change read @ e3e2107c7baf merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head ce7f21bb89eb is not exactly the change read at 5a87817c48c5 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head ce7f21bb89eb is not exactly the change read @ 5a87817c48c5 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head d7d0902ecc1c is not exactly the change read at a0ca1aa88bf3 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head d7d0902ecc1c is not exactly the change read @ a0ca1aa88bf3 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head daecc1f16a35 is not exactly the change read at 9e5089f32d20 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head daecc1f16a35 is not exactly the change read @ 9e5089f32d20 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the new head f3c1108692f2 is not exactly the change read at 479578f8de13 merged with main (a push after the lenses, or a conflict resolution?)."], "fn": "no_lens_text", "out": "the new head f3c1108692f2 is not exactly the change read @ 479578f8de13 merged with main (a push after the lenses, or a conflict resolution?)."} +{"args": ["the r1 comments are the old format; r4 read B"], "fn": "no_lens_text", "out": "the r1 comments are the old format; r4 read B"} +{"args": ["turning auto-merge back on for b19ac09cf490 failed: HTTP 502, read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3"], "fn": "no_lens_text", "out": "turning auto-merge back on for b19ac09cf490 failed: HTTP 502, read @: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3"} +{"args": ["x"], "fn": "no_lens_text", "out": "x"} +{"args": ["| lens | x |\n| read at | abc0abc |"], "fn": "no_lens_text", "out": " lens x \n read @ abc0abc "} +{"args": [{"authorAssociation": "COLLABORATOR", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "CONTRIBUTOR", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "MEMBER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "NONE", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "## Lens correctness\nsafe to merge: yes", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: a · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: b · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: c · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: c · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "includesCreatedEdit": true}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "includesCreatedEdit": true}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "lens: design · reviewer: x · read at: aaaaaaa\nfindings: none", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head 15c063d08f075985867ca73dec3dabb016db6934: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "includesCreatedEdit": false}], "fn": "override_sha", "out": "15c063d08f075985867ca73dec3dabb016db6934"} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": true}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it"}], "fn": "override_sha", "out": null} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0: arming ...", "includesCreatedEdit": false}], "fn": "override_sha", "out": "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge ...", "includesCreatedEdit": false}], "fn": "override_sha", "out": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "includesCreatedEdit": false}], "fn": "override_sha", "out": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"} +{"args": [{"authorAssociation": "OWNER", "body": "proj ready --head bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"} +{"args": [{"body": "## Lens correctness (Opus xhigh)\nsafe to merge: yes"}], "fn": "override_sha", "out": null} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: 491f7ed919af9c405b9fb73c6a0fdd368b86c6ee\nchecks: ...\nfinding: major ..."}], "fn": "override_sha", "out": null} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ..."}], "fn": "override_sha", "out": null} +{"args": [{"body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "**Approach (correctness lens, own view first, then the PR body):** I agree with the approach.\n\n```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: correctness · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "> proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-1 · reviewer: lens-542-di-1 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-2 · reviewer: lens-542-di-2 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n | field | value |\n |---|---|\n | lens | correctness |\n | read at | abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> | field | value |\n> |---|---|\n> | lens | correctness |\n> | read at | abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Report:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "Safe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: 0a60d2aab6a60f0c26846f117d59369047afaeb4\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: 508f89d19d21adc3cd262aff7c427d313d86d428\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "```\nlens: correctness · reviewer: x · read at: d6d662c\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 174ef306ca6cad085421ddc32c85f24f3df04d7d\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 4336224\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 479578f\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 850e438\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: 9e5089f\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: a1a1a1a1a1a1\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: e00b0ad\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: e3e2107\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x (t) · read at: f511b8f\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 26103a9\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 32bd303\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: 4ddc4f7\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: d588959\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness · reviewer: x · read at: dededededededededededededededededededede"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: a9cc126\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: b00c8cc0dbfdf05db516667eec0cdab343796b14\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: b2b2b2b\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: correctness r2 · reviewer: x · read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity (DI-1) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity (DI-2) · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 479578f\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 6954cd9\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 850e4380baa37266616c13e019733e2dba5776c7\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: a1a1a1afffff\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e00b0adda0ed29bba6af45d1b263405d45db9ddf\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e3e2107\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: f511b8f3e86e\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 · reviewer: x · read at: b2b2b2b\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-1 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: 6954cd96eca1cd34fc2c9df1c65284687d7aa8c6\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: data-integrity DI-2 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: 9a9f350\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 r2 · reviewer: x · read at: a9cc1269ff51a60311faa036b4971f5478e03a35\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "lens: di-1 r2 · reviewer: x · read at: b00c8cc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: \n lens: data-integrity DI-1 r3 · reviewer: b · read at: \n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nReport:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying a report\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x"}], "fn": "override_sha", "out": null} +{"args": [{"body": "not a lens: the brief\n~~~\nlens: correctness r3 · reviewer: a · read at: \n~~~\n"}], "fn": "override_sha", "out": null} +{"args": [{"body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "includesCreatedEdit": false}], "fn": "override_sha", "out": null} +{"args": [{"body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n| verdict | major |"}], "fn": "override_sha", "out": null} +{"args": [{"body": "| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |"}], "fn": "override_sha", "out": null} +{"args": [{"comments": [], "commits": [], "headRefOid": "631bd6367177c4ce47dc22326edb6f5ed97d27e2", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "04aa3de2d2b9b5aa35ea284ee0731d17c05607d4"}], "headRefOid": "04aa3de2d2b9b5aa35ea284ee0731d17c05607d4", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "0b3be1cf2a94c0cbb28536919bebb4fbaf0e6c99"}, {"oid": "18334b910e9349d67113f604898e4df644cced1c"}], "headRefOid": "18334b910e9349d67113f604898e4df644cced1c", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "0b3be1cf2a94c0cbb28536919bebb4fbaf0e6c99"}], "headRefOid": "0b3be1cf2a94c0cbb28536919bebb4fbaf0e6c99", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "15c063d08f075985867ca73dec3dabb016db6934"}, {"oid": "f9425266a46ea5aac4415a45a333583810c57597"}], "headRefOid": "f9425266a46ea5aac4415a45a333583810c57597", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "20bdc4e8c41d3a33a497b9c610d977c8acf2eeee"}], "headRefOid": "20bdc4e8c41d3a33a497b9c610d977c8acf2eeee", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "4dae538b4b17219f0a379fd4862d9959f8267308"}, {"oid": "7c20ddb7649128b316da6372bec8390087df348a"}], "headRefOid": "7c20ddb7649128b316da6372bec8390087df348a", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "4dae538b4b17219f0a379fd4862d9959f8267308"}], "headRefOid": "4dae538b4b17219f0a379fd4862d9959f8267308", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d"}], "headRefOid": "4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "577736c2b70df90602f38b735649cb6fde5583df"}], "headRefOid": "577736c2b70df90602f38b735649cb6fde5583df", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "5a87817c48c51f2d1760a5cb1aa620a67a67a5d2"}], "headRefOid": "5a87817c48c51f2d1760a5cb1aa620a67a67a5d2", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "631bd6367177c4ce47dc22326edb6f5ed97d27e2"}], "headRefOid": "631bd6367177c4ce47dc22326edb6f5ed97d27e2", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "738cf7750874272d8c8ce71a7d311dfa76913b3f"}, {"oid": "b19ac09cf4902b00b3128fb3ece5b8158190d033"}], "headRefOid": "b19ac09cf4902b00b3128fb3ece5b8158190d033", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "738cf7750874272d8c8ce71a7d311dfa76913b3f"}], "headRefOid": "738cf7750874272d8c8ce71a7d311dfa76913b3f", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "815cae9d3a82ff4f47a32c21805717cf80d06327"}, {"oid": "d5fbb9e85b88cf466cfc2864f2136e0f7a2e59f8"}], "headRefOid": "d5fbb9e85b88cf466cfc2864f2136e0f7a2e59f8", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "815cae9d3a82ff4f47a32c21805717cf80d06327"}], "headRefOid": "815cae9d3a82ff4f47a32c21805717cf80d06327", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "999e866518f8a9f1cffc2bd66792b7fba40d1814"}, {"oid": "5188bfdcef69fc396e559e259e0c8569ccb03394"}], "headRefOid": "5188bfdcef69fc396e559e259e0c8569ccb03394", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "a0ca1aa88bf3fc0b87a22388448403363e3a4f0c"}], "headRefOid": "a0ca1aa88bf3fc0b87a22388448403363e3a4f0c", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "cf6641204a1e047be19565e42385f04b4e36032e"}], "headRefOid": "cf6641204a1e047be19565e42385f04b4e36032e", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "d2015583d2f74125cfff55613ac1d43137c50c39"}, {"oid": "75440a811e644309583891e3efac4076d049f931"}], "headRefOid": "75440a811e644309583891e3efac4076d049f931", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "d2015583d2f74125cfff55613ac1d43137c50c39"}], "headRefOid": "d2015583d2f74125cfff55613ac1d43137c50c39", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "d5889596ac7010dc5ca54d578f6733eb7d38081f"}], "headRefOid": "d5889596ac7010dc5ca54d578f6733eb7d38081f", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "d6d662cf35e5669a73b2e181c8c62fa601527e11"}], "headRefOid": "d6d662cf35e5669a73b2e181c8c62fa601527e11", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [], "commits": [{"oid": "dffadb4e27cb7341d2b0053364297c8782fb1cb0"}, {"oid": "8632e9e6d121792974ef55296475cb4fb811d20b"}], "headRefOid": "8632e9e6d121792974ef55296475cb4fb811d20b", "reviews": []}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "## Lens correctness\nsafe to merge: yes", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-09T01:00:00Z, starts with '## Lens correctness') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: a · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: b · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: a aaaaaaaaaaaa, b bbbbbbbbbbbb"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: c · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: c · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "1ecec59981f24ba3edc79144fd4f32dd1c7d9f78"}, {"oid": "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c"}], "headRefOid": "1ecec59981f24ba3edc79144fd4f32dd1c7d9f78", "reviews": []}], "fn": "reviewed_head", "out": [true, "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "34fe7e14edfdbb17b12b3d28b27faa16629756cd"}, {"oid": "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c"}], "headRefOid": "34fe7e14edfdbb17b12b3d28b27faa16629756cd", "reviews": []}], "fn": "reviewed_head", "out": [true, "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: 1a2b1edf27e29c496a665ebb1a3c7c815967ee9c\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "ed5643c567a29f8c04ba170474e843ff844be60e"}, {"oid": "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c"}], "headRefOid": "ed5643c567a29f8c04ba170474e843ff844be60e", "reviews": []}], "fn": "reviewed_head", "out": [true, "1a2b1edf27e29c496a665ebb1a3c7c815967ee9c", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: design · reviewer: x · read at: aaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": true}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "coderabbitai"}, "authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "github-actions[bot]"}, "authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "COLLABORATOR", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "CONTRIBUTOR", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "MEMBER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "NONE", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": true}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z"}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "body": "proj ready --head aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: arming auto-merge. Why:\n\n> read it", "createdAt": "2026-11-09T02:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": true}], "commits": [{"oid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"oid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}], "headRefOid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "1f074d6d8b63823b2fc4545de5f6db86b08c00b4"}, {"oid": "fca2958366443b7664d2c47b4995e562b7d7aeee"}], "headRefOid": "1f074d6d8b63823b2fc4545de5f6db86b08c00b4", "reviews": []}], "fn": "reviewed_head", "out": [true, "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "1f074d6d8b63823b2fc4545de5f6db86b08c00b4"}, {"oid": "fca2958366443b7664d2c47b4995e562b7d7aeee"}], "headRefOid": "1f074d6d8b63823b2fc4545de5f6db86b08c00b4", "reviews": []}], "fn": "reviewed_head", "out": [true, "fca2958366443b7664d2c47b4995e562b7d7aeee", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "adfa55d4605b0eac86f80105eb95e0a87e69c59b"}, {"oid": "fca2958366443b7664d2c47b4995e562b7d7aeee"}], "headRefOid": "adfa55d4605b0eac86f80105eb95e0a87e69c59b", "reviews": []}], "fn": "reviewed_head", "out": [true, "fca2958366443b7664d2c47b4995e562b7d7aeee", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "lens: correctness · reviewer: x · read at: fca2958366443b7664d2c47b4995e562b7d7aeee\nfindings: none", "createdAt": "2026-11-09T01:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "e3a70dba4d1c832f743ce8697b2e30416b1fc12b"}, {"oid": "fca2958366443b7664d2c47b4995e562b7d7aeee"}], "headRefOid": "e3a70dba4d1c832f743ce8697b2e30416b1fc12b", "reviews": []}], "fn": "reviewed_head", "out": [true, "fca2958366443b7664d2c47b4995e562b7d7aeee", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "t", "includesCreatedEdit": false}]}], "fn": "reviewed_head", "out": [false, null, "no lens comments"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: 491f7ed919af9c405b9fb73c6a0fdd368b86c6ee\nchecks: ...\nfinding: major ...", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "491f7ed919af9c405b9fb73c6a0fdd368b86c6ee"}, {"oid": "3e3b60c14fb1fb2c77d7c841138196d2402ed024"}], "headRefOid": "3e3b60c14fb1fb2c77d7c841138196d2402ed024", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: Claude Opus 5.5 xhigh (lens sub-agent) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nchecks: ...\nfinding: major ...", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '## Lens correctness r1 (Opus xhigh)') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "**Approach (correctness lens, own view first, then the PR body):** I agree with the approach.\n\n```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (correctness lens, own view first, then the PR bo') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "**Approach (design lens, own view first, then MIGRATIONS.md):** I agree with the runner.\n\n```\nlens: correctness · reviewer: review sub-agent (T3) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py\nchecks: traced the rerun\nfinding: major a.py:10 rerun -> applied twice (high)\n```\n", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Approach (design lens, own view first, then MIGRATIONS.md)') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '**Safe to merge: yes** (security lens: no blocker)') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-1 · reviewer: lens-542-di-1 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n", "createdAt": "2026-11-07T14:20:00Z"}, {"author": {"login": "owner"}, "body": "DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-2 · reviewer: lens-542-di-2 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n", "createdAt": "2026-11-07T14:21:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none", "createdAt": "2026-11-07T17:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-2 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none", "createdAt": "2026-11-07T17:01:00Z"}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0: arming auto-merge ...", "createdAt": "2026-11-07T18:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-1 · reviewer: lens-542-di-1 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n", "createdAt": "2026-11-07T14:20:00Z"}, {"author": {"login": "owner"}, "body": "DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d9863509d9863509d98\n\nlens: data-integrity DI-2 · reviewer: lens-542-di-2 (Opus xhigh) · read at: 63509d9863509d9863509d9863509d9863509d98\n", "createdAt": "2026-11-07T14:21:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none", "createdAt": "2026-11-07T17:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-2 r4 · reviewer: x (t) · read at: b0b0b0b\nfindings: none", "createdAt": "2026-11-07T17:01:00Z"}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T14:20:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-1 lens (Opus xhigh), read at: 63509d9863509d9863509d98635') (no sha: no single commit of this PR), comment without a first-line lens header (by owner at 2026-11-07T14:21:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'DI-2 lens (Opus xhigh), read at: 63509d9863509d9863509d98635') (no sha: no single commit of this PR), data-integrity di-1 b0b0b0b0b0b0, data-integrity di-2 b0b0b0b0b0b0"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report: lens: correctness · reviewer: lens-x (Opus xhigh) · ') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report: lens: correctness · reviewer: lens-x (Opus xhigh) · ') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n | field | value |\n |---|---|\n | lens | correctness |\n | read at | abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> | field | value |\n> |---|---|\n> | lens | correctness |\n> | read at | abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Report:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Report:') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "Safe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'Safe to merge: no') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: 0a60d2aab6a60f0c26846f117d59369047afaeb4\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "0a60d2aab6a60f0c26846f117d59369047afaeb4"}, {"oid": "69c698e0b95c60871f2eb654a62df4b9bb953c48"}], "headRefOid": "69c698e0b95c60871f2eb654a62df4b9bb953c48", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "```\nlens: correctness · reviewer: claude-opus-5-5 (read-only) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all)\nchecks:\n- the state question\nfinding: minor (tests) a.py:3 fixed sleep (medium)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: 508f89d19d21adc3cd262aff7c427d313d86d428\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "508f89d19d21adc3cd262aff7c427d313d86d428"}, {"oid": "19b0450d5c7de63ab48ebbeaa9529489429023e3"}], "headRefOid": "19b0450d5c7de63ab48ebbeaa9529489429023e3", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "```\nlens: correctness · reviewer: review sub-agent (T3, for orchestrator 6287c5f8) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\ncovered: a.py (all), b.py (all)\nchecks: traced the rerun and the half-applied case\nfinding: major a.py:10 empty history -> data change applied twice (high)\n```\n", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "```\nlens: correctness · reviewer: x · read at: d6d662c\n```", "createdAt": "t"}], "commits": [{"oid": "d6d662cf35e5669a73b2e181c8c62fa601527e11"}], "headRefOid": "d6d662cf35e5669a73b2e181c8c62fa601527e11", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at t, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with '```') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 174ef306ca6cad085421ddc32c85f24f3df04d7d\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "174ef306ca6cad085421ddc32c85f24f3df04d7d"}, {"oid": "55432a376184b53dfec9c9d3eb7b60136e728766"}], "headRefOid": "55432a376184b53dfec9c9d3eb7b60136e728766", "reviews": []}], "fn": "reviewed_head", "out": [true, "174ef306ca6cad085421ddc32c85f24f3df04d7d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 174ef306ca6cad085421ddc32c85f24f3df04d7d\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "174ef306ca6cad085421ddc32c85f24f3df04d7d"}], "headRefOid": "174ef306ca6cad085421ddc32c85f24f3df04d7d", "reviews": []}], "fn": "reviewed_head", "out": [true, "174ef306ca6cad085421ddc32c85f24f3df04d7d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 4336224\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "43362242a605946a6902f7757e66ca425c003d0a"}], "headRefOid": "43362242a605946a6902f7757e66ca425c003d0a", "reviews": []}], "fn": "reviewed_head", "out": [true, "43362242a605946a6902f7757e66ca425c003d0a", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 850e438\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 850e4380baa37266616c13e019733e2dba5776c7\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "850e4380baa37266616c13e019733e2dba5776c7"}, {"oid": "b17b29c94b502ec73241348b87d012d816c07aa3"}], "headRefOid": "b17b29c94b502ec73241348b87d012d816c07aa3", "reviews": []}], "fn": "reviewed_head", "out": [true, "850e4380baa37266616c13e019733e2dba5776c7", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 850e438\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 850e4380baa37266616c13e019733e2dba5776c7\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "850e4380baa37266616c13e019733e2dba5776c7"}], "headRefOid": "850e4380baa37266616c13e019733e2dba5776c7", "reviews": []}], "fn": "reviewed_head", "out": [true, "850e4380baa37266616c13e019733e2dba5776c7", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 9e5089f\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "9e5089f32d20d4c3d1d47442f74942bfc98e49b5"}], "headRefOid": "9e5089f32d20d4c3d1d47442f74942bfc98e49b5", "reviews": []}], "fn": "reviewed_head", "out": [true, "9e5089f32d20d4c3d1d47442f74942bfc98e49b5", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: a1a1a1a1a1a1\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: a1a1a1afffff\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "a1a1a1afffffffffffffffffffffffffffffffff"}], "headRefOid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness a1a1a1a1a1a1, data-integrity di-1 a1a1a1afffff"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "bbd7144382c36a1194a24c6d22234a5956385f0d"}, {"oid": "353d33fc69714011d4b8759bc95bcad7b505160b"}], "headRefOid": "353d33fc69714011d4b8759bc95bcad7b505160b", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbd7144382c36a1194a24c6d22234a5956385f0d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "bbd7144382c36a1194a24c6d22234a5956385f0d"}, {"oid": "77251d7c4ae7f1bb71834a3e8fbb2be4c8a4c121"}], "headRefOid": "77251d7c4ae7f1bb71834a3e8fbb2be4c8a4c121", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbd7144382c36a1194a24c6d22234a5956385f0d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: bbd7144\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: bbd7144382c36a1194a24c6d22234a5956385f0d\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "bbd7144382c36a1194a24c6d22234a5956385f0d"}], "headRefOid": "bbd7144382c36a1194a24c6d22234a5956385f0d", "reviews": []}], "fn": "reviewed_head", "out": [true, "bbd7144382c36a1194a24c6d22234a5956385f0d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t2"}, {"author": {"login": "owner"}, "body": "Briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n", "createdAt": "t3"}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}, {"oid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "headRefOid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at t3, holds a lens header line 2 times (post one comment per lens), starts with 'Briefs for r3, each lens posts:') (no sha: no single commit of this PR), correctness d4d4d4d4d4d4, data-integrity di-1 d4d4d4d4d4d4"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t2"}, {"author": {"login": "owner"}, "body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: \n lens: data-integrity DI-1 r3 · reviewer: b · read at: \n", "createdAt": "t3"}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}, {"oid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "headRefOid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "fn": "reviewed_head", "out": [true, "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t2"}, {"author": {"login": "owner"}, "body": "not a lens: briefs for r3, each lens posts:\n\n lens: correctness r3 · reviewer: a · read at: b0b0b0b\n lens: data-integrity DI-1 r3 · reviewer: b · read at: b0b0b0b\n", "createdAt": "t3"}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}, {"oid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "headRefOid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at t3, holds a lens header line 2 times (post one comment per lens), starts with 'not a lens: briefs for r3, each lens posts:') (no sha: no single commit of this PR), correctness d4d4d4d4d4d4, data-integrity di-1 d4d4d4d4d4d4"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: d4d4d4d\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "not a lens: the brief\n~~~\nlens: correctness r3 · reviewer: a · read at: \n~~~\n", "createdAt": "t3"}], "commits": [{"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}, {"oid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "headRefOid": "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4"}], "fn": "reviewed_head", "out": [true, "d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: e00b0ad\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e00b0adda0ed29bba6af45d1b263405d45db9ddf\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "e00b0adda0ed29bba6af45d1b263405d45db9ddf"}], "headRefOid": "e00b0adda0ed29bba6af45d1b263405d45db9ddf", "reviews": []}], "fn": "reviewed_head", "out": [true, "e00b0adda0ed29bba6af45d1b263405d45db9ddf", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: e3e2107\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: e3e2107\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "e3e2107c7bafe8c548445e0fd4df8f7312b13d9c"}, {"oid": "2b2ac12a390686a83e101378c8d705f37112d7be"}], "headRefOid": "2b2ac12a390686a83e101378c8d705f37112d7be", "reviews": []}], "fn": "reviewed_head", "out": [true, "e3e2107c7bafe8c548445e0fd4df8f7312b13d9c", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: e3e2107\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "e3e2107c7bafe8c548445e0fd4df8f7312b13d9c"}], "headRefOid": "e3e2107c7bafe8c548445e0fd4df8f7312b13d9c", "reviews": []}], "fn": "reviewed_head", "out": [true, "e3e2107c7bafe8c548445e0fd4df8f7312b13d9c", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: f511b8f\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: f511b8f3e86e\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "f511b8f3e86ee7aa0c6ced82c4d1d07ec43d6d28"}], "headRefOid": "f511b8f3e86ee7aa0c6ced82c4d1d07ec43d6d28", "reviews": []}], "fn": "reviewed_head", "out": [true, "f511b8f3e86ee7aa0c6ced82c4d1d07ec43d6d28", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: 26103a9\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "body": "lens: correctness r2 · reviewer: x · read at: a9cc126\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 r2 · reviewer: x · read at: a9cc1269ff51a60311faa036b4971f5478e03a35\nfindings: none", "createdAt": "2026-11-07T12:00:01Z"}], "commits": [{"oid": "a9cc1269ff51a60311faa036b4971f5478e03a35"}, {"oid": "26103a90a5e13f5abecba90fcd6020e98c4a1998"}, {"oid": "b00c8cc0dbfdf05db516667eec0cdab343796b14"}], "headRefOid": "b00c8cc0dbfdf05db516667eec0cdab343796b14", "reviews": []}], "fn": "reviewed_head", "out": [true, "a9cc1269ff51a60311faa036b4971f5478e03a35", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: 26103a9\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "body": "lens: correctness r2 · reviewer: x · read at: a9cc126\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}], "commits": [{"oid": "a9cc1269ff51a60311faa036b4971f5478e03a35"}, {"oid": "26103a90a5e13f5abecba90fcd6020e98c4a1998"}, {"oid": "b00c8cc0dbfdf05db516667eec0cdab343796b14"}], "headRefOid": "b00c8cc0dbfdf05db516667eec0cdab343796b14", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness a9cc1269ff51, di-1 26103a90a5e1"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: 26103a9\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: 26103a90a5e13f5abecba90fcd6020e98c4a1998\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "body": "lens: correctness r2 · reviewer: x · read at: b00c8cc0dbfdf05db516667eec0cdab343796b14\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 r2 · reviewer: x · read at: b00c8cc\nfindings: none", "createdAt": "2026-11-07T12:00:01Z"}], "commits": [{"oid": "a9cc1269ff51a60311faa036b4971f5478e03a35"}, {"oid": "26103a90a5e13f5abecba90fcd6020e98c4a1998"}, {"oid": "b00c8cc0dbfdf05db516667eec0cdab343796b14"}], "headRefOid": "b00c8cc0dbfdf05db516667eec0cdab343796b14", "reviews": []}], "fn": "reviewed_head", "out": [true, "b00c8cc0dbfdf05db516667eec0cdab343796b14", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: 32bd303\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head 15c063d08f075985867ca73dec3dabb016db6934: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "15c063d08f075985867ca73dec3dabb016db6934"}], "headRefOid": "15c063d08f075985867ca73dec3dabb016db6934", "reviews": []}], "fn": "reviewed_head", "out": [true, "15c063d08f075985867ca73dec3dabb016db6934", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: 4ddc4f7\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: 4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d\nfindings: none", "createdAt": "t2"}], "commits": [{"oid": "4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d"}, {"oid": "f8f5a20526ad2da7006ff0fedd156d53152bca41"}], "headRefOid": "f8f5a20526ad2da7006ff0fedd156d53152bca41", "reviews": []}], "fn": "reviewed_head", "out": [true, "4ddc4f7a98a05c3c7aaf0d78ee870ea82c76430d", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "coderabbitai"}, "authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}], "headRefOid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}], "fn": "reviewed_head", "out": [true, "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "> proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z"}], "headRefOid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}], "fn": "reviewed_head", "out": [true, "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "body": "lens: correctness r2 · reviewer: x · read at: b2b2b2b\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}, {"author": {"login": "owner"}, "body": "lens: correctness r2 · reviewer: x · read at: c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness c3c3c3c3c3c3, di-1 b2b2b2b2b2b2"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "2026-11-07T10:00:01Z"}, {"author": {"login": "owner"}, "authorAssociation": "OWNER", "body": "proj ready --head b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2: arming auto-merge for this head although these lenses did not read it: x. Why:\n\n> read it myself", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1\nfindings: none", "createdAt": "t2"}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x · read at: a1a1a1a1a\nfindings: none", "createdAt": "t2"}], "headRefOid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}], "fn": "reviewed_head", "out": [true, "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x · read at: b2b2b2b\nfindings: none", "createdAt": "t2"}], "commits": [{"oid": "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"}, {"oid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness a1a1a1a1a1a1, data-integrity di-1 b2b2b2b2b2b2"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: a1a1a1a\nfindings: none", "createdAt": "t1"}], "headRefOid": "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2"}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (a1a1a1a: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: d588959\nfindings: none", "createdAt": "t1"}, {"author": {"login": "owner"}, "body": "lens: di-1 · reviewer: x · read at: 9a9f350\nfindings: none", "createdAt": "t2"}], "commits": [{"oid": "d5889596ac7010dc5ca54d578f6733eb7d38081f"}], "headRefOid": "d5889596ac7010dc5ca54d578f6733eb7d38081f", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness d5889596ac70, di-1 (9a9f350: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x · read at: dededededededededededededededededededede", "createdAt": "t"}], "commits": [{"oid": "631bd6367177c4ce47dc22326edb6f5ed97d27e2"}], "headRefOid": "631bd6367177c4ce47dc22326edb6f5ed97d27e2", "reviews": []}], "fn": "reviewed_head", "out": [true, "dededededededededededededededededededede", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: data-integrity (DI-1) · reviewer: x (t) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity (DI-2) · reviewer: x (t) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity (DI-1) r2 · reviewer: x (t) · read at: b0b0b0b\nfindings: none", "createdAt": "2026-11-07T12:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: data-integrity (di-1) b0b0b0b0b0b0, data-integrity (di-2) (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 479578f\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: correctness · reviewer: x (t) · read at: 479578f\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "479578f8de13f52c47003cd1f6fde3fad20a7ad9"}, {"oid": "a7cada89d12a8d178b1453f97cef1ff9f46a00aa"}], "headRefOid": "a7cada89d12a8d178b1453f97cef1ff9f46a00aa", "reviews": []}], "fn": "reviewed_head", "out": [true, "479578f8de13f52c47003cd1f6fde3fad20a7ad9", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: 6954cd9\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: 6954cd96eca1cd34fc2c9df1c65284687d7aa8c6\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "commits": [{"oid": "6954cd96eca1cd34fc2c9df1c65284687d7aa8c6"}], "headRefOid": "6954cd96eca1cd34fc2c9df1c65284687d7aa8c6", "reviews": []}], "fn": "reviewed_head", "out": [true, "6954cd96eca1cd34fc2c9df1c65284687d7aa8c6", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "lens: data-integrity DI-1 · reviewer: x (t) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}, {"author": {"login": "owner"}, "body": "lens: data-integrity DI-2 · reviewer: x (t) · read at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0", "reviews": []}], "fn": "reviewed_head", "out": [true, "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0", "every lens read it"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n ## Lens correctness r1 (Opus xhigh)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n **Safe to merge: yes** (security lens: no blocker)\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n - finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n 2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n Safe to merge: no\n \n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n covered: a.py\n findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> ## Lens correctness r1 (Opus xhigh)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> * lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> **Safe to merge: yes** (security lens: no blocker)\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> + lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> - [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> - lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> - finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> 1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> 1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> 2. finding: major a.py:1", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> Report: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> Safe to merge: no\n> \n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> finding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> • lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> _lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> le**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n> covered: a.py\n> findings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n> | lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n## Lens correctness r1 (Opus xhigh)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n* lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n**Safe to merge: yes** (security lens: no blocker)\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n+ lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n- [x] lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n- lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n- finding: major a.py:1 x\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n1) lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n1. lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n2. finding: major a.py:1\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nReport: lens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line (a lens line with a sha not written `read at: `), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n```\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |\n```", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nReport:\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nSafe to merge: no\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\nfinding: major a.py:1 x", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n• lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n_lens_: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nle**ns**: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · **read at:** abc0abc\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at (abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at commit abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: **abc0abc**", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: [abc0abc](https://x/commit/abc0abc)", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: `abc0abc`", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc\ncovered: a.py\nfindings: none", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at: https://github.com/owner/proj/commit/abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read at:abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read-at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · read_at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\nlens: correctness · reviewer: lens-x (Opus xhigh) · reviewed at: abc0abc", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying a report\n\n| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying a report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "not a lens: relaying the DI-2 report\n\nlens: data-integrity DI-2 · reviewer: x · read_at: abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0\nfinding: major a.py:1 x", "createdAt": "2026-11-07T11:00:00Z"}], "commits": [{"oid": "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0"}, {"oid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T11:00:00Z, holds a lens header line that is not its first plain line (a later line, a code block, quote or table), starts with 'not a lens: relaying the DI-2 report') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with '| field | value |') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "| field | value |\n|---|---|\n| lens | correctness |\n| read at | abc0abc |\n| verdict | major |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by owner at 2026-11-07T10:00:00Z, starts with '| field | value |') (no sha: no single commit of this PR)"]} +{"args": [{"comments": [{"author": {"login": "owner"}, "body": "| lens: correctness · reviewer: lens-x (Opus xhigh) · read at: abc0abc |", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: correctness (abc0abc: no single commit of this PR)"]} +{"args": [{"comments": [{"body": "## Lens correctness (Opus xhigh)\nsafe to merge: yes", "createdAt": "2026-11-07T10:00:00Z"}, {"authorAssociation": "OWNER", "body": "proj ready --head abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0: arming ...", "createdAt": "2026-11-07T11:00:00Z", "includesCreatedEdit": false}], "headRefOid": "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0", "reviews": []}], "fn": "reviewed_head", "out": [true, "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0", "every lens read it"]} +{"args": [{"comments": [{"body": "## Lens correctness (Opus xhigh)\nsafe to merge: yes", "createdAt": "2026-11-07T10:00:00Z"}], "headRefOid": "abc0abc0abc0abc0abc0abc0abc0abc0abc0abc0", "reviews": []}], "fn": "reviewed_head", "out": [true, null, "the lenses did not all read one head: comment without a first-line lens header (by ? at 2026-11-07T10:00:00Z, starts with '## Lens correctness (Opus xhigh)') (no sha: no single commit of this PR)"]}