great-cto 3.60.0 → 3.62.0

package/board/scripts/hooks/auto-attach-reviewers.mjs

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+/**
+ * SessionStart hook — auto-attach reviewers.
+ *
+ * Scans git diff since the last session and emits a list of reviewers that
+ * should be invoked for the changed files. Writes a short markdown block to
+ * stdout that the SessionStart bash hook pipes into Claude's context.
+ *
+ * Why this exists
+ * ---------------
+ * In real sessions, users dispatch Agent calls with
+ * `subagent_type: general-purpose` and never invoke the 24 specialist
+ * reviewers — even when migrations / auth / payment code changed.
+ * This hook makes the right reviewers visible at session start, so Claude
+ * picks the matching `subagent_type` proactively without `/start`.
+ *
+ * Pattern-to-reviewer map below. Add patterns conservatively — over-firing
+ * burns context. Default: emit only if diff > 0 files match a pattern.
+ *
+ * Exit codes: 0 always. Silent if no matches or no .great_cto dir.
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { adaptiveSpecialistPlan, planNotice } from '../lib/specialist-plan.mjs';
+
+const cwd = process.cwd();
+const greatCtoDir = join(cwd, ".great_cto");
+
+// Imports expose rules without exiting the caller outside a project.
+
+// Pattern → reviewer mapping. Ordered specific-first.
+// Each pattern is matched against the changed-file paths via simple substring.
+// `match` may be a function returning a count of matched files.
+// EXCLUDE (below) drops every `.md` path, so a rule token that can only match a
+// markdown file can never fire. Three did: `EVAL-.*\.md$`, `ssp\.md`, and an
+// `.api.md` token — removed rather than left as rules that read as coverage.
+// `tests/eval/` already routes the eval files that are not excluded for another
+// reason. The test `no rule can only match an excluded path` keeps this true.
+export const RULES = [
+  { reviewer: "db-migration-reviewer",   pattern: /(migrations\/|schema\.sql$|alembic\/|knex\/migrations|prisma\/migrations|\.room\.|Migration\d+\.kt$|Migration\d+\.swift$)/i,
+    cases: {
+      match: ["db/migrations/0007_add_index.sql", "prisma/migrations/20260801_init/migration.sql", "app/Migration12.kt"],
+      noMatch: ["src/db/query.ts", "docs/schema-notes.txt"],
+    } },
+  { reviewer: "pci-reviewer",            pattern: /(stripe|webhook.*sig|payment|refund|paypal|adyen|braintree|saq-a|pci-dss)/i,
+    cases: {
+      match: ["src/billing/stripe-webhook.ts", "api/refund.ts", "lib/adyen-client.ts"],
+      noMatch: ["src/user/profile.ts", "tests/fixtures/cart.json"],
+    } },
+  { reviewer: "security-officer",        pattern: /(auth\/|oauth|saml|jwt|password|login|session|csrf|cors\.|crypto\.|secret)/i,
+    cases: {
+      match: ["src/auth/session.ts", "api/oauth-callback.ts", "lib/jwt-verify.ts"],
+      noMatch: ["src/ui/button.tsx", "docs/onboarding.txt"],
+    } },
+  { reviewer: "ai-security-reviewer",    pattern: /(prompts?\/|system_prompt|tool_definitions|rag|embeddings?\/|jailbreak)/i,
+    cases: {
+      match: ["prompts/system.txt", "src/rag/retriever.ts", "lib/embeddings/index.ts"],
+      noMatch: ["src/api/users.ts"],
+    } },
+  { reviewer: "ai-eval-engineer",        pattern: /(tests\/eval\/|golden_set|prompt_regression)/i,
+    cases: {
+      match: ["tests/eval/runner.mjs", "data/golden_set.jsonl"],
+      noMatch: ["tests/unit/parser.test.ts"],
+    } },
+  { reviewer: "mobile-store-reviewer",   pattern: /(play[_-]?store|app[_-]?store|fastlane|iap|in_app_purchase|store_listing|aab$|ipa$)/i,
+    cases: {
+      match: ["fastlane/Fastfile", "ios/iap-manager.swift", "build/app.aab"],
+      noMatch: ["src/api/client.ts"],
+    } },
+  { reviewer: "api-platform-reviewer",   pattern: /(openapi\.|swagger|graphql\.schema|webhooks?\.|rfc7807|sunset_header)/i,
+    cases: {
+      match: ["api/openapi.yaml", "src/webhooks.ts", "schema/graphql.schema"],
+      noMatch: ["src/db/pool.ts"],
+    } },
+  { reviewer: "voice-ai-reviewer",       pattern: /(twilio|vonage|livekit|deepgram|elevenlabs|ivr|tcpa|stir.shaken)/i,
+    cases: {
+      match: ["integrations/twilio-handler.ts", "src/ivr/menu.ts", "lib/deepgram-stream.ts"],
+      noMatch: ["src/audio/player.ts"],
+    } },
+  { reviewer: "hr-ai-reviewer",          pattern: /(aedt|ny.?city.?ll.?144|resume_screen|hiring|interview_ai)/i,
+    cases: {
+      match: ["src/hiring/rank.ts", "lib/resume_screen.py"],
+      noMatch: ["src/hr/payroll.ts"],
+    } },
+  { reviewer: "edtech-reviewer",         pattern: /(coppa|ferpa|student[_-]?(data|pii)|sopipa)/i,
+    cases: {
+      match: ["src/coppa-consent.ts", "lib/student_data.py"],
+      noMatch: ["src/course/player.tsx"],
+    } },
+  { reviewer: "gov-reviewer",            pattern: /(fedramp|nist.?800.?53|cjis|fips.?140|fisma|vpat)/i,
+    cases: {
+      match: ["config/fedramp-boundary.yaml", "src/fisma-controls.ts"],
+      noMatch: ["src/gov/ui.tsx"],
+    } },
+  { reviewer: "game-reviewer",           pattern: /(loot[_-]?box|esrb|pegi|iarc|gacha)/i,
+    cases: {
+      match: ["src/loot_box.ts", "config/esrb.json"],
+      noMatch: ["src/game/physics.ts"],
+    } },
+  // general.?ledger / \bgaap\b appended for accounting-vertical coverage — there is no
+  // dedicated accounting-reviewer agent (only project-auditor, which is unrelated), so
+  // core accounting-controls signals route to the SOX-ITGC surface enterprise-saas-reviewer
+  // already owns. "1099"/"e-file" deliberately excluded: too loose as bare substrings
+  // (collide with port numbers, filenames, version strings) without a path anchor.
+  { reviewer: "enterprise-saas-reviewer",pattern: /(scim|tenant_id|row.?level.?security|sso\/|saml\/|sox.itgc)/i,
+    cases: {
+      match: ["src/scim/provision.ts", "db/row-level-security.sql", "src/sso/handler.ts"],
+      noMatch: ["src/ui/table.tsx"],
+    } },
+  // procurement-reviewer: purchasing / source-to-pay tokens only — deliberately avoids
+  // bare "purchase"/"order"/"vendor" (each collides with e-commerce/checkout code).
+  // Each token below is a procurement-specific compound or acronym:
+  //   purchase.?order       — the PO artifact itself, requires the compound
+  //   three.?way.?match     — the PO/receipt/invoice reconciliation control, unambiguous
+  //   \brfp\b               — Request for Proposal (word-boundaried: short acronym)
+  //   \bofac\b              — sanctions-screening authority (word-boundaried)
+  //   punchout               — e-procurement catalog-launch protocol, unambiguous
+  //   cxml                   — the punchout XML dialect name, unambiguous
+  //   requisition            — procurement-specific request artifact (not generic "request")
+  { reviewer: "procurement-reviewer",    pattern: /(purchase.?order|three.?way.?match|\brfp\b|\bofac\b|punchout|cxml|requisition)/i,
+    cases: {
+      match: ["src/purchase-order.ts", "lib/punchout.ts"],
+      noMatch: ["src/store/cart.ts"],
+    } },
+  // accounting-reviewer: bookkeeping / GL / close-cycle tokens — MOVED from
+  // enterprise-saas-reviewer (was a stop-gap before this reviewer existed, see
+  // great_cto-k0uf). general.?ledger and \bgaap\b now route here exclusively so
+  // accounting signals hit the domain-correct reviewer instead of the generic
+  // enterprise-controls one.
+  { reviewer: "accounting-reviewer",     pattern: /(asc.?606|journal.?entry|general.?ledger|\bgaap\b|1099|month.?end.?close|chart.?of.?accounts)/i,
+    cases: {
+      match: ["src/journal-entry.ts", "lib/general-ledger.ts"],
+      noMatch: ["src/reports/chart.tsx"],
+    } },
+  // msp-reviewer: managed-service-provider / RMM-PSA tokens only — deliberately avoids
+  // bare "tenant"/"service" (both collide with generic SaaS/microservice code; tenant_id
+  // already belongs to enterprise-saas-reviewer above). Each token below is MSP-specific:
+  //   \bmsa\b / \bsla\b     — Master Service Agreement / Service Level Agreement acronyms
+  //                           (word-boundaried: both are short and common as substrings)
+  //   \brmm\b / \bpsa\b     — Remote Monitoring & Management / Professional Services
+  //                           Automation, the two dominant MSP tool categories
+  //   multi.?tenant         — MSP cross-client blast-radius framing (distinct from
+  //                           enterprise-saas-reviewer's bare "tenant_id" data-isolation signal)
+  //   managed.?service      — "managed service provider" / "managed services", unambiguous
+  //   credential.?vault     — MSP's core liability surface (client credential storage)
+  { reviewer: "msp-reviewer",            pattern: /(\bmsa\b|\bsla\b|\brmm\b|\bpsa\b|multi.?tenant|managed.?service|credential.?vault)/i,
+    cases: {
+      match: ["src/rmm-agent.ts", "lib/credential-vault.ts"],
+      noMatch: ["src/ui/nav.tsx"],
+    } },
+  // tax-reviewer: tax-prep / IRS e-file tokens only — deliberately avoids bare "tax"
+  // (collides with sales-tax/tax-rate code in commerce/pci contexts) and bare "irs"
+  // alone as unanchored substring was considered too loose; each token below is a
+  // tax-prep-specific compound or acronym:
+  //   \bptin\b              — Preparer Tax Identification Number (word-boundaried)
+  //   circular.?230         — IRS preparer-practice regulations, unambiguous
+  //   form.?8879            — the e-file signature authorization form number
+  //   \bmef\b               — Modernized e-File, the IRS e-file system (word-boundaried:
+  //                           short acronym)
+  //   pub.?4557             — IRS Publication 4557 (taxpayer data safeguards)
+  //   section.?7216         — IRC §7216 consent-to-disclose statute
+  //   tax.?prep              — "tax prep"/"tax preparation", the domain itself
+  { reviewer: "tax-reviewer",            pattern: /(\bptin\b|circular.?230|form.?8879|\bmef\b|pub.?4557|section.?7216|tax.?prep)/i,
+    cases: {
+      match: ["src/form-8879.ts", "lib/tax-prep.py"],
+      noMatch: ["src/finance/invoice.ts"],
+    } },
+  { reviewer: "insurance-reviewer",      pattern: /(naic|solvency|ifrs.?17|acord|actuarial)/i,
+    cases: {
+      match: ["src/naic-filing.ts", "lib/actuarial-model.py"],
+      noMatch: ["src/policy/ui.tsx"],
+    } },
+  // legal-reviewer: legal-services / legal-tech domain tokens only — deliberately
+  // avoids bare "legal"/"law"/"case"/"trust" (each collides with generic code:
+  // "legal" appears in license headers, "law" in unrelated words, "case" in
+  // switch/test-case terminology, "trust" in security/crypto trust-boundary code).
+  // Each token below is a domain-specific signal:
+  //   iolta                — Interest on Lawyers' Trust Accounts, the client-trust
+  //                          accounting regime; unambiguous legal-practice term
+  //   trust.?account        — trust-accounting artifact, requires the compound so
+  //                          bare "trust" (crypto/security) doesn't match
+  //   matter.?number        — legal "matter" identifier; requires the compound so
+  //                          bare "matter" (generic English word) doesn't match
+  //   conflict.?check       — conflict-of-interest screening, legal-ethics specific
+  //   \bpacer\b             — federal court public e-filing system (word-boundaried:
+  //                          avoids matching inside unrelated identifiers)
+  //   \becf\b               — Electronic Case Filing (word-boundaried: "ecf" alone
+  //                          is short enough to risk false positives without \b)
+  //   \bcm\/ecf\b           — CM/ECF, the federal court e-filing platform name
+  //   retainer.?agreement   — engagement/retainer contract, legal-practice specific
+  //   attorney.?client      — attorney-client privilege, unambiguous legal-ethics term
+  //   \bupl\b               — Unauthorized Practice of Law, word-boundaried (short token)
+  //   docket                — court docket / case-management term, legal-specific
+  { reviewer: "legal-reviewer",          pattern: /(iolta|trust.?account|matter.?number|conflict.?check|\bpacer\b|\becf\b|\bcm\/ecf\b|retainer.?agreement|attorney.?client|\bupl\b|docket)/i,
+    cases: {
+      match: ["src/iolta-ledger.ts", "lib/conflict-check.ts", "src/docket-sync.ts"],
+      noMatch: ["src/legal/ui.tsx"],
+    } },
+  // healthcare-reviewer: HIPAA/PHI/clinical-transport tokens only — deliberately
+  // avoids bare "health"/"care"/"claim" (collide with insurance, wellness apps,
+  // generic support-ticket code). Each token below is a domain-specific signal:
+  //   hipaa            — the statute itself
+  //   phi[_-]           — Protected Health Information as an identifier/var prefix
+  //                       (require the separator so it doesn't match unrelated "phi" substrings)
+  //   hl7 / fhir        — the two dominant clinical-data transport standards
+  //   hitech            — HIPAA's breach-notification amendment
+  //   \bbaa\b           — Business Associate Agreement (word-boundaried: "baa" alone
+  //                       is a common false-positive token otherwise)
+  //   (^|\/)ehr\/       — electronic-health-record integration directories (Epic/Cerner/
+  //                       athenahealth); path-anchored so it doesn't match inside unrelated
+  //                       words like "behr" or "cheerful"
+  //   superbill         — clinical billing artifact, healthcare-specific (not "invoice")
+  //   icd-?10           — the diagnosis coding standard
+  //   soap.?note        — clinical documentation format (Subjective/Objective/Assessment/Plan)
+  //   cdt-?code         — Current Dental Terminology billing code (dental-specific,
+  //                       parallels icd-?10 for the dental vertical)
+  //   odontogram        — dental charting artifact (tooth-by-tooth condition map),
+  //                       unambiguous dental-clinical term
+  //   perio-chart       — periodontal charting artifact, dental-specific
+  //   dental.?claim      — dental insurance claim, requires the compound so bare
+  //                       "claim" (generic/insurance-collision) doesn't match
+  { reviewer: "healthcare-reviewer",     pattern: /(hipaa|phi[_-]|hl7|fhir|hitech|\bbaa\b|(^|\/)ehr\/|superbill|icd-?10|soap.?note|cdt-?code|odontogram|perio-chart|dental.?claim)/i,
+    cases: {
+      match: ["src/hipaa-audit.ts", "integrations/fhir/client.ts", "src/soap-note.ts"],
+      noMatch: ["src/patient/avatar.tsx"],
+    } },
+  // rcm-reviewer: medical-billing / revenue-cycle tokens only — deliberately excludes
+  // bare "claim" (generic/insurance-collision, already avoided by healthcare-reviewer's
+  // "dental.?claim" compound) and bare "modifier"/"denial" (too generic on their own).
+  // "icd-?10" and "superbill" stay on healthcare-reviewer (clinical/chart surface);
+  // the tokens below are billing/claims-submission specific:
+  //   cms-?1500 / ub-?04    — the professional/institutional claim form names
+  //   hcpcs                 — HCPCS Level II billing code set
+  //   \b835\b               — ERA remittance transaction number (word-boundaried:
+  //                           short numeric token needs a boundary to avoid false hits)
+  //   remittance.?advice    — the 835's plain-English name
+  //   prior.?auth           — prior-authorization workflow, billing-specific compound
+  //   denial.?code          — CARC/RARC denial-code workflow, requires the compound so
+  //                           bare "denial" doesn't fire on unrelated rejection/reject code
+  //   npi\b                 — National Provider Identifier (word-boundaried)
+  { reviewer: "rcm-reviewer",            pattern: /(cms-?1500|ub-?04|hcpcs|\b835\b|remittance.?advice|prior.?auth|denial.?code|npi\b)/i,
+    cases: {
+      match: ["src/cms-1500.ts", "lib/prior-auth.ts", "src/denial-code-map.ts"],
+      noMatch: ["src/billing/ui.tsx"],
+    } },
+  // regulated-reviewer: DORA/NIS2/ISO27001 only — its other two frameworks (SOX ITGC,
+  // HIPAA) are already claimed by enterprise-saas-reviewer's `sox.itgc` and the
+  // healthcare-reviewer pattern above respectively, so re-adding those tokens here
+  // would double-attach two reviewers on the same file for no added signal. DORA/NIS2/
+  // ISO27001 are regulated-reviewer's exclusive surface — no other rule covers them.
+  { reviewer: "regulated-reviewer",      pattern: /(\bdora\b|dora.?ict|nis2|iso.?27001)/i,
+    cases: {
+      match: ["config/dora-ict-register.yaml", "src/nis2-controls.ts"],
+      noMatch: ["src/app/main.ts"],
+    } },
+  { reviewer: "infra-reviewer",          pattern: /(\.tf$|terraform\/|helm\/|kustomize\/|cdk\/|pulumi\/|\.bicep$)/i,
+    cases: {
+      match: ["infra/main.tf", "helm/values.yaml", "cdk/stack.ts"],
+      noMatch: ["src/server.ts"],
+    } },
+  { reviewer: "web-store-reviewer",      pattern: /(manifest\.json$|mv3|chrome_extension|firefox_addon)/i,
+    cases: {
+      match: ["extension/manifest.json", "src/mv3-worker.ts"],
+      noMatch: ["package.json"],
+    } },
+  { reviewer: "performance-engineer",    pattern: /(perf|p99|latency_budget|k6\/|locust\/|gatling\/|benchmark)/i,
+    cases: {
+      match: ["tests/k6/load.js", "src/perf-budget.ts", "bench/benchmark.ts"],
+      noMatch: ["src/ui/form.tsx"],
+    } },
+  // This rule never fired. It required a manifest name AND the word "version" or
+  // "public api" in the SAME string, but the string it is tested against is a
+  // FILE PATH — no path contains both, so library-reviewer was never attached to
+  // anything since the rule was written. The `version` half was written as if it
+  // would see the diff.
+  //
+  // Bare `package.json` is deliberately not a trigger: every project has one, and
+  // a reviewer that attaches to everything is one people learn to ignore. What is
+  // matched instead are the manifests and artifacts that only a PUBLISHED library
+  // has — a declared public API surface, or a packaging manifest for an ecosystem
+  // where the file's presence already implies distribution.
+  { reviewer: "library-reviewer",        pattern: /(api-extractor\.json|(^|\/)(pyproject\.toml|Cargo\.toml|setup\.py|go\.mod)$|\.npmignore$)/i,
+    cases: {
+      match: ["Cargo.toml", "pyproject.toml", "sdk/api-extractor.json", "go.mod"],
+      noMatch: ["package.json", "src/index.ts"],
+    } },
+  { reviewer: "cli-reviewer",            pattern: /(bin\/|cli\/main|argv|exit.?code)/i,
+    cases: {
+      match: ["bin/great-cto", "src/cli/main.ts", "lib/argv-parse.ts"],
+      noMatch: ["src/server/routes.ts"],
+    } },
+  // Building an MCP server, not consuming one: `.mcp.json` and `.playwright-mcp/`
+  // are what USING a server leaves behind, and neither is ours to review.
+  { reviewer: "mcp-server-reviewer",     pattern: /(mcp[-_]servers?[/.]|[/.]mcp[-_]server\.|(^|\/)mcp\.(ts|js|mjs|py)$|modelcontextprotocol)/i,
+    cases: {
+      match: ["mcp-servers/llm-router/server.py", "src/mcp.ts", "lib/modelcontextprotocol-adapter.ts"],
+      noMatch: [".mcp.json", ".playwright-mcp/session.json"],
+    } },
+];
+
+// Known limit, found by giving every rule its own cases: `^docs/` and `\.md$`
+// are excluded wholesale, so a compliance artefact that lives as a document —
+// a FedRAMP boundary, a DORA ICT register, a system prompt in markdown — never
+// reaches gov-reviewer, regulated-reviewer or ai-security-reviewer. Those rules
+// fire only on config and source. Widening EXCLUDE would make every rule fire on
+// every doc, so it is recorded here rather than changed in passing.
+//
+// Files we deliberately ignore for reviewer routing — these are metadata,
+// templates, or test fixtures whose path matches a pattern by accident but
+// they're not actual product code that needs review.
+const EXCLUDE = [
+  /^tests\/fixtures\//,        // fixtures for our own tests
+  /^docs\//,                   // analysis docs, ADRs, marketing
+  /^commands\//,               // slash-command definitions
+  /^agents\//,                 // agent prompt files (great_cto-repo only)
+  /^skills\/great_cto\//,      // plugin skill files
+  /^\.claude\//,               // claude config
+  /\.md$/,                     // any markdown — docs talking about X ≠ doing X
+  /^node_modules\//,
+  /^\.git\//,
+  // What USING an MCP server leaves behind, not code we wrote. The
+  // mcp-server-reviewer rule already says these are not ours to review; they
+  // were still reaching every OTHER rule, and `.playwright-mcp/session.json`
+  // matched security-officer's `session` token on every run that used the
+  // browser. A reviewer flagged by a tool's own cache file is noise, and noise
+  // is what teaches people to skim the reviewer list.
+  /^\.playwright-mcp\//,
+  /^\.mcp\.json$/,
+];
+
+export function shouldExclude(path) {
+  return EXCLUDE.some(rx => rx.test(path));
+}
+
+// Get changed files since last session.
+// Strategy: files touched in the last 7 days (broader than `since last commit`,
+// captures uncommitted edits + recent work). Falls back to last 50 commits.
+function getChangedFiles() {
+  try {
+    // execFileSync, not execSync: no shell at all. Nothing here is interpolated
+    // today, but this runs on EVERY tool use, and a hook that builds a command
+    // as a string is one careless edit away from running whatever a path
+    // contains. `sort -u` was the only reason a shell was needed; a Set does it.
+    const recent = execFileSync(
+      "git", ["log", "--since=@{7.days.ago}", "--name-only", "--pretty=format:"],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).split("\n").filter(Boolean);
+    // Plus currently uncommitted
+    const uncommitted = execFileSync("git", ["status", "--porcelain"], {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"]
+    }).split("\n").map(l => l.slice(3)).filter(Boolean);
+    return [...new Set([...recent, ...uncommitted])];
+  } catch {
+    return [];
+  }
+}
+
+// Read verdicts log to skip reviewers that have ALREADY run recently on these files.
+// Conservative: dedupe by reviewer name + day. If a reviewer ran in the last 24h,
+// don't re-flag it.
+function recentlyInvokedReviewers() {
+  try {
+    // log-verdict.sh writes to the PROJECT-local .great_cto/verdicts/ — read
+    // that first; the HOME-level dir only exists if a global aggregator syncs
+    // logs there. Reading only HOME meant the dedupe never fired (bug).
+    const candidateDirs = [
+      join(greatCtoDir, "verdicts"),
+      join(process.env.HOME || "~", ".great_cto", "verdicts"),
+    ];
+    const day24Ago = Date.now() - 24 * 3600 * 1000;
+    const seen = new Set();
+    for (const verdictDir of candidateDirs) {
+      if (!existsSync(verdictDir)) continue;
+      scanVerdictDir(verdictDir, day24Ago, seen);
+    }
+    return seen;
+  } catch {
+    return new Set();
+  }
+}
+
+function scanVerdictDir(verdictDir, day24Ago, seen) {
+  for (const f of readdirSync(verdictDir)) {
+    const fp = join(verdictDir, f);
+    try {
+      const stat = statSync(fp);
+      if (stat.mtimeMs < day24Ago) continue;
+      const lines = readFileSync(fp, "utf8").split("\n").slice(-30);
+      for (const line of lines) {
+        const m = line.match(/\|?\s*([\w-]+-reviewer|security-officer|qa-engineer|architect|pm|senior-dev|devops|l3-support|ai-eval-engineer|ai-prompt-architect)\s*\|/);
+        if (!m) continue;
+        // Lines start with an ISO-8601 UTC timestamp (verdict-format.md).
+        // Compare it against the 24h window instead of matching a calendar
+        // date string (the old check only matched yesterday's date, so
+        // verdicts written today were never deduped).
+        const ts = Date.parse(line.split(" ")[0]);
+        if (!Number.isNaN(ts) && ts >= day24Ago) seen.add(m[1]);
+      }
+    } catch { /* skip unreadable */ }
+  }
+}
+
+function main() {
+  if (!existsSync(greatCtoDir)) process.exit(0);
+  const plan = adaptiveSpecialistPlan(cwd, RULES);
+  if (plan) { console.log(planNotice(plan)); return; }
+  const files = getChangedFiles();
+  if (files.length === 0) process.exit(0);
+
+  const recent = recentlyInvokedReviewers();
+  const matches = new Map();  // reviewer → [matched files]
+
+  // Filter out fixtures/docs/templates — they accidentally match patterns
+  // but don't represent product code that needs review.
+  const productFiles = files.filter(f => !shouldExclude(f));
+  if (productFiles.length === 0) process.exit(0);
+
+  for (const rule of RULES) {
+    if (recent.has(rule.reviewer)) continue;
+    const matchedFiles = productFiles.filter(f => rule.pattern.test(f));
+    if (matchedFiles.length === 0) continue;
+    matches.set(rule.reviewer, matchedFiles);
+  }
+
+  if (matches.size === 0) process.exit(0);
+
+  // Cap output: emit at most 5 reviewers (most-matched first), summarize rest.
+  const sorted = [...matches.entries()].sort((a, b) => b[1].length - a[1].length);
+  const top = sorted.slice(0, 5);
+  const overflow = sorted.slice(5);
+
+  console.log("\n📋 REVIEWERS FLAGGED — match `subagent_type` to changed files");
+  for (const [reviewer, mf] of top) {
+    const preview = mf.slice(0, 2).join(", ");
+    const extra = mf.length > 2 ? ` (+${mf.length - 2})` : "";
+    console.log(`  • ${reviewer} — ${preview}${extra}`);
+  }
+  if (overflow.length > 0) {
+    console.log(`  • +${overflow.length} more: ${overflow.map(([r]) => r).join(", ")}`);
+  }
+  console.log(`  Use: Agent({ subagent_type: "<reviewer>", description, prompt })`);
+}
+
+// Guarded so reviewer-nudge.mjs can import RULES/shouldExclude without running the scan.
+import { fileURLToPath } from "node:url";
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) main();

