@reneturcios/greenlight 0.15.1 → 0.16.1

package/README.md

@@ -25,11 +25,11 @@ Three layers, from decide to solve to coordinate:
 
 | Layer | Question it answers | Flagship commands |
 |---|---|---|
-| **Decide** | Is this issue mine to take? Is this repo worth my time? | `check`, `scan`, `friction`, `xray`, `preflight` |
+| **Decide** | Is this issue mine to take? Is this repo worth my time? | `check`, `scan`, `friction`, `xray`, `wave`, `preflight` |
 | **Solve** | Will my PR pass? What broke? What do I do next? | `ci-prep`, `ci`, `review`, `brief`, `verify`, `autopilot`, `babysit`, `evidence` |
 | **Coordinate** | Who is working on what, and who resolves conflicts? | `claim` (+ Claim Protocol), `guard`, `radar`, `digest`, `passport` |
 
-* **Decide.** `check` reads an issue, its comments, linked and mentioned PRs (timeline plus search plus comment references), and the repo's rules, then answers in plain words: GO, RISKY, TAKEN, GATED, or STALE. `scan` ranks a repo's open issues so you pick a winnable one first. `friction` scores a repo 0 to 100 on how hard it really is to get a PR merged, with every gate quoting the file its evidence came from. `xray` (Timeline X-Ray) deep-verifies candidates against their issue timelines before you write a line, catching hidden in-flight PRs including reporter-owned fix PRs; `scan --deep` demotes anything taken before it shows you the list.
+* **Decide.** `check` reads an issue, its comments, linked and mentioned PRs (timeline plus search plus comment references), and the repo's rules, then answers in plain words: GO, RISKY, TAKEN, GATED, or STALE. `scan` ranks a repo's open issues so you pick a winnable one first. `friction` scores a repo 0 to 100 on how hard it really is to get a PR merged, with every gate quoting the file its evidence came from. `xray` (Timeline X-Ray) deep-verifies candidates against their issue timelines before you write a line, catching hidden in-flight PRs including reporter-owned fix PRs; `scan --deep` demotes anything taken before it shows you the list. `wave` turns the Agent Policy Index into a build queue in one command: winnable open repos, x-rayed starter issues, behavioral gates excluded.
 * **Solve.** `ci-prep` runs a repo's own pull-request checks locally before you push (tests, lint, typecheck, plus conventions like changesets, commit format, DCO), so avoidable CI failures never appear in front of a maintainer. `ci` triages red PRs into pre-existing vs likely-yours vs external-blocker against base-branch history. `review` classifies every review thread as likely-real, likely-noise, or needs-decision and drafts your replies. `verify` reports the honest red-green test delta of your change. `autopilot` verifies bot findings against the code at head and fixes the mechanical items (DCO surgery, conflict re-merges, formatting) itself. `brief` assembles a verified one-screen brief for any PR: change shape by area and risk, CI triaged against base-branch history, findings classified real vs false-positive with evidence, test evidence present or explicitly marked absent, merge blockers, and a one-line look-at-this-first. `babysit` watches your open PRs and reports one prioritized action list.
 * **Coordinate.** `claim` posts a protocol claim (expiring lease, public queue, heartbeats; full spec in [`protocol/SPEC.md`](protocol/SPEC.md)), with a hosted app client option via `--via-api`. `guard` analyzes an incoming PR for a maintainer: competing fix, prior claims, missing artifacts, first-time contributor. `digest` reports a repo's PR races, claimed-by-other conflicts, stale claims, and assignment-gate conflicts. `radar` scans the whole open-PR queue and clusters competing or duplicate PRs with evidence per cluster and a suggested keep, labeled a heuristic, never a verdict. `passport` renders a contributor's merged work plus claim record.
 
@@ -38,7 +38,7 @@ Every verdict and every report cites its evidence: the quoted policy line, the c
 ## Who it is for
 
 * **Contributors (human).** Run `check` before you spend an evening on an issue. Run `scan` when you are picking what to work on. Run `ci-prep` before you push.
