@olegkoval/agent-skills 1.58.0 → 1.59.0

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

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+// Run ledger for lekker-review: one row per review run, plus a small archive of
+// the run's own files, so past runs can be measured and compared.
+//
+// Before this, the evidence of a run was split across four places that nothing
+// joined: the review markdown, the scratchpad (deleted with the session), the
+// Workflow tool's own record under ~/.claude/projects (owned by Claude Code and
+// cleaned with old sessions), and the revmux task archive.
+//
+// Usage:
+//   node run-log.mjs start  --repo <slug> --target <pr-N|branch-x> --mode pr|branch \
+//                           --depth <d> --engine workflow|revmux [--fix] [--host claude]
+//   node run-log.mjs mark   <runId> <phase> [--note <text>]
+//   node run-log.mjs attach <runId> <file>...
+//   node run-log.mjs finish <runId> --status ok|failed|aborted [--verdict lgtm|lgtm-with-changes|needs-work]
+//                           [--review-file <path>] [--artifact-url <url>] [--wf <wf_id>]... [--note <text>]
+//   node run-log.mjs report [--days 30] [--json]
+//   node run-log.mjs backfill        import past Workflow-tool records and revmux rounds
+//   node run-log.mjs prune [--keep-days 90]
+//
+// Layout under ${LEKKER_STATE_DIR:-~/.local/state/lekker-review}:
+//   runs.jsonl                one row per finish; `report` keeps the LAST row per runId
+//   runs/<runId>/run.json     the same row, with the timeline
+//   runs/<runId>/timeline.jsonl
+//   runs/<runId>/<attached files>
+//
+// `finish` may be called more than once for one run (after the review, again
+// after fix mode); every call appends a fresh row and the newest one wins.
+
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, copyFileSync, readdirSync, statSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+
+const STATE_DIR = process.env.LEKKER_STATE_DIR || join(homedir(), '.local', 'state', 'lekker-review');
+const RUNS_DIR = join(STATE_DIR, 'runs');
+const LEDGER = join(STATE_DIR, 'runs.jsonl');
+const PROJECTS_DIR = process.env.LEKKER_CLAUDE_PROJECTS || join(homedir(), '.claude', 'projects');
+const REVMUX_TASKS = process.env.LEKKER_REVMUX_TASKS_DIR || join(homedir(), 'code-reviews', 'revmux-tasks');
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+
+function flag(name, fallback = null) {
+  const i = argv.indexOf('--' + name);
+  return i === -1 ? fallback : argv[i + 1];
+}
+function flags(name) {
+  const out = [];
+  argv.forEach((a, i) => { if (a === '--' + name && argv[i + 1]) out.push(argv[i + 1]); });
+  return out;
+}
+const has = (name) => argv.includes('--' + name);
+
+const readJson = (p) => {
+  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; }
+};
+const readJsonl = (p) => (existsSync(p) ? readFileSync(p, 'utf8').split('\n').filter(Boolean).map((l) => {
+  try { return JSON.parse(l); } catch { return null; }
+}).filter(Boolean) : []);
+
+function runDir(runId) {
+  if (!/^[A-Za-z0-9._-]+$/.test(runId || '')) fail(`bad runId "${runId}"`);
+  return join(RUNS_DIR, runId);
+}
+
+function fail(msg) {
+  console.log(JSON.stringify({ error: msg }));
+  process.exit(2);
+}
+
+const slug = (s) => String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+
+// The Workflow tool keeps its own record of every run (duration, total tokens,
+// agent count, the returned result). Copying the numbers out at finish time is
+// what keeps them once Claude Code cleans up the session directory.
+function findWorkflowRecord(wfId) {
+  if (!existsSync(PROJECTS_DIR)) return null;
+  for (const project of readdirSync(PROJECTS_DIR)) {
+    const projectDir = join(PROJECTS_DIR, project);
+    let sessions;
+    try { sessions = readdirSync(projectDir); } catch { continue; }
+    for (const session of sessions) {
+      const p = join(projectDir, session, 'workflows', `${wfId}.json`);
+      if (existsSync(p)) return readJson(p);
+    }
+  }
+  return null;
+}
+
+function summariseWorkflow(rec) {
+  const result = rec?.result && typeof rec.result === 'object' ? rec.result : {};
+  return {
+    wfId: rec?.runId ?? null,
+    name: rec?.workflowName ?? null,
+    status: rec?.status ?? null,
+    durationS: rec?.durationMs != null ? Math.round(rec.durationMs / 1000) : null,
+    totalTokens: rec?.totalTokens ?? null,
+    agentCount: rec?.agentCount ?? null,
+    toolCalls: rec?.totalToolCalls ?? null,
+    outputTokens: result.outputTokens ?? null,
+    found: Array.isArray(result.findings) ? result.findings.length : null,
+    dropped: result.droppedCount ?? null,
+    downgraded: result.downgradedCount ?? null,
+    hardRule: result.hardRuleCount ?? null,
+    proveAttempts: result.proveAttemptCount ?? null,
+    proven: result.provenCount ?? null,
+    sessionModel: rec?.defaultModel ?? null,
+  };
+}
+
+function severityCounts(findings) {
+  const list = Array.isArray(findings) ? findings : findings?.findings;
+  if (!Array.isArray(list)) return null;
+  const counts = { total: list.length };
+  for (const f of list) counts[f.severity || 'unknown'] = (counts[f.severity || 'unknown'] || 0) + 1;
+  return counts;
+}
+
+function phaseDurations(timeline) {
+  const out = {};
+  for (let i = 0; i < timeline.length - 1; i++) {
+    const ms = Date.parse(timeline[i + 1].at) - Date.parse(timeline[i].at);
+    out[timeline[i].phase] = (out[timeline[i].phase] || 0) + Math.round(ms / 1000);
+  }
+  return out;
+}
+
+function append(row) {
+  mkdirSync(STATE_DIR, { recursive: true });
+  appendFileSync(LEDGER, JSON.stringify(row) + '\n');
+}
+
+function latestRows(days) {
+  const cutoff = days ? Date.now() - days * 86400000 : 0;
+  const byId = new Map();
+  for (const row of readJsonl(LEDGER)) byId.set(row.runId, row);
+  return [...byId.values()].filter((r) => Date.parse(r.startedAt || r.finishedAt) >= cutoff);
+}
+
+const median = (xs) => {
+  const s = xs.filter((x) => typeof x === 'number').sort((a, b) => a - b);
+  return s.length ? s[Math.floor((s.length - 1) / 2)] : null;
+};
+const p90 = (xs) => {
+  const s = xs.filter((x) => typeof x === 'number').sort((a, b) => a - b);
+  return s.length ? s[Math.floor(0.9 * (s.length - 1))] : null;
+};
+const sum = (xs) => xs.reduce((a, x) => a + (typeof x === 'number' ? x : 0), 0);
+
+if (cmd === 'start') {
+  const repo = flag('repo');
+  const target = flag('target');
+  if (!repo || !target) fail('start needs --repo and --target');
+  const startedAt = new Date().toISOString();
+  const runId = `${startedAt.replace(/[-:]/g, '').slice(0, 15)}-${slug(repo.split('/').pop())}-${slug(target)}`;
+  const dir = runDir(runId);
+  mkdirSync(dir, { recursive: true });
+  const meta = {
+    schema: 1, runId, startedAt, repo, target,
+    mode: flag('mode', 'pr'), depth: flag('depth'), engine: flag('engine', 'workflow'),
+    fix: has('fix'), host: flag('host', 'claude'),
+  };
+  writeFileSync(join(dir, 'run.json'), JSON.stringify(meta, null, 2) + '\n');
+  appendFileSync(join(dir, 'timeline.jsonl'), JSON.stringify({ phase: 'start', at: startedAt }) + '\n');
+  console.log(JSON.stringify({ runId, dir }));
+} else if (cmd === 'mark') {
+  const [runId, phase] = [argv[1], argv[2]];
+  if (!phase) fail('mark needs <runId> <phase>');
+  const dir = runDir(runId);
+  if (!existsSync(dir)) fail(`no run ${runId}`);
+  appendFileSync(join(dir, 'timeline.jsonl'), JSON.stringify({ phase, at: new Date().toISOString(), note: flag('note') ?? undefined }) + '\n');
+  console.log(JSON.stringify({ runId, phase }));
+} else if (cmd === 'attach') {
+  const runId = argv[1];
+  const dir = runDir(runId);
+  if (!existsSync(dir)) fail(`no run ${runId}`);
+  const copied = [];
+  const missing = [];
+  for (const file of argv.slice(2)) {
+    if (existsSync(file)) { copyFileSync(file, join(dir, basename(file))); copied.push(basename(file)); }
+    else missing.push(file);
+  }
+  console.log(JSON.stringify({ runId, copied, missing }));
+} else if (cmd === 'finish') {
+  const runId = argv[1];
+  const dir = runDir(runId);
+  const meta = readJson(join(dir, 'run.json'));
+  if (!meta) fail(`no run ${runId}`);
+  const finishedAt = new Date().toISOString();
+  const timeline = [...readJsonl(join(dir, 'timeline.jsonl')), { phase: 'finish', at: finishedAt }];
+  const workflows = flags('wf').map((id) => summariseWorkflow(findWorkflowRecord(id) || { runId: id }));
+  const reviewWf = workflows.find((w) => w.name === 'lekker-review-core') || null;
+  const row = {
+    ...meta,
+    finishedAt,
+    status: flag('status', 'ok'),
+    verdict: flag('verdict', meta.verdict ?? null),
+    wallS: Math.round((Date.parse(finishedAt) - Date.parse(meta.startedAt)) / 1000),
+    phasesS: phaseDurations(timeline),
+    findings: severityCounts(readJson(join(dir, 'findings.json'))),
+    review: reviewWf,
+    workflows,
+    tokensTotal: sum(workflows.map((w) => w.totalTokens)) || null,
+    reviewFile: flag('review-file', meta.reviewFile ?? null),
+    artifactUrl: flag('artifact-url'),
+    note: flag('note', meta.note ?? null),
+  };
+  writeFileSync(join(dir, 'run.json'), JSON.stringify({ ...row, timeline }, null, 2) + '\n');
+  append(row);
+  const unresolved = workflows.filter((w) => w.durationS == null).map((w) => w.wfId);
+  console.log(JSON.stringify({ runId, ledger: LEDGER, wallS: row.wallS, tokensTotal: row.tokensTotal, unresolvedWorkflows: unresolved }));
+} else if (cmd === 'report') {
+  const days = Number(flag('days', '30'));
+  const rows = latestRows(days);
+  const groups = new Map();
+  for (const r of rows) {
+    const key = `${r.engine || 'workflow'}/${r.depth || 'unknown'}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(r);
+  }
+  const table = [...groups.entries()].sort().map(([key, rs]) => {
+    const found = sum(rs.map((r) => r.review?.found));
+    const dropped = sum(rs.map((r) => r.review?.dropped));
+    return {
+      group: key,
+      runs: rs.length,
+      failed: rs.filter((r) => r.status !== 'ok').length,
+      reviewMedianS: median(rs.map((r) => r.review?.durationS)),
+      reviewP90S: p90(rs.map((r) => r.review?.durationS)),
+      wallMedianS: median(rs.map((r) => r.wallS)),
+      tokensMedianK: median(rs.map((r) => (r.tokensTotal ? Math.round(r.tokensTotal / 1000) : null))),
+      agentsMedian: median(rs.map((r) => r.review?.agentCount)),
+      findingsMedian: median(rs.map((r) => r.review?.found ?? r.findings?.total)),
+      verifierDropRate: found + dropped ? +(dropped / (found + dropped)).toFixed(3) : null,
+      proven: `${sum(rs.map((r) => r.review?.proven))}/${sum(rs.map((r) => r.review?.proveAttempts))}`,
+    };
+  });
+  const verdicts = {};
+  for (const r of rows) if (r.verdict) verdicts[r.verdict] = (verdicts[r.verdict] || 0) + 1;
+  const revmux = rows.filter((r) => r.source === 'revmux-backfill');
+  // Cost medians over rounds that produced a result: a fully degraded round costs ~$0 and drags them down.
+  const revmuxOk = revmux.filter((r) => r.status === 'ok');
+  const out = {
+    window: `${days}d`, runs: rows.length, ledger: LEDGER, table, verdicts,
+    revmuxRounds: revmux.length ? {
+      rounds: revmux.length,
+      fullyDegraded: revmux.filter((r) => r.revmux.degraded >= r.revmux.agents && r.revmux.agents > 0).length,
+      medianUsd: median(revmuxOk.map((r) => r.revmux.usd)),
+      medianTokensK: median(revmuxOk.map((r) => (r.tokensTotal ? Math.round(r.tokensTotal / 1000) : null))),
+      medianWallS: median(revmuxOk.map((r) => r.wallS)),
+    } : null,
+  };
+  if (has('json')) {
+    console.log(JSON.stringify(out, null, 2));
+  } else {
+    console.log(`lekker-review runs, last ${out.window}: ${out.runs} (ledger ${LEDGER})`);
+    const cols = ['group', 'runs', 'failed', 'reviewMedianS', 'reviewP90S', 'tokensMedianK', 'agentsMedian', 'findingsMedian', 'verifierDropRate', 'proven'];
+    console.log(cols.join('\t'));
+    for (const t of table) console.log(cols.map((c) => t[c] ?? '-').join('\t'));
+    if (Object.keys(verdicts).length) console.log('verdicts:', JSON.stringify(verdicts));
+    if (out.revmuxRounds) console.log('revmux rounds:', JSON.stringify(out.revmuxRounds));
+  }
+} else if (cmd === 'backfill') {
+  const known = new Set(latestRows(0).flatMap((r) => [r.runId, ...(r.workflows || []).map((w) => w.wfId)]));
+  let added = 0;
+  if (existsSync(PROJECTS_DIR)) {
+    for (const project of readdirSync(PROJECTS_DIR)) {
+      let sessions;
+      try { sessions = readdirSync(join(PROJECTS_DIR, project)); } catch { continue; }
+      for (const session of sessions) {
+        const wfDir = join(PROJECTS_DIR, project, session, 'workflows');
+        if (!existsSync(wfDir)) continue;
+        for (const f of readdirSync(wfDir)) {
+          if (!f.endsWith('.json')) continue;
+          const rec = readJson(join(wfDir, f));
+          if (!rec?.workflowName?.startsWith('lekker-review') || known.has(rec.runId)) continue;
+          const args = rec.args && typeof rec.args === 'object' ? rec.args : {};
+          const w = summariseWorkflow(rec);
+          append({
+            schema: 1, source: 'harness-backfill', runId: rec.runId, startedAt: rec.timestamp,
+            repo: args.repoSlug ?? null, target: args.prNumber ? `pr-${args.prNumber}` : args.targetLabel ?? null,
+            depth: rec.workflowName === 'lekker-review-fix' ? 'fix' : args.depth ?? null,
+            engine: args.engine || 'workflow', status: rec.status === 'completed' ? 'ok' : 'failed',
+            review: rec.workflowName === 'lekker-review-core' ? w : null, workflows: [w], tokensTotal: w.totalTokens,
+          });
+          known.add(rec.runId);
+          added++;
+        }
+      }
+    }
+  }
+  if (existsSync(REVMUX_TASKS)) {
+    for (const task of readdirSync(REVMUX_TASKS)) {
+      let rounds;
+      try { rounds = readdirSync(join(REVMUX_TASKS, task)); } catch { continue; }
+      for (const round of rounds) {
+        const roundDir = join(REVMUX_TASKS, task, round);
+        const events = readJsonl(join(roundDir, 'events.jsonl'));
+        const runId = `revmux-${task}-${round}`;
+        if (!events.length || known.has(runId)) continue;
+        const started = new Set(events.filter((e) => e.kind === 'agent_started').map((e) => e.agent));
+        const degraded = new Set(events.filter((e) => e.kind === 'agent_degraded').map((e) => e.agent));
+        let usd = 0;
+        let tokens = 0;
+        const agentsDir = join(roundDir, 'agents');
+        if (existsSync(agentsDir)) {
+          for (const a of readdirSync(agentsDir)) {
+            for (const line of readJsonl(join(agentsDir, a))) {
+              if (line.type !== 'result') continue;
+              usd += line.total_cost_usd || 0;
+              const u = line.usage || {};
+              tokens += (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.output_tokens || 0);
+            }
+          }
+        }
+        const times = events.map((e) => Date.parse(e.at)).filter(Number.isFinite);
+        append({
+          schema: 1, source: 'revmux-backfill', runId, startedAt: new Date(Math.min(...times)).toISOString(),
+          target: task, engine: 'revmux', depth: 'round', status: degraded.size >= started.size && started.size ? 'failed' : 'ok',
+          wallS: Math.round((Math.max(...times) - Math.min(...times)) / 1000), tokensTotal: tokens || null,
+          revmux: { agents: started.size, degraded: degraded.size, usd: +usd.toFixed(2) },
+        });
+        known.add(runId);
+        added++;
+      }
+    }
+  }
+  console.log(JSON.stringify({ added, ledger: LEDGER }));
+} else if (cmd === 'prune') {
+  const keepDays = Number(flag('keep-days', '90'));
+  const cutoff = Date.now() - keepDays * 86400000;
+  const removed = [];
+  if (existsSync(RUNS_DIR)) {
+    for (const id of readdirSync(RUNS_DIR)) {
+      const dir = join(RUNS_DIR, id);
+      // Only directories this script created: they all hold a run.json.
+      if (!existsSync(join(dir, 'run.json'))) continue;
+      if (statSync(dir).mtimeMs < cutoff) { rmSync(dir, { recursive: true, force: true }); removed.push(id); }
+    }
+  }
+  console.log(JSON.stringify({ removed: removed.length, keptLedger: LEDGER }));
+} else {
+  fail(`unknown command "${cmd}"`);
+}

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

@@ -569,5 +569,112 @@ console.log('\nbot pre-emption: lint pre-flight, pattern mining, precision store
   rmSync(tmp, { recursive: true, force: true })
 }
 
+console.log('\ndeps: obsolete ledger tools are ignored')
+{
+  const { spawnSync } = await import('node:child_process')
+  const { mkdtempSync, mkdirSync, writeFileSync, chmodSync, rmSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const tmp = mkdtempSync(join(tmpdir(), 'lekker-deps-'))
+  try {
+    const bin = join(tmp, 'bin')
+    mkdirSync(bin)
+    for (const name of ['git', 'gh', 'node', 'npx', 'jq', 'python3', 'icm']) {
+      const output = name === 'gh' ? 'v2.0.0' : '1.0.0'
+      writeFileSync(join(bin, name), `#!/bin/sh\necho ${output}\n`)
+      chmodSync(join(bin, name), 0o755)
+    }
+    const now = new Date().toISOString()
+    const obsolete = { choice: 'installed', version: '0.1.0' }
+    const ledger = join(tmp, 'deps.json')
+    writeFileSync(ledger, JSON.stringify({
+      initialisedAt: now, checkedAt: now, lastAttemptAt: now, cadenceDays: 7, autoUpdate: false,
+      tools: { legacy: obsolete, constructor: obsolete, icm: { choice: 'installed' }, revmux: { choice: 'skipped' } },
+    }))
+    const run = args => spawnSync(process.execPath, [join(SKILL, 'scripts', 'deps.mjs'), 'check', ...args], {
+      encoding: 'utf8', env: { ...process.env, PATH: bin, LEKKER_STATE_DIR: tmp },
+    })
+    for (const args of [[], ['--force']]) {
+      const result = run(args)
+      check(`deps ${args.length ? 'full' : 'presence'} check exits successfully`, result.status, 0)
+      const out = JSON.parse(result.stdout)
+      check('deps reports only registered installed tools', out.presence, { icm: 'present' })
+      check('deps preserves skipped tools', out.skipped, ['revmux'])
+    }
+    const saved = JSON.parse(readFileSync(ledger, 'utf8'))
+    check('deps leaves obsolete entries untouched', [saved.tools.legacy, saved.tools.constructor], [obsolete, obsolete])
+    check('deps still checks registered versions', [saved.tools.icm.version, saved.tools.icm.latest, saved.tools.icm.outdated], ['1.0.0', '2.0.0', true])
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+console.log('\nrun log: repeated finishes retain optional metadata')
+{
+  const { execFileSync } = await import('node:child_process')
+  const { mkdtempSync, rmSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const tmp = mkdtempSync(join(tmpdir(), 'lekker-run-log-'))
+  try {
+    const run = args => JSON.parse(execFileSync(process.execPath, [join(SKILL, 'scripts', 'run-log.mjs'), ...args], {
+      encoding: 'utf8', env: { ...process.env, LEKKER_STATE_DIR: tmp },
+    }))
+    const { runId } = run(['start', '--repo', 'example/repo', '--target', 'pr-1'])
+    const meta = () => JSON.parse(readFileSync(join(tmp, 'runs', runId, 'run.json'), 'utf8'))
+    const values = row => [row.verdict, row.reviewFile, row.note]
+    run(['finish', runId])
+    check('run log defaults absent metadata to null', values(meta()), [null, null, null])
+    run(['finish', runId, '--verdict', 'needs-work', '--review-file', '/tmp/review.md', '--note', 'initial review'])
+    run(['finish', runId, '--artifact-url', 'https://example.invalid/review'])
+    check('run log retains omitted metadata', values(meta()), ['needs-work', '/tmp/review.md', 'initial review'])
+    const rows = readFileSync(join(tmp, 'runs.jsonl'), 'utf8').trim().split('\n').map(JSON.parse)
+    check('run log appends retained values to the ledger', values(rows.at(-1)), values(meta()))
+    run(['finish', runId, '--verdict', 'lgtm', '--review-file', '/tmp/updated.md', '--note', ''])
+    check('run log accepts explicit replacements including empty values', values(meta()), ['lgtm', '/tmp/updated.md', ''])
+    run(['finish', runId])
+    check('run log retains explicit empty values', values(meta()), ['lgtm', '/tmp/updated.md', ''])
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+console.log('\nprove: skipped without an installed test runner')
+{
+  const { spawnSync } = await import('node:child_process')
+  const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const wf = readFileSync(join(SKILL, 'workflow.js'), 'utf8')
+  check('prover is skipped without a usable test runner', /proveCandidates\.length > 0 && !hasRunner/.test(wf), true)
+  check('workflow reads testRunner from args', /^\s+testRunner,$/m.test(wf), true)
+
+  const runnerOf = dir => JSON.parse(spawnSync('node', [join(SKILL, 'scripts', 'test-runner.mjs'), dir], { encoding: 'utf8' }).stdout)
+  const tmp = mkdtempSync(join(tmpdir(), 'lekker-runner-'))
+  writeFileSync(join(tmp, 'package.json'), JSON.stringify({ devDependencies: { vitest: '^2' }, scripts: { test: 'vitest' } }))
+  const missing = runnerOf(tmp)
+  check('declared but uninstalled runner is not usable', [missing.runner, /node_modules\/\.bin\/vitest missing/.test(missing.reason)], [null, true])
+  mkdirSync(join(tmp, 'node_modules', '.bin'), { recursive: true })
+  writeFileSync(join(tmp, 'node_modules', '.bin', 'vitest'), '')
+  check('installed runner is usable at the root', runnerOf(tmp), { runner: 'vitest', dirs: [{ dir: '.', runner: 'vitest' }], reason: null })
+  const pkg = (dir, data) => {
+    mkdirSync(join(tmp, dir), { recursive: true })
+    writeFileSync(join(tmp, dir, 'package.json'), JSON.stringify(data))
+  }
+  pkg('packages/a', { devDependencies: { vitest: '^2' } })
+  pkg('packages/b', { devDependencies: { jest: '^29' } })
+  pkg('packages/c', { scripts: { test: 'node --test' } })
+  mkdirSync(join(tmp, 'packages', 'node_modules', '.bin'), { recursive: true })
+  writeFileSync(join(tmp, 'packages', 'node_modules', '.bin', 'jest'), '')
+  check('each package retains its runner, including root and intermediate hoists', runnerOf(tmp), {
+    runner: 'vitest', dirs: [
+      { dir: '.', runner: 'vitest' }, { dir: 'packages/a', runner: 'vitest' },
+      { dir: 'packages/b', runner: 'jest' }, { dir: 'packages/c', runner: 'node-test' },
+    ], reason: null,
+  })
+  pkg('isolated', { devDependencies: { vitest: '^2' } })
+  const isolated = runnerOf(join(tmp, 'isolated') + '/')
+  check('binary lookup stops at the worktree root, including a trailing slash',
+    [isolated.runner, isolated.dirs, /node_modules\/\.bin\/vitest missing/.test(isolated.reason)], [null, [], 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

@@ -290,6 +290,12 @@ done < <(find "$WORKTREE_PATH" -mindepth 2 -maxdepth 3 -name package.json \
     -not -path '*/node_modules/*' 2>/dev/null)
 [[ "$NM_LINKED" == "true" ]] || NOTES="${NOTES}no-node_modules-static-checks-skipped;"
 
+# Can a single test file run here? The prove phase reads this instead of
+# paying a prover agent to discover a missing node_modules.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEST_RUNNER_JSON="$(node "$SCRIPT_DIR/test-runner.mjs" "$WORKTREE_PATH" 2>/dev/null \
+    || printf '{"runner":null,"dirs":[],"reason":"test-runner.mjs failed"}')"
+
 # Lintable, still-on-disk changed files (a deleted file must not go to eslint).
 ESLINT_TARGETS=()
 if [[ -s "$CHANGED_FILES_FILE" ]]; then
@@ -475,6 +481,7 @@ python3 - \
     "$MERGE_BASE_VAL" \
     "$DEPS_INSTALL_FILE" \
     "$ESLINT_JSON_FILE" \
+    "$TEST_RUNNER_JSON" \
     "$OUT_JSON" <<'PYEOF'
 import json, sys, os
 
@@ -482,7 +489,13 @@ 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, eslint_json_file, out_json) = sys.argv[1:19]
+ deps_install_file, eslint_json_file, test_runner_json, out_json) = sys.argv[1:20]
+
+def parse_runner(raw):
+    try:
+        return json.loads(raw)
+    except ValueError:
+        return {"runner": None, "dirs": [], "reason": "unparseable test-runner output"}
 
 def read_file(path):
     if not os.path.exists(path):
@@ -541,6 +554,8 @@ data = {
     "tscChangedTail": read_file(tsc_changed_file),
     "tscErrorCount":  tsc_error_count,
     "depsInstall":    deps_install,
+    # {runner, dirs, reason}; runner null means Prove is skipped.
+    "testRunner":     parse_runner(test_runner_json),
     # 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".

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

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Decide whether a worktree can run a single test file, before any prover
+// agent is paid to find out.
+//
+// The prove phase attempted 7 proofs between 2026-08 and 2026-10 and proved
+// none; 5 of the 7 provers reported the same thing: vitest is declared in
+// package.json but node_modules is absent from the worktree. A prover agent is
+// an expensive way to run `ls node_modules/.bin`.
+//
+// Usage: node test-runner.mjs <worktreePath>
+// Prints {runner, dirs, reason}. `runner` is the first usable runner found
+// (vitest|jest|mocha|node-test) or null; `dirs` lists every package dir with a
+// usable one as {dir, runner}, relative to the worktree ("." for the root).
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+
+const root = process.argv[2];
+if (!root || !existsSync(root)) {
+  console.log(JSON.stringify({ runner: null, dirs: [], reason: 'no worktree' }));
+  process.exit(0);
+}
+
+const RUNNERS = ['vitest', 'jest', 'mocha'];
+
+function packageDirs(dir, depth) {
+  const out = existsSync(join(dir, 'package.json')) ? [dir] : [];
+  if (depth === 0) return out;
+  let entries;
+  try { entries = readdirSync(dir); } catch { return out; }
+  for (const e of entries) {
+    if (e === 'node_modules' || e.startsWith('.')) continue;
+    const p = join(dir, e);
+    try { if (statSync(p).isDirectory()) out.push(...packageDirs(p, depth - 1)); } catch { /* unreadable */ }
+  }
+  return out;
+}
+
+function usableRunner(dir) {
+  let pkg;
+  try { pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')); } catch { return { reason: 'unreadable package.json' }; }
+  const declared = { ...pkg.dependencies, ...pkg.devDependencies };
+  const testScript = String(pkg.scripts?.test ?? '');
+  for (const r of RUNNERS) {
+    if (!declared[r] && !testScript.includes(r)) continue;
+    // existsSync follows the symlinked node_modules setup-worktree.sh creates.
+    for (let binDir = resolve(dir); ; binDir = dirname(binDir)) {
+      if (existsSync(join(binDir, 'node_modules', '.bin', r))) return { runner: r };
+      if (binDir === resolve(root) || dirname(binDir) === binDir) break;
+    }
+    return { reason: `${r} declared but node_modules/.bin/${r} missing` };
+  }
+  if (/\bnode\b[^&|;]*--test\b/.test(testScript)) return { runner: 'node-test' };
+  return { reason: 'no test runner declared' };
+}
+
+const dirs = [];
+const reasons = [];
+let runner = null;
+for (const dir of packageDirs(root, 3)) {
+  const rel = relative(root, dir) || '.';
+  const r = usableRunner(dir);
+  if (r.runner) {
+    dirs.push({ dir: rel, runner: r.runner });
+    runner ??= r.runner;
+  } else {
+    reasons.push(`${rel}: ${r.reason}`);
+  }
+}
+
+console.log(JSON.stringify({
+  runner,
+  dirs,
+  reason: runner ? null : (reasons.length ? reasons.join('; ') : 'no package.json'),
+}));

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

@@ -450,6 +450,7 @@ const {
   targetLabel: targetLabelArg,
   engine: engineArg,
   findingsFile,
+  testRunner,
 } = input
 
 // 'revmux' skips straight to Prove on pre-computed findings, so Prove's
@@ -866,7 +867,9 @@ const budgetAtStart = budget.spent()
   // with no runtime failure to demonstrate), attempt to produce an
   // executable failing test in the worktree. Only runs with a worktree and
   // outside scan depth, and is capped so a pathological finding count can't
-  // blow the budget.
+  // blow the budget. `testRunner` comes from worktree.json: without a runner
+  // whose binary is installed a prover cannot run its test, which is how 5 of
+  // the first 7 proof attempts failed.
   // -------------------------------------------------------------------------
 
   function proverPrompt(finding) {
@@ -876,6 +879,8 @@ const budgetAtStart = budget.spent()
       `Read and follow ${promptDir}/prover.md.`,
       `FINDING (JSON): ${JSON.stringify(finding)}.`,
       `DIFF_FILE=${diffFile}, CONTEXT_FILE=${contextFile}, WORKTREE_PATH=${worktreePath}.`,
+      `TEST_RUNNER per package (JSON; dirs relative to WORKTREE_PATH): ${JSON.stringify(testRunner.dirs || [])}.`,
+      `Use the runner paired with the most specific package dir containing the finding.`,
       `You get ONE attempt. Leave the worktree exactly as you found it.`,
     ].join(' ')
   }
@@ -884,8 +889,15 @@ const budgetAtStart = budget.spent()
     const proveCandidates = finalFindings.filter(function(f) {
       return shouldProve(f) && !isHardRule(f)
     })
+    const hasRunner = Boolean(testRunner && testRunner.runner)
 
-    if (proveCandidates.length > 0) {
+    if (proveCandidates.length > 0 && !hasRunner) {
+      const reason = 'no runnable test runner: ' + ((testRunner && testRunner.reason) || 'testRunner not passed')
+      for (const f of proveCandidates) {
+        f.proof = { attempted: false, proven: false, outcome: 'not_attempted', reason: reason }
+      }
+      log(`Prove: skipped ${proveCandidates.length} finding(s), ${reason}`)
+    } else if (proveCandidates.length > 0) {
       phase('Prove')
 
       const capped = proveCandidates.slice(0, 5)

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.58.0",
+  "version": "1.59.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.58.0",
+  "version": "1.59.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.58.0",
+  "version": "1.59.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.58.0",
+  "version": "1.59.0",
   "author": {
     "name": "Oleg Koval"
   },