@olegkoval/agent-skills 1.54.3 → 1.55.0

package/plugins/olko-github-pr/skills/lekker-review/scripts/mine-bot-comments.sh

@@ -0,0 +1,280 @@
+#!/usr/bin/env bash
+# Mine real Greptile / Gemini review comments from a repo's newest PR review comments
+# and cluster them into the patterns worth pre-empting.
+#
+# Why this exists: predicting bot-reviewer comments from a model's intuition is
+# guesswork. The bots have already told us what they comment on - dozens of
+# times, in this exact repo, on this exact codebase. Mining that is free and it
+# is evidence, not a guess.
+#
+# Usage:
+#   mine-bot-comments.sh <repo-slug> [out-md] [--limit N]
+#
+#   repo-slug   e.g. acme/web-app
+#   out-md      default: $LEKKER_DATA_DIR/bot-patterns.md, where LEKKER_DATA_DIR
+#               defaults to ~/.cache/lekker-review (outside the skill dir, so a
+#               plugin update does not wipe the mined history)
+#   --limit N   max review comments to fetch, newest first (default 400);
+#               paging stops there, so a long history is never pulled whole
+#
+# Writes/replaces a "## <repo-slug>" section in out-md, leaving other repos'
+# sections alone, and prints a one-line summary. The section carries a
+# "<!-- mined: YYYY-MM-DD -->" marker that SKILL.md reads to decide staleness;
+# a repo with no bot comments still gets a section, so it is not re-mined on
+# every run.
+
+set -uo pipefail
+
+REPO_SLUG="${1:-}"
+if [[ -z "$REPO_SLUG" ]]; then
+    echo "usage: mine-bot-comments.sh <repo-slug> [out-md] [--limit N]" >&2
+    exit 2
+fi
+shift
+
+DATA_DIR="${LEKKER_DATA_DIR:-$HOME/.cache/lekker-review}"
+OUT_MD="$DATA_DIR/bot-patterns.md"
+LIMIT=400
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --limit) LIMIT="${2:-}"; shift; [[ $# -gt 0 ]] && shift ;;
+        *)       OUT_MD="$1"; shift ;;
+    esac
+done
+
+if ! [[ "$LIMIT" =~ ^[1-9][0-9]*$ ]]; then
+    echo "mine-bot-comments: --limit needs a positive integer, got '$LIMIT'" >&2
+    exit 2
+fi
+
+mkdir -p "$(dirname "$OUT_MD")"
+
+python3 - "$REPO_SLUG" "$OUT_MD" "$LIMIT" <<'PYEOF'
+import datetime, json, os, re, subprocess, sys
+from collections import defaultdict
+
+repo_slug, out_md, limit = sys.argv[1:4]
+limit = int(limit)
+
+# Review comments are the inline ones - the class the bots actually bill for.
+# Page by hand rather than `gh api --paginate`, which fetches the whole history
+# before LIMIT could apply.
+comments = []
+page = 1
+while len(comments) < limit:
+    res = subprocess.run(
+        ["gh", "api", "repos/%s/pulls/comments?per_page=100&sort=created&direction=desc&page=%d"
+         % (repo_slug, page)],
+        capture_output=True, text=True)
+    if res.returncode != 0:
+        print("mine-bot-comments: gh api failed for %s (auth? repo name?)" % repo_slug, file=sys.stderr)
+        sys.exit(1)
+    batch = json.loads(res.stdout or "[]")
+    if not isinstance(batch, list):
+        break
+    comments.extend(batch)
+    if len(batch) < 100:
+        break
+    page += 1
+comments = comments[:limit]
+
+BOT_RE = re.compile(r'gemini-code-assist|greptile|coderabbit', re.I)
+
+
+def is_bot(c):
+    # A reply in a bot's own thread ("Thanks, updated") is not a new finding.
+    # The account type too: a human login can contain a bot's name.
+    user = c.get("user") or {}
+    return (user.get("type") == "Bot" and bool(BOT_RE.search(user.get("login", "")))
+            and not c.get("in_reply_to_id"))
+
+
+bot_comments = [c for c in comments if is_bot(c)]
+
+
+def first_claim(body):
+    """The sentence that carries the finding, with the bot's chrome removed."""
+    text = body or ""
+    # Both bots lead with chrome: Gemini an image badge, Greptile an <a><img>
+    # priority pill. Neither is the claim.
+    text = re.sub(r'!\[[^\]]*\]\([^)]*\)', '', text)
+    text = re.sub(r'<!--.*?-->', '', text, flags=re.S)
+    text = re.sub(r'<[^>]+>', ' ', text)
+    # Fenced code is the suggestion, not the claim.
+    text = re.sub(r'```.*?```', ' ', text, flags=re.S)
+    text = re.sub(r'`[^`]*`', ' CODE ', text)
+    text = re.sub(r'^\s*[#>*\-]+\s*', '', text, flags=re.M)
+    text = re.sub(r'\s+', ' ', text).strip()
+    parts = re.split(r'(?<=[.!?])\s', text)
+    for p in parts:
+        if len(p.strip()) > 25:
+            return p.strip()[:400]
+    return text[:400]
+
+
+STOP = set("""a an and are as at be been but by can could does for from has have if in into is it
+its may not of on or should that the their them there these this to was were will with would you your
+we i be his her they code line file change changes when which what while also""".split())
+
+
+def signature(claim):
+    words = re.findall(r'[a-z]+', claim.lower())
+    words = [w for w in words if len(w) > 3 and w not in STOP]
+    # The 6 longest words are a good enough fingerprint at this scale: short
+    # common words carry little. Ties break alphabetically so wording order
+    # does not split one pattern into two clusters.
+    return tuple(sorted(set(words), key=lambda w: (-len(w), w))[:6])
+
+
+# A curated taxonomy on top of the free-text clustering. Fingerprint clustering
+# splits one concern across several wordings ("casting violates policy", "the use
+# of CODE is a type cast", "TypeScript casts bypass checks" are one comment the
+# bots make three ways), and the CATEGORY is what a reviewer can act on before
+# the bot ever runs.
+CATEGORIES = [
+    ("type cast / any",        r'\btype (cast|assertion)|\bcasting\b|\bas unknown\b|\bany\b type|\bnon-null assertion'),
+    ("null / undefined guard", r'\bnull\b|\bundefined\b|optional chain|\bmissing (a )?check'),
+    ("error handling",         r'\berror (handling|is swallowed)|silently (fail|ignor)|catch block|\bthrow\b|unhandled'),
+    ("pagination",             r'\bpaginat|\bpageInfo\b|\bhasNextPage\b|\bcursor\b|page size'),
+    ("await / concurrency",    r'\bawait\b|floating promise|not awaited|\brace\b|concurren|fire.and.forget'),
+    ("unused / dead code",     r'\bunused\b|not used|dead code|\bunreachable\b|never referenced'),
+    ("debug / logging",        r'\bconsole\.|debug(ging)? (statement|log)|log(ging)? (noise|level)|should be removed before'),
+    ("hardcoded / magic value",r'\bhardcoded\b|magic (number|string)|should be (a )?constant|configurable'),
+    ("naming",                 r'\bnaming\b|\brename\b|\bmisleading name|the name CODE'),
+    ("comment / docs",         r'\bcomment (is|does|adds)|\bredundant comment|\bjsdoc\b|\btypo\b'),
+    ("test coverage",          r'\btest (coverage|case)|\bnot (covered|tested)|missing (a )?test'),
+    ("performance / N+1",      r'\bN\+1\b|\bin a loop\b|inefficien|\bperformance\b|every (run|iteration)|batch'),
+    ("schedule / config",      r'\bcron\b|\bschedul|\benv (var|variable)|\byaml\b|\bvalues\.'),
+    ("SQL / query",            r'\bSQL\b|\bquery uses\b|\bwhere clause\b|\bindex\b|\btransaction\b'),
+]
+
+
+def categorize(body):
+    text = body or ""
+    hits = [name for name, rx in CATEGORIES if re.search(rx, text, re.I)]
+    return hits or ["other"]
+
+
+PRIORITY_RE = re.compile(r'badges/(p[0-9])\.svg|\b(P[0-9])\b')
+
+
+def priority(body):
+    m = PRIORITY_RE.search(body or "")
+    if not m:
+        return None
+    return (m.group(1) or m.group(2) or "").upper()
+
+
+category_counts = defaultdict(int)
+category_priority = defaultdict(list)
+for c in bot_comments:
+    prio = priority(c.get("body", ""))
+    for name in categorize(c.get("body", "")):
+        category_counts[name] += 1
+        if prio:
+            category_priority[name].append(prio)
+
+clusters = defaultdict(list)
+for c in bot_comments:
+    claim = first_claim(c.get("body", ""))
+    if not claim:
+        continue
+    clusters[signature(claim)].append((claim, c))
+
+# Merge clusters that share most of their fingerprint - one pattern phrased two
+# ways should not read as two patterns with a count of 1 each.
+merged = []
+for sig, items in sorted(clusters.items(), key=lambda kv: -len(kv[1])):
+    for m in merged:
+        shared = len(set(sig) & set(m["sig"]))
+        if sig and m["sig"] and shared / max(len(set(sig) | set(m["sig"])), 1) >= 0.5:
+            m["items"].extend(items)
+            break
+    else:
+        merged.append({"sig": sig, "items": list(items)})
+
+merged.sort(key=lambda m: -len(m["items"]))
+
+lines = []
+lines.append("## %s" % repo_slug)
+lines.append("<!-- mined: %s -->" % datetime.date.today().isoformat())
+lines.append("")
+if not bot_comments:
+    lines.append("No bot review comments in the newest %d review comment(s)." % len(comments))
+    lines.append("")
+else:
+    lines.append("Mined from %d bot review comment(s) (%s). Counts are how many times the "
+                 "bots have raised that pattern in THIS repo - the higher the count, the more "
+                 "certain it is to come back on the next PR."
+                 % (len(bot_comments), ", ".join(sorted({(c.get("user") or {}).get("login", "?")
+                                                         for c in bot_comments}))))
+    lines.append("")
+    lines.append("### Categories, most-raised first")
+    lines.append("")
+    lines.append("| times raised | category | typical priority |")
+    lines.append("|---|---|---|")
+    for name, count in sorted(category_counts.items(), key=lambda kv: -kv[1]):
+        prios = category_priority.get(name, [])
+        typical = min(prios) if prios else "-"
+        lines.append("| %d | %s | %s |" % (count, name, typical))
+    lines.append("")
+    lines.append("A comment can land in more than one category, so the column sums above the")
+    lines.append("comment total. Read the categories as priors: on a diff that touches one of")
+    lines.append("them, assume the bots will raise it and settle it before opening the PR.")
+    lines.append("")
+    lines.append("### Concrete comments, most-repeated first")
+    lines.append("")
+
+    for m in merged:
+        if len(m["items"]) < 2 and len(merged) > 12:
+            continue
+        claim, c = m["items"][0]
+        count = len(m["items"])
+        path = c.get("path") or "?"
+        lines.append("- **x%d** - %s" % (count, claim))
+        lines.append("  - e.g. `%s` ([comment](%s))" % (path, c.get("html_url", "")))
+
+    lines.append("")
+
+body = "\n".join(lines)
+
+# The file is shared by every repo, so two reviews mining at once must not
+# lose each other's sections: hold a lock across read-modify-write, and replace
+# the file atomically so a reader never sees half of it.
+import fcntl, tempfile
+lock = open(out_md + ".lock", "w")
+fcntl.flock(lock, fcntl.LOCK_EX)
+
+existing = ""
+if os.path.exists(out_md):
+    with open(out_md) as f:
+        existing = f.read()
+
+header = ("# Bot reviewer patterns\n\n"
+          "What Greptile / Gemini / CodeRabbit have actually commented on, per repo, mined\n"
+          "from review-comment history by `scripts/mine-bot-comments.sh`. This is evidence,\n"
+          "not prediction: every line below is a comment a bot really left.\n\n"
+          "Delivered to the review agents as `botPatternsFile`. Regenerate per repo with\n"
+          "`scripts/mine-bot-comments.sh <repo-slug>`.\n\n")
+
+if not existing.startswith("# Bot reviewer patterns"):
+    existing = header + existing
+
+# Replace this repo's section in place; leave every other repo alone.
+pattern = re.compile(r'^## %s$.*?(?=^## |\Z)' % re.escape(repo_slug), re.M | re.S)
+if pattern.search(existing):
+    # A function replacement, so backslashes in mined bot text are literal.
+    existing = pattern.sub(lambda _: body, existing)
+else:
+    existing = existing.rstrip() + "\n\n" + body
+
+fd, tmp = tempfile.mkstemp(dir=os.path.dirname(os.path.abspath(out_md)), prefix=".bot-patterns.")
+with os.fdopen(fd, "w") as f:
+    f.write(existing)
+os.replace(tmp, out_md)
+fcntl.flock(lock, fcntl.LOCK_UN)
+
+print("mine-bot-comments: %d bot comment(s) -> %d pattern(s) -> %s"
+      % (len(bot_comments), len(merged), out_md))
+PYEOF

package/plugins/olko-github-pr/skills/lekker-review/scripts/selftest.mjs

@@ -383,5 +383,191 @@ console.log('\ndeps depth: routing, classifier, line validation')
   check('summary counts', [r.summary.remapped, r.summary.nulled, r.summary.unchecked], [1, 1, 1])
 }
 