-* **AI agents and coding tools.** One command (`init --agent claude-code`, also cursor, copilot, windsurf, cline) installs the MCP config plus the one behavior rule: check Greenlight before opening a PR. Agents waste the most tokens fixing already-taken issues; 27 MCP tools make the whole engine available mid-run.
+* **AI agents and coding tools.** One command (`init --agent claude-code`, also cursor, copilot, windsurf, cline) installs the MCP config plus the one behavior rule: check Greenlight before opening a PR. Agents waste the most tokens fixing already-taken issues; 28 MCP tools make the whole engine available mid-run.
 * **Maintainers.** `guard` on each incoming PR, `radar` across the whole open queue, `digest` for the weekly triage, and the roadmap below for the control room: stale-claim sweeps, policy enforcement, AI-PR filtering.
 
 ## Proof, stated plainly
@@ -103,7 +103,7 @@ One command sets it up:
 npx @reneturcios/greenlight init --agent claude-code
 ```
 
-(also `cursor`, `copilot`, `windsurf`, `cline`; repeat `--agent` for more than one). Init copies the MCP config into your project and installs the workflow instruction snippet that teaches your agent the one behavior rule: **check Greenlight before it opens a PR.** Prefer doing it by hand? The [`integrations/`](integrations/README.md) drop-in pack has ready-to-copy MCP configs plus the same snippets. Then verify with a "list your MCP tools" prompt; the greenlight server carries 27 tools (see the list below).
+(also `cursor`, `copilot`, `windsurf`, `cline`; repeat `--agent` for more than one). Init copies the MCP config into your project and installs the workflow instruction snippet that teaches your agent the one behavior rule: **check Greenlight before it opens a PR.** Prefer doing it by hand? The [`integrations/`](integrations/README.md) drop-in pack has ready-to-copy MCP configs plus the same snippets. Then verify with a "list your MCP tools" prompt; the greenlight server carries 28 tools (see the list below).
 
 ## CLI
 
@@ -283,12 +283,13 @@ The same engine is exposed over stdio for coding agents (Claude, Cursor, Cline).
 }
 ```
 
-Tools (27):
+Tools (28):
 
 * `check_issue` - verdict for one issue URL
 * `scan_repo` - rank a repo's open issues, GO first (label-tagged starter issues, falling back to recent open unassigned issues; `deep: true` timeline-x-rays the candidates first)
 * `xray_issues` - Timeline X-Ray: deep-verify candidate issues against their timelines (hidden in-flight PRs, reporter-owned fix PRs, comment claims); GO / RISKY / TAKEN per issue with PR evidence
 * `repo_friction` - friction score for a repo
+* `wave_queue` - build queue in one call: filters the Agent Policy Index for winnable open repos, x-rays starter issues (CLEAR / RISKY / TAKEN), excludes behavioral gates, skips repos where you already have an open PR
 * `claim_issue` - verdict-gated claim comment (dry run unless `execute: true`)
 * `prep_issue` - fork and branch check plus a local PREP.md checklist with the repo's learned conventions (dry run unless `execute: true`)
 * `open_pr` - DCO-aware PR opening from a fork branch (dry run unless `execute: true`)
@@ -332,7 +333,11 @@ The verdict engine is deterministic (no LLM) and checks, in order:
 11. An open PR referenced in a non-author comment whose title/body mentions the issue number: downgrades an otherwise-GO verdict to **RISKY** with the `comment-mentioned-pr` flag ("may already cover part of this issue"). Neither can produce **TAKEN**; only closing PRs do that. Fix-announcement comments ("/attempt #N" commands or "Submitted fix for ... in <PR url>" narratives, often linking PRs in sibling repos) get the same downgrade under their own reason quoting the PR URL, with the `attempt-linked-pr` flag, even when the PR never names the issue. `/attempt` comments also register as strong claims.
 12. **Partially-addressed**: merged PRs that reference the issue number (comment-mentioned or linked), or maintainer comments signaling part of the work already shipped ("Half addressed by #905, leaving this open for half B", "Shipped in v3.1.0" next to the issue reference). A plain **GO** hides the scoping work this needs, so the flag `partially-addressed` is added, an otherwise-GO verdict is capped at **RISKY** with a reason like "part of this issue already shipped (PR #905, merged); scope your work to what remains". Never **TAKEN**.
 