package/board/scripts/lib/adaptive-benchmark-collector.mjs

@@ -0,0 +1,202 @@
+/** Read-only operator-pinned observation collection, not provider attestation. */
+import { lstatSync, realpathSync, openSync, fstatSync, readSync, closeSync, constants } from 'node:fs';
+import { resolve, relative, isAbsolute, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { describeMatchedObservations } from './adaptive-benchmark-protocol.mjs';
+import { dispatchEvidenceSummary } from './controller-dispatch-evidence.mjs';
+import { treeReceipt } from './receipt.mjs';
+import { scorerAuthority, verifyScorerReport } from './benchmark-scorer-signature.mjs';
+import { baselineInputDigest, readPinnedScorerOracle } from './pinned-benchmark-scorer.mjs';
+import { assertBenchmarkReviewDispatches } from './benchmark-review-dispatch.mjs';
+
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const digest = value => hash(JSON.stringify(value));
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const mandatory = ['code-reviewer', 'qa-engineer', 'security-officer'];
+const hex = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+function document(raw, label) {
+  try { return JSON.parse(raw); }
+  catch { throw Error(`invalid benchmark ${label} JSON`); } // Never echo private input bytes.
+}
+
+export function benchmarkPolicySnapshot(state, { entry = state.queue[0] } = {}) {
+  // Stand-down audit grows during execution; it is not a policy configuration.
+  const gatePolicy = state.gatePolicy ? { ...state.gatePolicy } : null;
+  if (gatePolicy) delete gatePolicy.skipped;
+  return structuredClone({ graphHash: state.graphHash, allowed: state.allowed, intent: state.intent,
+    entry, hostRoutes: state.hostRoutes || {}, maxAttempts: state.maxAttempts,
+    checkPolicy: state.checkPolicy || null, gatePolicy, executionBudget: state.executionBudget || null,
+    specialistPolicy: state.specialistPolicy || null });
+}
+
+function registrationIdentity(registration) {
+  const { protocol, trial } = registration || {};
+  describeMatchedObservations(protocol, []); // Checks the entire registered protocol digest.
+  const block = protocol.blocks.find(b => b.task === trial?.task && b.repetition === trial?.repetition);
+  if (registration.version !== 1 || !block || !['legacy', 'adaptive'].includes(trial.arm)
+    || typeof registration.scorer?.id !== 'string' || !registration.scorer.id.trim() || !hex(registration.scorer.sha256)
+    || !Array.isArray(registration.requiredRoles) || registration.requiredRoles.some(r => typeof r !== 'string' || !r)
+    || new Set(registration.requiredRoles).size !== registration.requiredRoles.length
+    || mandatory.some(r => !registration.requiredRoles.includes(r))) throw Error('invalid benchmark trial registration or mandatory roles');
+  const scenario = protocol.scenarios.find(s => s.id === block.task);
+  scorerAuthority(registration.scorer);
+  return { registrationDigest: digest(registration), protocolDigest: protocol.digest,
+    task: block.task, repetition: block.repetition, arm: trial.arm,
+    specificationDigest: block.specificationDigest, acceptanceDigest: block.acceptanceDigest,
+    artifact: protocol.artifacts[trial.arm], policyDigest: digest(protocol.policies[trial.arm]),
+    scorer: registration.scorer, requiredRoles: registration.requiredRoles, scenario };
+}
+
+/** Called only on a newly constructed controller state, before its first dispatch. */
+export function bindBenchmarkTrial(state, registration) {
+  if (state.benchmarkBinding || state.status !== 'ready' || state.active || state.steps !== 0
+    || state.attempts.length || state.approvals.length || state.dispatchEvidence?.records.length
+    || state.releasePolicy) throw Error('benchmark binding requires a fresh no-release run');
+  const identity = registrationIdentity(registration);
+  if (state.prompt !== identity.scenario.task || !same(state.acceptance, identity.scenario.checks)
+    || digest(benchmarkPolicySnapshot(state)) !== identity.policyDigest) throw Error('benchmark task, criteria or policy differs from registration');
+  const initialReceipt = treeReceipt(state.root);
+  if (!initialReceipt || initialReceipt.truncated) throw Error('benchmark requires a readable complete initial Git receipt');
+  state.benchmarkBinding = structuredClone({ ...identity, initialReceipt });
+  return state.benchmarkBinding;
+}
+
+function outside(root, file) {
+  const rel = relative(root, realpathSync(file));
+  if (!rel || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))) throw Error('benchmark evidence must be external to the worker project');
+}
+
+function boundedFile(file, { privateFile = true, maxBytes = 65536 } = {}) {
+  const path = resolve(file);
+  if (realpathSync(path) !== path || lstatSync(path).isSymbolicLink()) throw Error('unsafe noncanonical benchmark evidence path');
+  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0) | (constants.O_NONBLOCK || 0));
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile() || (privateFile && (info.mode & 0o077)) || info.size > maxBytes) throw Error('unsafe or oversized bounded benchmark evidence file');
+    // Allocate only the observed bounded size; one extra byte detects growth.
+    const bytes = Buffer.alloc(info.size + 1); let used = 0, count;
+    while (used < bytes.length && (count = readSync(fd, bytes, used, bytes.length - used, null)) > 0) used += count;
+    if (used > info.size) throw Error('benchmark evidence grew during bounded read');
+    const raw = bytes.subarray(0, used);
+    return { raw, sha256: hash(raw) };
+  } finally { closeSync(fd); }
+}
+
+function externalFile(root, file, options) {
+  outside(root, file);
+  return boundedFile(file, options);
+}
+export function privateBenchmarkEvidence(root, file) { return externalFile(root, file); }
+
+export function readBenchmarkRegistration(root, file) {
+  const evidence = externalFile(realpathSync(root), file);
+  const registration = document(evidence.raw, 'registration');
+  registrationIdentity(registration);
+  return registration;
+}
+
+function assertArtifacts(state) {
+  for (const [name, expected] of Object.entries(state.writes || {})) {
+    if (!name || isAbsolute(name) || name.includes('\\') || name.split('/').some(p => !p || p === '..' || p === '.')) throw Error('invalid benchmark artifact path');
+    const path = resolve(state.root, name), actual = realpathSync(path), info = lstatSync(path);
+    if (actual !== path || !info.isFile() || !state.allowed.some(p => name === p || name.startsWith(`${p}/`))
+      || boundedFile(path, { privateFile: false, maxBytes: 1024 * 1024 }).sha256 !== expected) throw Error('benchmark artifact drift or unsafe path');
+  }
+}
+
+function assertScorable(state, registration, receipt) {
+  if (state.status !== 'done' || state.active || state.pending || state.wave || state.rework || state.queue.length
+    || state.releasePolicy || !receipt || receipt.truncated || !state.attempts.length || !same(state.attempts.at(-1).receipt, receipt)) throw Error('controller is not settled on the scored receipt');
+  assertArtifacts(state);
+  if (state.dispatchEvidence?.records.some(r => !r || r.outcome === 'intent' || !r.finishedAt)) throw Error('unfinished controller invocation cannot be assessed as settled');
+  const required = new Set(registration.requiredRoles);
+  // Do not omit reviewers that the actual adaptive controller selected.
+  for (const role of state.specialistReview?.roles || []) required.add(role);
+  for (const role of required) {
+    const result = state.results[role], attempt = state.attempts.find(a => a.id === result?.attemptId);
+    const observed = state.dispatchEvidence?.records.find(r => r.id === `${attempt?.id}:verifier`);
+    if (!result || !attempt || attempt.role !== role || attempt.status !== 'verified'
+      || result.verification?.state !== 'verified' || !result.verification.checks?.length
+      || attempt.verification?.state !== 'verified' || !same(result.verification, attempt.verification)
+      || observed?.kind !== 'verifier' || observed.outcome !== 'returned') throw Error('missing independently verified required role');
+  }
+  for (const approval of state.approvals) {
+    if (state.results[approval.role]?.digest !== approval.result) throw Error('approval refers to stale result');
+  }
+  assertBenchmarkReviewDispatches(state, [...required]);
+}
+
+/** Shared read-only pre/post execution context; not proof of executing this package. */
+export function benchmarkScoringContext({ registrationFile, stateFile, stateSha256, artifactFile,
+  scorerFile, oracleFile = null }, { settled = false } = {}) {
+  if (!hex(stateSha256)) throw Error('exact state byte pin required');
+  // Root is not trusted until the bounded private state has been parsed and checked.
+  const evidence = boundedFile(stateFile, { maxBytes: 8 * 1024 * 1024 });
+  if (evidence.sha256 !== stateSha256) throw Error('controller state byte pin mismatch');
+  const state = document(evidence.raw, 'state'), root = realpathSync(state.root);
+  if (state.version !== 1 || !state.id || state.root !== root) throw Error('invalid benchmark controller identity');
+  outside(root, stateFile);
+  const registration = readBenchmarkRegistration(root, registrationFile), identity = registrationIdentity(registration);
+  const binding = state.benchmarkBinding;
+  if (!binding || !same({ ...binding, initialReceipt: undefined }, { ...identity, initialReceipt: undefined })
+    || !binding.initialReceipt || state.prompt !== identity.scenario.task || !same(state.acceptance, identity.scenario.checks)) throw Error('controller trial binding mismatch or absent pre-dispatch binding');
+  if (digest(benchmarkPolicySnapshot(state, { entry: registration.protocol.policies[identity.arm].entry })) !== identity.policyDigest) throw Error('controller execution policy drift');
+  const artifact = externalFile(root, artifactFile, { privateFile: false, maxBytes: 100 * 1024 * 1024 });
+  const scorer = externalFile(root, scorerFile, { privateFile: false, maxBytes: 1024 * 1024 });
+  if (artifact.sha256 !== identity.artifact.artifactSha256 || scorer.sha256 !== identity.scorer.sha256) throw Error('package or scorer code pin mismatch');
+  const receipt = treeReceipt(root);
+  let oracle = null;
+  if (identity.scorer.authority) {
+    if (!oracleFile) throw Error('registered signed scorer requires pinned oracle evidence');
+    oracle = readPinnedScorerOracle(root, oracleFile, identity.scorer.oracleSha256);
+    if (oracle.scenario !== identity.task) throw Error('scorer oracle task differs from registered trial');
+  }
+  if (settled) assertScorable(state, registration, receipt);
+  return { state, root, registration, identity, artifact, scorer, receipt, oracle };
+}
+
+/** Binds raw state bytes, package bytes and pinned scorer code to the supplied report. */
+export function collectBenchmarkObservation(options) {
+  const { stateSha256, scoreFile = null, scoreSha256 = null } = options;
+  if (!hex(stateSha256) || (scoreFile && !hex(scoreSha256)) || (!scoreFile && scoreSha256)) throw Error('exact state/score byte pins required');
+  const { state, root, registration, identity, artifact, scorer, receipt, oracle } = benchmarkScoringContext(options);
+  const telemetry = dispatchEvidenceSummary(state);
+  let status = ['blocked', 'cancelled'].includes(state.status) ? (state.status === 'blocked' ? 'blocked' : 'failed') : 'unassessed';
+  let accepted = null, scoreDigest = null, trustedScorerProcessSignatureVerified = false;
+  if (scoreFile) {
+    assertScorable(state, registration, receipt);
+    const score = externalFile(root, scoreFile);
+    if (score.sha256 !== scoreSha256) throw Error('score byte pin mismatch');
+    let report = document(score.raw, 'score');
+    if (identity.scorer.authority) {
+      const payload = verifyScorerReport(report, identity.scorer);
+      if (payload.artifactSha256 !== artifact.sha256 || payload.scorerSha256 !== scorer.sha256
+        || payload.oracleSha256 !== identity.scorer.oracleSha256
+        || payload.candidateInputDigest !== baselineInputDigest(root, Object.keys(oracle.baseline).sort())) throw Error('signed scorer artifact/oracle/input binding mismatch');
+      report = { ...payload, version: 1, source: 'operator-attestation', scorer: identity.scorer };
+      trustedScorerProcessSignatureVerified = true;
+    }
+    if (report.version !== 1 || report.source !== 'operator-attestation' || report.runId !== state.id
+      || report.stateSha256 !== stateSha256 || report.registrationDigest !== identity.registrationDigest
+      || !same(report.scorer, identity.scorer) || !same(report.receipt, receipt)
+      || !Array.isArray(report.criteria) || report.criteria.length !== state.acceptance.length
+      || report.criteria.some((c, i) => c?.text !== state.acceptance[i] || !['passed', 'failed'].includes(c.state)
+        || typeof c.evidence !== 'string' || !c.evidence.trim())) throw Error('independent score report identity/criteria mismatch');
+    status = 'completed'; accepted = report.criteria.every(c => c.state === 'passed'); scoreDigest = score.sha256;
+  }
+  const row = { task: identity.task, repetition: identity.repetition, arm: identity.arm,
+    protocolDigest: identity.protocolDigest, specificationDigest: identity.specificationDigest,
+    acceptanceDigest: identity.acceptanceDigest, artifactSha256: artifact.sha256, status, accepted,
+    activeMs: telemetry.activeMs, workerCalls: telemetry.workerCalls, verifierCalls: telemetry.verifierCalls,
+    humanPauses: null, actionableFindings: null, escapedDefects: null, actualCostUsd: null,
+    evidence: { level: trustedScorerProcessSignatureVerified
+      ? 'trusted-launcher-signed-scorer-and-pinned-controller-not-provider-attested'
+      : 'operator-pinned-controller-and-score-not-provider-attested', runId: state.id,
+      controllerStatus: state.status, stateSha256, registrationDigest: identity.registrationDigest,
+      scorerSha256: scorer.sha256, scoreSha256: scoreDigest, receipt,
+      trustedScorerProcessSignatureVerified,
+      graphFloorCoverageVerified: false, executionArtifactProvenanceVerified: false,
+      benchmarkEligible: false } };
+  describeMatchedObservations(registration.protocol, [row]);
+  return row;
+}