+console.log('\nbot pre-emption: lint pre-flight, pattern mining, precision store')
+{
+  const { spawnSync } = await import('node:child_process')
+  const { mkdtempSync, writeFileSync: wf, readFileSync: rf, mkdirSync, chmodSync, symlinkSync, existsSync, rmSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const tmp = mkdtempSync(join(tmpdir(), 'lekker-bots-'))
+  const script = name => join(SKILL, 'scripts', name)
+
+  const lint = (name, content, worktree = '/wt') => {
+    const inPath = join(tmp, `${name}.json`)
+    const outPath = join(tmp, `${name}.out.json`)
+    if (content !== undefined) wf(inPath, content)
+    const res = spawnSync('node', [script('lint-findings.mjs'), inPath, outPath], {
+      encoding: 'utf8', env: { ...process.env, LEKKER_WORKTREE_PATH: worktree },
+    })
+    return { status: res.status, out: JSON.parse(rf(outPath, 'utf8')) }
+  }
+  const msg = (ruleId, line, severity = 2, fix) => ({ ruleId, line, column: 1, severity, message: `${ruleId} hit`, ...(fix ? { fix } : {}) })
+  const report = JSON.stringify([
+    { filePath: '/wt/web/a.ts', messages: [msg('no-unused-vars', 3), msg('no-console', 9, 1), msg('no-unused-vars', 7, 2, { range: [0, 1], text: '' })] },
+    { filePath: '/wt/web/b.ts', messages: [msg('no-unused-vars', 1)] },
+    { filePath: '/wt/web/c.ts', messages: [] },
+  ])
+  const issues = lint('issues', report)
+  check('lint: one finding per rule and file, errors first',
+    issues.out.findings.map(f => `${f.rule} ${f.file}`), ['LINT:no-unused-vars web/a.ts', 'LINT:no-unused-vars web/b.ts', 'LINT:no-console web/a.ts'])
+  check('lint: error -> important, warning -> idiomatic', issues.out.findings.map(f => f.severity), ['important', 'important', 'idiomatic'])
+  check('lint: paths relative to the worktree', issues.out.findings[0].file, 'web/a.ts')
+  check('lint: fixable and site count carried', [issues.out.findings[0].lintFixable, issues.out.findings[0].lintSiteCount], [true, 2])
+  check('lint: every finding is botPredicted', issues.out.findings.every(f => f.botPredicted === true), true)
+  check('lint: summary', [issues.out.summary.status, issues.out.summary.messageCount, issues.out.summary.ruleCount], ['issues', 4, 2])
+  check('lint: a report with no messages is clean', lint('clean', '[{"filePath":"/wt/a.ts","messages":[]}]').out.summary.status, 'clean')
+  check('lint: an empty report is not clean', lint('empty', '').out.summary.status, 'empty-report')
+  check('lint: a report listing no files is not clean', lint('nofiles', '[]').out.summary.status, 'empty-report')
+  // eslint reports the resolved path while the worktree arrives via a symlink
+  // (macOS: /tmp -> /private/tmp); the finding must still be repo-relative.
+  const realWt = join(tmp, 'real-wt')
+  mkdirSync(join(realWt, 'web'), { recursive: true })
+  wf(join(realWt, 'web', 'd.ts'), 'const a = 1\nconst unused = 2\n')
+  symlinkSync(realWt, join(tmp, 'link-wt'))
+  const viaLink = lint('symlink', JSON.stringify([{ filePath: join(realWt, 'web', 'd.ts'), messages: [msg('no-unused-vars', 2)] }]), join(tmp, 'link-wt'))
+  check('lint: symlinked worktree still gives a relative path', viaLink.out.findings[0].file, 'web/d.ts')
+  check('lint: badCode is the source line, not a location', viaLink.out.findings[0].badCode, 'const unused = 2')
+  check('lint: a non-array report is not clean', lint('obj', '{}').out.summary.status, 'not-an-eslint-json-report')
+  const missing = lint('missing')
+  check('lint: a missing report is unknown, exit 0', [missing.status, missing.out.summary.status.startsWith('unreadable:')], [0, true])
+  check('lint: every site is carried for scoring', issues.out.findings[0].lintSites.map(x => `${x.file}:${x.line}`), ['web/a.ts:3', 'web/a.ts:7'])
+  const notices = lint('notices', JSON.stringify([{ filePath: '/wt/web/e.ts', messages: [
+    { ruleId: null, severity: 1, line: 0, message: 'File ignored because of a matching ignore pattern.' },
+    { ruleId: null, fatal: true, severity: 2, line: 4, message: 'Parsing error: Unexpected token' },
+  ] }]))
+  check('lint: an ignored-file notice is not a finding, a fatal parse error is',
+    [notices.out.summary.messageCount, notices.out.findings.map(f => f.rule)], [1, ['LINT:parse-error']])
+
+  // --base: only lines the change added count. A real repo, since the filter
+  // reads git diff -U0 <base> HEAD in the worktree.
+  const repo = join(tmp, 'diffrepo')
+  mkdirSync(join(repo, 'web'), { recursive: true })
+  const git = (...a) => spawnSync('git', ['-C', repo, '-c', 'user.name=t', '-c', 'user.email=t@t', ...a], { encoding: 'utf8' })
+  git('init', '-q')
+  wf(join(repo, 'web', 'f.ts'), 'one\ntwo\nthree\n')
+  git('config', 'diff.noprefix', 'true')
+  git('add', '.'); git('commit', '-qm', 'base')
+  const base = git('rev-parse', 'HEAD').stdout.trim()
+  wf(join(repo, 'web', 'f.ts'), 'one\nTWO\nthree\nfour\n')
+  git('commit', '-qam', 'change')
+  const inDiff = (() => {
+    const inPath = join(tmp, 'diff.json'), outPath = join(tmp, 'diff.out.json')
+    wf(inPath, JSON.stringify([{ filePath: join(repo, 'web', 'f.ts'), messages: [
+      msg('no-console', 1), msg('no-console', 2), msg('no-unused-vars', 4),
+      { ruleId: null, fatal: true, severity: 2, line: 1, message: 'Parsing error' },
+    ] }]))
+    spawnSync('node', [script('lint-findings.mjs'), inPath, outPath, '--base', base], { encoding: 'utf8', env: { ...process.env, LEKKER_WORKTREE_PATH: repo } })
+    return JSON.parse(rf(outPath, 'utf8'))
+  })()
+  check('lint --base: untouched lines dropped, added lines and parse errors kept',
+    [inDiff.summary.messageCount, inDiff.summary.outOfDiff, inDiff.findings.flatMap(f => f.lintSites.map(x => x.line)).sort()], [3, 1, [1, 2, 4]])
+
+  const store = join(tmp, 'precision.jsonl')
+  const prec = args => spawnSync('node', [script('bot-precision.mjs'), ...args, '--jsonl', store], { encoding: 'utf8' })
+  const predicted = join(tmp, 'issues.out.json')
+  const rec = prec(['record', '--repo', 'acme/app', '--pr', '7', '--predicted', predicted])
+  check('precision: record appends one prediction per lint site', [rec.status, JSON.parse(rf(store, 'utf8').trim()).predictedCount], [0, 4])
+  check('precision: lint findings are tagged lint-preflight',
+    JSON.parse(rf(store, 'utf8').trim()).predicted.every(p => p.source === 'lint-preflight'), true)
+  check('precision: no prediction scores as nothing, not 0%', /no recorded prediction/.test(prec(['score', '--repo', 'acme/app', '--pr', '8']).stdout), true)
+  check('precision: summary with no scores', /no scored reviews yet/.test(prec(['summary']).stdout), true)
+
+  // Data dir: LEKKER_DATA_DIR wins, else ~/.cache/lekker-review - never the
+  // skill dir, which a plugin update replaces.
+  const noJsonl = (env, args) => spawnSync('node', [script('bot-precision.mjs'), ...args], { encoding: 'utf8', env: { ...process.env, ...env } })
+  const dataDir = join(tmp, 'data')
+  noJsonl({ LEKKER_DATA_DIR: dataDir }, ['record', '--repo', 'acme/app', '--pr', '1', '--predicted', predicted])
+  check('precision: LEKKER_DATA_DIR sets the store', existsSync(join(dataDir, 'bot-precision.jsonl')), true)
+  const home = join(tmp, 'home')
+  const envNoData = { ...process.env, HOME: home }
+  delete envNoData.LEKKER_DATA_DIR
+  spawnSync('node', [script('bot-precision.mjs'), 'record', '--repo', 'acme/app', '--pr', '1', '--predicted', predicted], { encoding: 'utf8', env: envNoData })
+  check('precision: default store is ~/.cache/lekker-review', existsSync(join(home, '.cache', 'lekker-review', 'bot-precision.jsonl')), true)
+
+  // Stub gh on PATH so the miner runs offline against a fixed comment set.
+  const bin = join(tmp, 'bin')
+  mkdirSync(bin)
+  const comments = [
+    { user: { login: 'greptile-apps[bot]', type: 'Bot' }, path: 'src/a.ts', in_reply_to_id: 1, html_url: 'https://x/r', body: 'Thanks for the update, this looks resolved now to me.' },
+    { user: { login: 'coderabbit-fan', type: 'User' }, path: 'src/a.ts', html_url: 'https://x/h', body: 'A human whose login names a bot is still a human here.' },
+    ...[1, 2, 3].map(i => ({ user: { login: 'greptile-apps[bot]', type: 'Bot' }, path: 'src/a.ts', html_url: `https://x/${i}`, body: 'This type cast bypasses the compiler and hides a real mismatch here.' })),
+    { user: { login: 'gemini-code-assist[bot]', type: 'Bot' }, path: 'src/b.ts', html_url: 'https://x/4', body: 'The promise is not awaited, so errors are silently ignored by the caller.' },
+    { user: { login: 'a-human' }, path: 'src/c.ts', html_url: 'https://x/5', body: 'Humans are not mined, only the bots are counted here.' },
+  ]
+  wf(join(tmp, 'comments.json'), JSON.stringify(comments))
+  // Precision fixture, served --slurp style (a list of pages) for pulls/9.
+  const bot = (login, path, line) => ({ user: { login, type: login.endsWith('[bot]') ? 'Bot' : 'User' }, path, line, html_url: `https://x/${path}`, body: `${path} remark` })
+  wf(join(tmp, 'pr9.json'), JSON.stringify([[
+    bot('greptile-apps[bot]', 'web/a.ts', 10),
+    bot('gemini-code-assist[bot]', 'web/c.ts', 5),
+    bot('greptile-apps[bot]', 'web/b.ts', 50),
+    bot('a-human', 'web/a.ts', 100),
+    bot('coderabbit-fan', 'web/z.ts', 1),
+    { ...bot('greptile-apps[bot]', 'web/x.ts', 1), in_reply_to_id: 1 },
+    { ...bot('greptile-apps[bot]', 'web/y.ts', 1), created_at: '2000-01-01T00:00:00Z' },
+  ]]))
+  wf(join(bin, 'gh'), [
+    '#!/bin/sh',
+    'case "$*" in',
+    `  *pulls/9/comments*) cat "${join(tmp, 'pr9.json')}" ;;`,
+    "  *acme/empty*) echo '[]' ;;",
+    `  *'&page=1') cat "${join(tmp, 'comments.json')}" ;;`,
+    "  *) echo '[]' ;;",
+    'esac',
+    '',
+  ].join('\n'))
+  chmodSync(join(bin, 'gh'), 0o755)
+  const ghEnv = { ...process.env, PATH: `${bin}:${process.env.PATH}` }
+
+  // Predictions: a.ts:3 is 7 lines from a bot comment (hit), a.ts:100 has no
+  // bot comment within 20 lines (the human one does not count), b.ts with no
+  // line matches any comment on b.ts. c.ts was not predicted (missed).
+  const pr9 = join(tmp, 'pr9-predicted.json')
+  wf(pr9, JSON.stringify([{ file: 'web/a.ts', line: 3 }, { file: 'web/a.ts', line: 100 }, { file: 'web/b.ts', line: null }]))
+  const score9 = args => spawnSync('node', [script('bot-precision.mjs'), ...args, '--jsonl', store], { encoding: 'utf8', env: ghEnv })
+  score9(['record', '--repo', 'acme/app', '--pr', '9', '--predicted', pr9, '--at', new Date(Date.now() - 60000).toISOString()])
+  check('precision: --at must be a timestamp', score9(['record', '--repo', 'acme/app', '--pr', '9', '--predicted', pr9, '--at', 'soon']).status, 2)
+  // A later prediction (a re-review after the bots ran) must not be scored.
+  const late = join(tmp, 'pr9-late.json')
+  wf(late, JSON.stringify([{ file: 'web/c.ts', line: 5 }]))
+  score9(['record', '--repo', 'acme/app', '--pr', '9', '--predicted', late])
+  const s9 = score9(['score', '--repo', 'acme/app', '--pr', '9'])
+  const last = () => rf(store, 'utf8').trim().split('\n').map(l => JSON.parse(l)).filter(r => r.kind === 'score').pop()
+  const sc = last()
+  check('precision: score counts only bot comments, no replies', [s9.status, sc.botCommentCount], [0, 3])
+  check('precision: comments older than the prediction excluded', sc.preexistingExcluded, 1)
+  check('precision: the first prediction is scored, not a later one', sc.predictedCount, 3)
+  check('precision: precision and recall', [sc.predictedAndRaised, sc.botCommentsPredicted, sc.precision.toFixed(3), sc.recall.toFixed(3)], [2, 2, '0.667', '0.667'])
+  check('precision: a null line is "no line", not line 0', sc.predictedAndRaised, 2)
+  check('precision: missed comments listed', sc.missedBotComments.map(c => c.path), ['web/c.ts'])
+  score9(['score', '--repo', 'acme/app', '--pr', '9'])
+  check('precision: a re-scored PR counts once in the summary', /summary: 1 scored review/.test(score9(['summary']).stdout), true)
+  const out = join(tmp, 'patterns.md')
+  const mine = slug => spawnSync('bash', [script('mine-bot-comments.sh'), slug, out], { encoding: 'utf8', env: ghEnv })
+  const m1 = mine('acme/app')
+  const md1 = rf(out, 'utf8')
+  check('mine: exit 0 and a section for the repo', [m1.status, md1.includes('## acme/app\n')], [0, true])
+  check('mine: counts only bot comments', /Mined from 4 bot review comment/.test(md1), true)
+  check('mine: a repeated claim is one pattern with its count', /\*\*x3\*\* - This type cast/.test(md1), true)
+  check('mine: categories table', /\| 3 \| type cast \/ any \|/.test(md1), true)
+  check('mine: section carries its own mined date', md1.includes(`## acme/app\n<!-- mined: ${new Date().toISOString().slice(0, 10)} -->`), true)
+  const noLimit = spawnSync('bash', [script('mine-bot-comments.sh'), 'acme/app', out, '--limit'], { encoding: 'utf8', env: ghEnv, timeout: 10000 })
+  check('mine: --limit with no value fails fast', noLimit.status, 2)
+  const empty = mine('acme/empty')
+  check('mine: a repo with no bot comments still gets a section', [empty.status, rf(out, 'utf8').includes('## acme/empty\n<!-- mined: ')], [0, true])
+  mine('acme/other')
+  mine('acme/app')
+  const md2 = rf(out, 'utf8')
+  check('mine: re-mining replaces the section, other repos kept',
+    [md2.split('## acme/app\n').length - 1, md2.includes('## acme/other\n')], [1, true])
+
+  check('workflow.js tells agents not to re-report the pre-flight', src.includes('"preflightFile"'), true)
+  const skillMd = readFileSync(join(SKILL, 'SKILL.md'), 'utf8')
+  check('SKILL.md passes preflightFile and botPatternsFile in CONTEXT_FILE',
+    skillMd.includes('"preflightFile":') && skillMd.includes('"botPatternsFile":'), true)
+  check('SKILL.md ages bot patterns by the section marker, not file mtime',
+    skillMd.includes('<!-- mined: /') && !skillMd.includes('-mtime +30'), true)
+  rmSync(tmp, { recursive: true, force: true })
+}
+
 console.log(failed === 0 ? '\nall checks passed\n' : `\n${failed} check(s) FAILED\n`)
 process.exit(failed === 0 ? 0 : 1)

package/plugins/olko-github-pr/skills/lekker-review/scripts/setup-worktree.sh

@@ -14,6 +14,8 @@ set -euo pipefail
 REPO_SLUG="${1:?REPO_SLUG required}"
 PR_BRANCH="${2:?PR_BRANCH required}"
 OUT_JSON="${3:?OUT_JSON required}"
+# Absolute, because the static checks run after cd into the worktree.
+case "$OUT_JSON" in /*) ;; *) OUT_JSON="$PWD/$OUT_JSON" ;; esac
 PREV_SHA="${4:-}"
 
 LOCAL_REPO="${LEKKER_LOCAL_REPO:-}"
@@ -311,11 +313,50 @@ TSC_CHANGED_FILE="/tmp/lekker-tsc-changed-$$.txt"
 TSC_COUNT_FILE="/tmp/lekker-tsc-count-$$.txt"
 ESLINT_TAIL_FILE="/tmp/lekker-eslint-$$.txt"
 ESLINT_SCOPE_FILE="/tmp/lekker-eslint-scope-$$.txt"
+# Structured lint report, kept beside the output JSON (NOT deleted with the
+# temp files): lint-findings.mjs turns it into botPredicted findings, so the
+# review can fix what the bot reviewers would have charged for. Exported by
+# path as eslintJson.
+ESLINT_JSON_FILE="$(dirname "$OUT_JSON")/eslint-report.json"
 printf '' > "$TSC_TAIL_FILE"
 printf '' > "$TSC_CHANGED_FILE"
 printf '0' > "$TSC_COUNT_FILE"
 printf '' > "$ESLINT_TAIL_FILE"
 printf 'skipped' > "$ESLINT_SCOPE_FILE"
+printf '' > "$ESLINT_JSON_FILE"
+
+# Render a stylish-style tail from the JSON report. An empty or unparseable
+# report (eslint crashed, bad config) keeps whatever eslint wrote on stderr
+# instead of rendering "0 errors" from nothing.
+render_eslint_tail() {
+    local rendered="$ESLINT_JSON_FILE.txt"
+    node -e '
+const fs = require("fs");
+const raw = fs.readFileSync(process.argv[1], "utf8");
+if (!raw.trim()) process.exit(3);
+let report;
+try { report = JSON.parse(raw); } catch { process.exit(3); }
+if (!Array.isArray(report) || !report.length) process.exit(3);
+const lines = [];
+let errors = 0, warnings = 0;
+for (const f of report) {
+  const msgs = f.messages || [];
+  if (!msgs.length) continue;
+  lines.push(f.filePath);
+  for (const m of msgs) {
+    if (m.severity === 2) errors++; else warnings++;
+    lines.push(`  ${m.line}:${m.column}  ${m.severity === 2 ? "error" : "warning"}  ${m.message}  ${m.ruleId || ""}`);
+  }
+}
+if (!errors && !warnings) process.exit(0);
+lines.push(`total: ${errors} error(s), ${warnings} warning(s)`);
+process.stdout.write(lines.slice(-40).join("\n") + "\n");
+' "$ESLINT_JSON_FILE" > "$rendered" 2>/dev/null
+    if [[ -s "$rendered" ]]; then
+        cat "$rendered" > "$ESLINT_TAIL_FILE"
+    fi
+    rm -f "$rendered"
+}
 
 run_tsc() {
     # tsc needs the whole program to resolve types, so it always runs
@@ -345,8 +386,11 @@ run_eslint() {
         if [[ "$has_config" == "true" ]]; then
             if [[ -s "$CHANGED_FILES_FILE" ]]; then
                 if [[ ${#ESLINT_TARGETS[@]} -gt 0 ]]; then
-                    # Default (stylish) formatter: ESLint 9 removed the bundled "compact" formatter
-                    (cd "$WORKTREE_PATH" && npx eslint --max-warnings=0 "${ESLINT_TARGETS[@]}" 2>&1 | tail -40 >> "$ESLINT_TAIL_FILE") || true
+                    # One run, JSON formatter: the machine-readable report feeds
+                    # lint-findings.mjs and the human tail is rendered from the
+                    # same report, so the two can never disagree.
+                    (cd "$WORKTREE_PATH" && npx eslint --max-warnings=0 -f json -o "$ESLINT_JSON_FILE" "${ESLINT_TARGETS[@]}" 2> "$ESLINT_TAIL_FILE") || true
+                    render_eslint_tail
                     printf 'changed-files' > "$ESLINT_SCOPE_FILE"
                 else
                     printf 'no-changed-lintable-files\n' > "$ESLINT_TAIL_FILE"
@@ -354,6 +398,8 @@ run_eslint() {
                 fi
             else
                 # Base ref could not be resolved -- fall back to the old repo-wide run.
+                # No JSON here on purpose: a repo-wide report is standing debt,
+                # not this change's, and must not become botPredicted findings.
                 (cd "$WORKTREE_PATH" && npx eslint . --max-warnings=0 2>&1 | tail -40 >> "$ESLINT_TAIL_FILE") || true
                 printf 'full-fallback' > "$ESLINT_SCOPE_FILE"
             fi
@@ -428,6 +474,7 @@ python3 - \
     "$TSC_COUNT_FILE" \
     "$MERGE_BASE_VAL" \
     "$DEPS_INSTALL_FILE" \
+    "$ESLINT_JSON_FILE" \
     "$OUT_JSON" <<'PYEOF'
 import json, sys, os
 
@@ -435,7 +482,7 @@ import json, sys, os
  tsc_file, eslint_file, rules_file, delta_file, notes,
  changed_files_file, base_ref_val, eslint_scope_file,
  tsc_changed_file, tsc_count_file, merge_base_val,
- deps_install_file, out_json) = sys.argv[1:18]
+ deps_install_file, eslint_json_file, out_json) = sys.argv[1:19]
 
 def read_file(path):
     if not os.path.exists(path):
@@ -462,6 +509,14 @@ for row in read_file(deps_install_file).splitlines():
 
 changed_files = [l for l in read_file(changed_files_file).splitlines() if l.strip()]
 
+
+def file_has_content(path):
+    try:
+        return os.path.getsize(path) > 0
+    except OSError:
+        return False
+
+
 eslint_scope = read_file(eslint_scope_file).strip() or "skipped"
 
 try:
@@ -486,6 +541,10 @@ data = {
     "tscChangedTail": read_file(tsc_changed_file),
     "tscErrorCount":  tsc_error_count,
     "depsInstall":    deps_install,
+    # Path, not content: lint-findings.mjs reads it. None when eslint produced
+    # no structured report (skipped, no config, crashed, or the repo-wide
+    # fallback), so a consumer can tell "no lint report" from "no problems".
+    "eslintJson":     eslint_json_file if file_has_content(eslint_json_file) else None,
 }
 
 for p in (tsc_file, eslint_file, rules_file, changed_files_file,

package/plugins/olko-github-pr/skills/lekker-review/workflow.js

@@ -519,6 +519,16 @@ const budgetAtStart = budget.spent()
         + ` number of DIFF_FILE itself. Quote the code at that line verbatim in "badCode".`,
     ].join(' ')
 
+    // The deterministic lint pre-flight has already collected every rule the
+    // repo's own eslint config fires on this diff, and those are exactly the
+    // comments the bot reviewers bill for. An agent re-reporting them costs a
+    // verifier round and produces a worse description than the linter's.
+    prompt += ` PRE-FLIGHT: CONTEXT_FILE may carry a key "preflightFile" pointing`
+      + ` at lint findings already collected deterministically from the repo's own`
+      + ` eslint config. If it is present and non-null, Read it and do NOT re-report`
+      + ` anything it already lists - those are already queued for fixing. Report`
+      + ` only what it missed.`
+
     if (prevSha) {
       prompt += ` RE-REVIEW MODE: a prior review covered up to commit ${prevSha}.`
         + ` Focus findings on the delta (see key deltaFile in CONTEXT_FILE);`

package/plugins/olko-obsidian/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "olko-obsidian",
   "description": "Keep an Obsidian vault in sync with work: PR sync, task rollover, morning routine.",
-  "version": "1.54.3",
+  "version": "1.55.0",
   "author": {
     "name": "Oleg Koval"
   },

package/plugins/olko-product/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "olko-product",
   "description": "Take a product idea to a shippable build: MVP passes, full-stack scaffolds, UX/UI quality loops, launch plans.",
-  "version": "1.54.3",
+  "version": "1.55.0",
   "author": {
     "name": "Oleg Koval"
   },

package/plugins/olko-reflection/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "olko-reflection",
   "description": "Look back and improve: self-critique, retrospectives, performance review, rapid learning.",
-  "version": "1.54.3",
+  "version": "1.55.0",
   "author": {
     "name": "Oleg Koval"
   },

package/plugins/olko-release/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "olko-release",
   "description": "Ship a release: semantic-release setup, changelogs, store listing copy, release-day routine.",
-  "version": "1.54.3",
+  "version": "1.55.0",
   "author": {
     "name": "Oleg Koval"
   },