-Friction score starts at 100 and subtracts gate weights (assignment -25, vouch -35, collaborators-only -50, paused unsolicited PRs -40, external PRs auto-closed -50, discussion-first -10, claim-first -5, CLA/DCO -5 each), adjusts for external PR merge rate and review/response times when computable, and adds up to +10 for open good-first-issues. Unknown signals stay null and are skipped, never guessed. See `src/friction.ts` for the exact formula.
+Friction score starts at 100 and subtracts gate weights (assignment -25, vouch -35, collaborators-only -50, paused unsolicited PRs -40, external PRs auto-closed -50, discussion-first -10, claim-first -5, CLA/DCO -5 each, detected behavioral gate -20), adjusts for external PR merge rate and review/response times when computable, and adds up to +10 for open good-first-issues. Unknown signals stay null and are skipped, never guessed. See `src/friction.ts` for the exact formula.
+
+A behavioral gate is not a policy file: it is read from what maintainers do. `friction` walks the closed-PR list until it has the 15 most recent closed-unmerged PRs, then reads maintainer-side comments for AI-rejection evidence (AI attribution plus rejection language, explicit phrases like "AI slop" or an invoked "AI policy", with welcoming overrides like "AI-assisted PRs are welcome" suppressing the signal). Two independent PRs mark the repo as behaviorally gated; a single weak signal is carried as a warning, while a single explicit rejection phrase detects on its own. `friction --json` reports it as `behavioral_gate` (`detected`, `strength`, `threshold`, `evidence` with PR numbers, quotes, and URLs, `notes`), so index pipelines like the rebaseline can reclassify repos whose written policy is silent but whose practice is hostile. API cost is bounded at 18 calls: up to 3 list calls to collect 15 closed-unmerged PRs plus one comment page per PR; skip it with `--no-behavioral`.
+
+`wave` turns the Agent Policy Index into a build queue in one command: pure-open repos with outsider merge share, star band, and starter issues are x-rayed with the existing xray engine (CLEAR / RISKY / TAKEN with competing PRs named), repos with detected behavioral gates are excluded, repos where you already have an open PR are skipped, and the run stops with marked partial results when the core API budget falls under the floor (default 800) or search throttling hits. Human and `--json` output; every stage reports the API calls it used.
 
 ### Agent-policy gates and triage holds
 

package/dist/behavior.d.ts

@@ -0,0 +1,63 @@
+export interface BehavioralClosedPR {
+    number: number;
+    url: string;
+    author: string;
+    closedAt: string;
+}
+export interface BehavioralMaintainerComment {
+    pr: number;
+    author: string;
+    association: string;
+    body: string;
+    url: string;
+}
+export interface BehavioralSignal {
+    pr: number;
+    author: string;
+    /** Truncated quote (240 chars) that fired the matcher. */
+    quote: string;
+    url: string;
+    /** True for explicit phrases like "AI slop"; weaker signals can still count toward strength. */
+    strong: boolean;
+}
+export interface BehavioralGate {
+    /** True when strength >= threshold: the maintainer rejects AI-built PRs in practice. */
+    detected: boolean;
+    /** Distinct closed-unmerged PRs with at least one matching maintainer comment. */
+    strength: number;
+    /** Detection needs strength >= threshold. Always 2; a lone PR is a warning, not a policy. */
+    threshold: number;
+    evidence: BehavioralSignal[];
+    /** Transparency: PRs scanned, maintainer comments seen, why nothing fired. */
+    notes: string[];
+    note: string;
+}
+/** Maximum closed-unmerged PRs examined per repo. Keeps the pass bounded. */
+export declare const BEHAVIORAL_MAX_PRS = 15;
+/**
+ * API cost contract: 1-3 calls to walk the closed-PR list (stops early
+ * once 15 unmerged PRs are found) plus at most one comment page per
+ * closed-unmerged PR.
+ */
+export declare const BEHAVIORAL_MAX_API_CALLS: number;
+/** Pure: does one comment body read as maintainer AI-rejection evidence? */
+export declare function matchAiRejection(body: string): {
+    matched: boolean;
+    strong: boolean;
+};
+/**
+ * Pure core: fold maintainer comments on closed-unmerged PRs into a gate
+ * verdict. The live fetcher below builds these two inputs; tests drive
+ * this function with fixtures, so the threshold logic never depends on
+ * the network. Comments whose association is not maintainer-side are
+ * ignored here too, so the pure contract is complete.
+ */
+export declare function detectBehavioralGateFromData(prs: BehavioralClosedPR[], comments: BehavioralMaintainerComment[]): BehavioralGate;
+/**
+ * Live pass: walk the closed-PR list (newest first) until 15
+ * closed-unmerged PRs are collected, fetch comments on those PRs, and run
+ * the pure core. Returns the gate verdict; throws on API failure (the
+ * friction pipeline treats a failure as "signal unavailable", never as
+ * detected).
+ */
+export declare function detectBehavioralGate(owner: string, repo: string): Promise<BehavioralGate>;

package/dist/behavior.js

@@ -0,0 +1,178 @@
+/**
+ * Behavioral gate detection (v0.16.0).
+ *
+ * Field data (2026-10-19, PR wave): spotDL/spotify-downloader is classed
+ * "open" in the Agent Policy Index (no policy file bans agents), yet its
+ * maintainer rejects AI-built contributions in practice: issue #2371 drew
+ * three PRs, all closed unmerged, with PR #2494 closed on a comment
+ * calling the submission "AI slop". Policy-file gate detection cannot see
+ * this shape, so the index misleads contributors into burning builds. This
+ * module closes that gap with a bounded, deterministic pass over recent
+ * closed-unmerged PRs.
+ *
+ * Design (deliberately conservative; read before changing):
+ *   - Scope: the 15 most recent CLOSED-UNMERGED PRs. The closed-PR list is
+ *     walked (newest first, up to 3 pages of 30) until 15 unmerged PRs are
+ *     collected, because merged PRs carry no closure evidence and an
+ *     active repo's unmerged closures can sit pages deep. Comment fetches
+ *     (first page, per_page=100) run only for those unmerged PRs, so the
+ *     total cost is 1-3 list calls + up to 15 comment calls (18 max).
+ *   - Maintainer-side only: comment author_association must be OWNER,
+ *     MEMBER, or COLLABORATOR, and the comment author must not be the PR
+ *     author (a maintainer closing their own PR is not evidence against
+ *     outsiders).
+ *   - A comment counts as AI-rejection evidence when it contains an
+ *     AI-attribution term AND a rejection/closure term (or matches one of
+ *     the explicit strong phrases below). Welcoming overrides
+ *     ("AI-assisted PRs are welcome") suppress the signal so open repos
+ *     do not false-positive.
+ *   - Detection threshold: strength >= 2, where strength is the number of
+ *     DISTINCT closed-unmerged PRs carrying at least one matching
+ *     maintainer comment. A single weak signal is carried in evidence
+ *     with detected=false: a warning, not a behavioral policy. A single
+ *     STRONG signal (an explicit phrase like "AI slop" or an invoked "AI
+ *     policy" on closure) detects on its own: the phrase is unambiguous
+ *     maintainer intent, and corroboration would only delay the warning.
+ *
+ * This is behavior inference from maintainer actions, not policy text:
+ * verdicts should treat a detected behavioral gate as a hard reason to
+ * skip the repo, the same way agents_banned is treated.
+ */
+import { apiGet, apiCallsUsed } from "./github.js";
+/** Maximum closed-unmerged PRs examined per repo. Keeps the pass bounded. */
+export const BEHAVIORAL_MAX_PRS = 15;
+/**
+ * API cost contract: 1-3 calls to walk the closed-PR list (stops early
+ * once 15 unmerged PRs are found) plus at most one comment page per
+ * closed-unmerged PR.
+ */
+export const BEHAVIORAL_MAX_API_CALLS = 3 + BEHAVIORAL_MAX_PRS;
+const AI_TERMS = /\b(ai|a\.i\.|llm|llms|chatgpt|copilot|Muse|gemini|gpt-?4|gpt-?3|generated|slop)\b/i;
+const REJECTION_TERMS = /\b(clos(?:e|ed|ing|ure)?|not\s+accept(?:ing|s)?|won['’]t|will\s+not|do\s+not|don['’]t|reject(?:ed|s|ion)?|declin(?:e|ed)|low[\s-]?effort|slop|refus(?:e|ed|ing)|spam|not\s+welcome|polic(?:y|ies))\b/i;
+/** Explicit phrases: unmistakable even without the two-term rule. */
+const STRONG_PHRASES = [
+    /\bai\s+slop\b/i,
+    /\bno\s+ai[-\s]?(prs?|contributions?|code|submissions?)\b/i,
+    /\bwe\s+(do\s+not|don['’]t|won['’]t)\s+accept\s+ai/i,
+    /\bno\s+(ai|llm)[-\s]?generated\b/i,
+    /\bai[-\s]?(llm\s+)?polic(y|ies)\b/i,
+];
+/** Welcoming language suppresses the signal: "AI-assisted PRs are welcome" must never fire. */
+const WELCOMING = /\bwelcom(e|ing)\b[^.!?]{0,80}\b(ai|ai[-\s]assisted|contributions?|contributors?|prs?)\b/i;
+/** Pure: does one comment body read as maintainer AI-rejection evidence? */
+export function matchAiRejection(body) {
+    const text = body.replace(/\s+/g, " ");
+    if (WELCOMING.test(text))
+        return { matched: false, strong: false };
+    for (const p of STRONG_PHRASES) {
+        if (p.test(text))
+            return { matched: true, strong: true };
+    }
+    if (AI_TERMS.test(text) && REJECTION_TERMS.test(text)) {
+        return { matched: true, strong: /\bslop\b/i.test(text) };
+    }
+    return { matched: false, strong: false };
+}
+function truncateQuote(body, limit = 240) {
+    const flat = body.replace(/\s+/g, " ").trim();
+    return flat.length > limit ? flat.slice(0, limit - 1) + "\u2026" : flat;
+}
+const MAINTAINER_ASSOCIATIONS = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
+/**
+ * Pure core: fold maintainer comments on closed-unmerged PRs into a gate
+ * verdict. The live fetcher below builds these two inputs; tests drive
+ * this function with fixtures, so the threshold logic never depends on
+ * the network. Comments whose association is not maintainer-side are
+ * ignored here too, so the pure contract is complete.
+ */
+export function detectBehavioralGateFromData(prs, comments) {
+    const prByNumber = new Map(prs.map((p) => [p.number, p]));
+    const evidence = [];
+    const prsWithSignal = new Set();
+    const notes = [];
+    notes.push(`scanned ${prs.length} closed-unmerged PRs, ${comments.length} maintainer comments on them`);
+    for (const c of comments) {
+        if (!MAINTAINER_ASSOCIATIONS.has(String(c.association ?? "")))
+            continue;
+        const pr = prByNumber.get(c.pr);
+        if (!pr)
+            continue;
+        // A maintainer closing their own PR is not evidence against outsiders.
+        if (c.author.toLowerCase() === pr.author.toLowerCase())
+            continue;
+        const { matched, strong } = matchAiRejection(c.body);
+        if (!matched)
+            continue;
+        evidence.push({
+            pr: c.pr,
+            author: c.author,
+            quote: truncateQuote(c.body),
+            url: c.url,
+            strong,
+        });
+        prsWithSignal.add(c.pr);
+    }
+    const strength = prsWithSignal.size;
+    const threshold = 2;
+    const hasStrong = evidence.some((e) => e.strong);
+    // Two independent PRs make it a behavioral policy; one explicit
+    // strong phrase (e.g. "AI slop", an invoked "AI policy" on closure)
+    // is unambiguous maintainer intent and detects on its own.
+    const detected = strength >= threshold || (strength >= 1 && hasStrong);
+    const note = detected
+        ? `maintainer rejects AI-built PRs in practice: ${strength} closed-unmerged PR${strength === 1 ? "" : "s"} carr${strength === 1 ? "ies" : "y"} AI-rejection comments${hasStrong ? ", including an explicit rejection phrase" : ""}`
+        : strength === 0
+            ? "no maintainer AI-rejection evidence found on recent closed-unmerged PRs"
+            : `only ${strength} closed-unmerged PR with AI-rejection evidence and no explicit phrase (threshold ${threshold}): warning, not a behavioral gate`;
+    if (!detected && evidence.length > 0) {
+        notes.push("signals exist but stay below the detection threshold");
+    }
+    return { detected, strength, threshold, evidence, notes, note };
+}
+/**
+ * Live pass: walk the closed-PR list (newest first) until 15
+ * closed-unmerged PRs are collected, fetch comments on those PRs, and run
+ * the pure core. Returns the gate verdict; throws on API failure (the
+ * friction pipeline treats a failure as "signal unavailable", never as
+ * detected).
+ */
+export async function detectBehavioralGate(owner, repo) {
+    const callsBefore = apiCallsUsed();
+    const closedUnmerged = [];
+    for (let page = 1; page <= 3 && closedUnmerged.length < BEHAVIORAL_MAX_PRS; page++) {
+        const items = (await apiGet(`/repos/${owner}/${repo}/pulls?state=closed&sort=updated&direction=desc&per_page=30&page=${page}`));
+        if (!items || items.length === 0)
+            break;
+        for (const p of items) {
+            if (closedUnmerged.length >= BEHAVIORAL_MAX_PRS)
+                break;
+            if (p.state === "closed" && !p.merged_at) {
+                closedUnmerged.push({
+                    number: p.number,
+                    url: p.html_url,
+                    author: String(p.user?.login ?? ""),
+                    closedAt: String(p.closed_at ?? ""),
+                });
+            }
+        }
+        if (items.length < 30)
+            break;
+    }
+    const comments = [];
+    for (const pr of closedUnmerged) {
+        const list = (await apiGet(`/repos/${owner}/${repo}/issues/${pr.number}/comments?per_page=100`));
+        for (const c of list ?? []) {
+            comments.push({
+                pr: pr.number,
+                author: String(c.user?.login ?? ""),
+                association: String(c.author_association ?? ""),
+                body: String(c.body ?? ""),
+                url: c.html_url,
+            });
+        }
+    }
+    const gate = detectBehavioralGateFromData(closedUnmerged, comments);
+    gate.notes.push(`API calls used: ${apiCallsUsed() - callsBefore}`);
+    return gate;
+}
+//# sourceMappingURL=behavior.js.map

package/dist/behavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavior.js","sourceRoot":"","sources":["../src/behavior.ts"],"names":[],"mappings":"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"}

package/dist/cli.js

@@ -4,6 +4,7 @@
  *
  *   greenlight check <issue-url> [--json] [--gates-file path]
  *   greenlight scan <owner/repo> [--json] [--no-fallback] [--gates-file path]
+ *   greenlight wave [--index url|path] [--repos N] [--min-share N] [--stars lo,hi] [--issues-per-repo N] [--min-budget N] [--json]
  *   greenlight mcp
  *   greenlight friction <owner/repo> [--json]
  *   greenlight ci <pr-url> [--json]
@@ -55,6 +56,7 @@ import { briefPR } from "./brief.js";
 import { babysit, defaultStatePath, defaultAccountAuthor } from "./babysit.js";
 import { runAutopilot, defaultAutopilotStatePath } from "./autopilot.js";
 import { runSync, formatSyncHuman, syncJson } from "./sync.js";
+import { runWave, liveWaveDeps, loadPolicyIndex, formatWaveHuman, POLICY_INDEX_URL, DEFAULT_WAVE_FILTERS, } from "./wave.js";
 import { runPortfolio, formatPortfolioHuman, portfolioJson } from "./portfolio.js";
 import { runShipcheck, formatShipcheckHuman } from "./shipcheck.js";
 import { runPreflight, formatPreflightHuman } from "./preflight.js";
@@ -382,12 +384,16 @@ async function cmdXray(repoRef, args) {
             console.log(`  flags: ${r.flags.join(", ")}`);
     }
 }
-async function cmdFriction(repoRef, asJson) {
+async function cmdFriction(repoRef, asJson, args = []) {
     const { owner, repo } = parseRepoRef(repoRef);
     // v0.9.3: one shared pipeline (fetchFrictionSummary) for the CLI, the
     // MCP repo_friction tool, and preflight, so gates come from the full
     // policy source set everywhere instead of a single CONTRIBUTING read.
-    const report = await fetchFrictionSummary(owner, repo);
+    // v0.16.0: the behavioral gate pass (maintainer actions, not policy
+    // text) is part of the report; --no-behavioral skips its API cost.
+    const report = await fetchFrictionSummary(owner, repo, {
+        behavioral: !args.includes("--no-behavioral"),
+    });
     if (asJson) {
         console.log(JSON.stringify(report, null, 2));
         return;
@@ -397,12 +403,74 @@ async function cmdFriction(repoRef, asJson) {
         console.log(`  - ${reason}`);
     if (report.reasons.length === 0)
         console.log("  - no gates or penalties detected");
+    if (report.behavioral_gate?.detected) {
+        const n = report.behavioral_gate.strength;
+        console.log(`  BEHAVIORAL GATE: maintainer rejects AI-built PRs in practice (${n} signal${n === 1 ? "" : "s"})`);
+        for (const ev of report.behavioral_gate.evidence) {
+            console.log(`    - PR #${ev.pr} by @${ev.author}: "${ev.quote}" (${ev.url})`);
+        }
+    }
+    else if (report.behavioral_gate && report.behavioral_gate.evidence.length > 0) {
+        console.log(`  behavioral note: ${report.behavioral_gate.note}`);
+    }
     const starterCount = report.signals.openGoodFirstIssueCount ?? null;
     if (starterCount !== null)
         console.log(`  open starter issues: ${starterCount}`);
     if (report.mergeVelocity)
         console.log(`  merge velocity: ${describeMergeVelocity(report.mergeVelocity)}`);
 }
+/**
+ * v0.16.0: turn the Agent Policy Index into a build queue in one command.
+ * Filters pure-open repos, x-rays starter issues with the existing xray
+ * engine, excludes behavioral gates, and skips repos where you already
+ * have an open PR. Stops with partial results under the budget floor.
+ */
+async function cmdWave(args) {
+    const numFlag = (name) => {
+        const v = flagValue(args, name);
+        if (v === undefined)
+            return undefined;
+        const n = Number(v);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    const starsRaw = flagValue(args, "--stars");
+    let minStars = DEFAULT_WAVE_FILTERS.minStars;
+    let maxStars = DEFAULT_WAVE_FILTERS.maxStars;
+    if (starsRaw) {
+        const [lo, hi] = starsRaw.split(",").map(Number);
+        if (Number.isFinite(lo) && Number.isFinite(hi) && lo <= hi) {
+            minStars = lo;
+            maxStars = hi;
+        }
+    }
+    const filters = {
+        minShare: numFlag("--min-share") ?? DEFAULT_WAVE_FILTERS.minShare,
+        minStars,
+        maxStars,
+        maxRepos: numFlag("--repos") ?? DEFAULT_WAVE_FILTERS.maxRepos,
+        issuesPerRepo: numFlag("--issues-per-repo") ?? DEFAULT_WAVE_FILTERS.issuesPerRepo,
+        minBudget: numFlag("--min-budget") ?? DEFAULT_WAVE_FILTERS.minBudget,
+    };
+    const indexSource = flagValue(args, "--index") ?? POLICY_INDEX_URL;
+    const asJson = args.includes("--json");
+    let index;
+    try {
+        index = await loadPolicyIndex(indexSource);
+    }
+    catch (err) {
+        console.error(`Error: could not load the policy index from ${indexSource}: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await runWave(index, filters, liveWaveDeps());
+    if (asJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(formatWaveHuman(result));
+    if (result.partial)
+        process.exitCode = 2;
+}
 function flagValue(args, name) {
     const i = args.indexOf(name);
     return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
@@ -1451,7 +1519,9 @@ async function main() {
         if (command === "xray" && target)
             return await cmdXray(target, args);
         if (command === "friction" && target)
-            return await cmdFriction(target, args.includes("--json"));
+            return await cmdFriction(target, args.includes("--json"), args);
+        if (command === "wave")
+            return await cmdWave(args);
         if (command === "ci" && target)
             return await cmdCi(target, args.includes("--json"));
         if (command === "ci-prep" && target)