@openmixer/plugin-qualify 0.8.0 → 0.10.1

package/src/pins-file.ts

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The pins file `plugin-qualify --pins <file>` writes and plugin-hostd loads (`pin_file` in its settings, or its
+ * pin store's import): one line per qualified plugin, the SAME line as hostd's `pin_set` verb, with the
+ * qualification verdict as a last word.
+ *
+ *     pin_set <uri> <path>=<sha256>[,<path>=<sha256>...] <scheme>:<sha256> [verdict=<word>]
+ *
+ * The digests and the layout are the prober's, raw (`IntegrityMeasurement`); nothing here computes a hash. A plugin
+ * whose run took no whole pin has no line: a pins file never holds a partial pin. The grammar is plugin-hostd's
+ * (`include/plugin-hostd/protocol.h`, PHD_PIN_*); `parsePinLine` reads a line back with the daemon's rules, so a
+ * writer that drifts from them is a red test and not a refused add.
+ */
+import { resolve } from "node:path";
+
+import type { RtSafetyDocument } from "./clap-qualify.js";
+import type { IntegrityMeasurement, MeasuredPlugin } from "./measurement/format.js";
+import type { QualifyVerdict } from "./qualify-cli.js";
+import type { SuitabilityRating } from "./rating.js";
+
+/** The verb the line starts with in a pins file, hostd's `PHD_VERB_PIN_SET`. */
+export const PIN_VERB = "pin_set";
+
+/** The key of the verdict word, hostd's `PHD_PIN_VERDICT_KEY`. */
+export const PIN_VERDICT_KEY = "verdict=";
+
+/** The verdict words hostd knows (`PHD_PIN_VERDICTS`). */
+export const PIN_VERDICTS = ["in-process", "isolated", "refused"] as const;
+export type PinVerdict = (typeof PIN_VERDICTS)[number];
+
+/**
+ * What a rating says about where the plugin may run, in hostd's words. `suitable` is qualified for a worker that other
+ * plugins share. `conditional` loads and is isolated. `unsuitable` is measured to fail and is `refused`. `unknown` is no
+ * opinion: no verdict word, and hostd treats the plugin as not qualified.
+ */
+export function pinVerdictOf(rating: SuitabilityRating): PinVerdict | undefined {
+  switch (rating) {
+    case "suitable":
+      return "in-process";
+    case "conditional":
+      return "isolated";
+    case "unsuitable":
+      return "refused";
+    case "unknown":
+      return undefined;
+  }
+}
+
+/** One pin: what hostd's `pin_set` takes, and the verdict of the run that took it. */
+export interface PinEntry {
+  /** hostd's uri: `clap:<path of the .clap>#<id>`, or an LV2 plugin's own URI. */
+  readonly uri: string;
+  readonly integrity: IntegrityMeasurement;
+  readonly verdict?: PinVerdict;
+}
+
+/** The line of one pin, or `undefined` when the integrity block is not a whole pin. A uri with whitespace in it would be read back as more words: it is refused, by name. */
+export function pinLine(entry: PinEntry): string | undefined {
+  const spaced = [entry.uri, ...(entry.integrity.files ?? []).map((f) => f.path)].find((w) => /\s/.test(w));
+  if (spaced !== undefined) {
+    throw new Error(`${entry.uri}: ${JSON.stringify(spaced)} has whitespace in it and cannot be a word of a pin line`);
+  }
+  const { files, layout } = entry.integrity;
+  if (files === undefined || files.length === 0 || layout === undefined) return undefined;
+  const list = files.map((f) => `${f.path}=${f.sha256}`).join(",");
+  const verdict = entry.verdict === undefined ? "" : ` ${PIN_VERDICT_KEY}${entry.verdict}`;
+  return `${PIN_VERB} ${entry.uri} ${list} ${layout.scheme}:${layout.sha256}${verdict}`;
+}
+
+/** hostd's uri of a CLAP plugin the prober loaded: its file as it was handed, made absolute, and its id. */
+export function clapPinUri(binaryPath: string, pluginUri: string): string {
+  const id = pluginUri.startsWith("urn:clap:") ? pluginUri.slice("urn:clap:".length) : pluginUri;
+  return `clap:${resolve(binaryPath)}#${id}`;
+}
+
+/** What went into a pins file and what did not. */
+export interface PinsFile {
+  readonly text: string;
+  /** The uris written. */
+  readonly written: readonly string[];
+  /** The uris of plugins that took no whole pin: they have no line. */
+  readonly skipped: readonly string[];
+  /** The uris refused because a word of their line has whitespace in it, each with the reason: they have no line. */
+  readonly refused: readonly { readonly uri: string; readonly problem: string }[];
+}
+
+/**
+ * The file: a comment that says where it came from, then one line per plugin, sorted by uri. A uri given twice keeps
+ * the entry whose verdict is the worse one (`refused` over `isolated` over `in-process`, no word over all), so a
+ * plugin found twice is never pinned more kindly than its worst measurement.
+ */
+export function pinsFile(entries: readonly PinEntry[]): PinsFile {
+  const byUri = new Map<string, string>();
+  const verdictOf = new Map<string, PinVerdict | undefined>();
+  const skipped: string[] = [];
+  const refused: { uri: string; problem: string }[] = [];
+  const rank = (v: PinVerdict | undefined): number => (v === undefined ? 4 : { "in-process": 1, isolated: 2, refused: 3 }[v]);
+  for (const entry of entries) {
+    let line: string | undefined;
+    try {
+      line = pinLine(entry);
+    } catch (e) {
+      refused.push({ uri: entry.uri, problem: (e as Error).message });
+      continue;
+    }
+    if (line === undefined) {
+      skipped.push(entry.uri);
+      continue;
+    }
+    if (byUri.has(entry.uri) && rank(verdictOf.get(entry.uri)) >= rank(entry.verdict)) continue;
+    byUri.set(entry.uri, line);
+    verdictOf.set(entry.uri, entry.verdict);
+  }
+  const uris = [...byUri.keys()].sort();
+  const text = [
+    "# written by plugin-qualify --pins; plugin-hostd reads it with pin_file",
+    ...uris.map((u) => byUri.get(u)!),
+    "",
+  ].join("\n");
+  return { text, written: uris, skipped: skipped.filter((u) => !byUri.has(u)), refused };
+}
+
+/**
+ * The entries of a CLAP pass for one host: each document of that host's profile with its pin and the verdict its
+ * rating says. The documents of other profiles are ignored; a pins file is for one host.
+ */
+export function clapPinEntries(documents: readonly RtSafetyDocument[], host: string): PinEntry[] {
+  return documents
+    .filter((d) => d.console === host)
+    .map((d) => {
+      const verdict = pinVerdictOf(d.verdict.rating);
+      return {
+        uri: clapPinUri(d.plugin.binary.path, d.plugin.uri),
+        integrity: d.measured.integrity,
+        ...(verdict === undefined ? {} : { verdict }),
+      };
+    });
+}
+
+/**
+ * The entries of an LV2 run: each measured plugin with a pin and the verdict row of that host. A plugin with no verdict
+ * row for the host is pinned without a verdict word.
+ */
+export function measuredPinEntries(
+  plugins: readonly MeasuredPlugin[],
+  verdicts: readonly QualifyVerdict[],
+  host: string,
+): PinEntry[] {
+  return plugins.flatMap((p) => {
+    if (p.integrity === undefined) return [];
+    const row = verdicts.find((v) => v.uri === p.uri && v.host === host);
+    const verdict = row === undefined || !row.measured ? undefined : pinVerdictOf(row.rating);
+    return [{ uri: p.uri, integrity: p.integrity, ...(verdict === undefined ? {} : { verdict }) }];
+  });
+}
+
+/** A line read back with hostd's rules. */
+export interface ParsedPin {
+  readonly uri: string;
+  readonly files: readonly { readonly path: string; readonly sha256: string }[];
+  readonly layout: { readonly scheme: string; readonly sha256: string };
+  readonly verdict?: PinVerdict;
+}
+
+const HEX = /^[0-9a-f]{64}$/;
+
+/**
+ * hostd's grammar for a pin line, the verb optional; `undefined` for a blank or comment line, and a thrown Error for a
+ * line the daemon would refuse (a path holding a separator, a path that climbs out of the bundle, a digest that is not
+ * 64 lowercase hex digits, a layout without a scheme, a verdict outside the vocabulary, a path named twice).
+ */
+export function parsePinLine(line: string): ParsedPin | undefined {
+  const words = line.trim().split(/\s+/).filter((w) => w !== "");
+  if (words.length === 0 || words[0]!.startsWith("#")) return undefined;
+  if (words[0] === PIN_VERB) words.shift();
+  if (words.length !== 3 && words.length !== 4) throw new Error(`a pin line has 3 or 4 words, not ${words.length}`);
+  const [uri, list, layout, verdictWord] = words as [string, string, string, string | undefined];
+  const files = list.split(",").map((item) => {
+    const eq = item.lastIndexOf("=");
+    if (eq < 0) throw new Error(`${item}: no =`);
+    const path = item.slice(0, eq);
+    const sha256 = item.slice(eq + 1);
+    if (path === "" || path.startsWith("/") || path.split("/").some((part) => part === "" || part === "..")) {
+      throw new Error(`${path}: not a path inside the bundle`);
+    }
+    if (!HEX.test(sha256)) throw new Error(`${path}: not a sha256`);
+    return { path, sha256 };
+  });
+  if (new Set(files.map((f) => f.path)).size !== files.length) throw new Error("a path is named twice");
+  const colon = layout.lastIndexOf(":");
+  if (colon <= 0 || !HEX.test(layout.slice(colon + 1))) throw new Error(`${layout}: not a layout pin`);
+  let verdict: PinVerdict | undefined;
+  if (verdictWord !== undefined) {
+    const word = verdictWord.startsWith(PIN_VERDICT_KEY) ? verdictWord.slice(PIN_VERDICT_KEY.length) : "";
+    if (!(PIN_VERDICTS as readonly string[]).includes(word)) throw new Error(`${verdictWord}: not a verdict`);
+    verdict = word as PinVerdict;
+  }
+  return { uri, files, layout: { scheme: layout.slice(0, colon), sha256: layout.slice(colon + 1) }, ...(verdict === undefined ? {} : { verdict }) };
+}

package/src/qualify-cli.ts

@@ -27,6 +27,8 @@ export interface QualifyArgs {
   readonly rates: readonly number[];
   readonly quanta: readonly number[];
   readonly out?: string;
+  /** `--pins`: where the pins file is written. */
+  readonly pins?: string;
   readonly format: OutputFormat;
   readonly isolate: boolean;
   readonly hostSweep: boolean;
@@ -83,6 +85,8 @@ export function parseQualifyArgs(argv: readonly string[]): ParseResult {
     return { ok: false, error: `--format must be one of ${OUTPUT_FORMATS.join(", ")}` };
   }
   const out = seen.get("--out") as string | undefined;
+  const pins = seen.get("--pins") as string | undefined;
+  if (pins !== undefined && pins.startsWith("--")) return { ok: false, error: "--pins needs a file name" };
   const hostProfiles = [...new Set(profileSpecs.length > 0 ? profileSpecs : [defaultOf("--host-profile")])];
   return {
     ok: true,
@@ -92,6 +96,7 @@ export function parseQualifyArgs(argv: readonly string[]): ParseResult {
       rates,
       quanta,
       ...(out === undefined ? {} : { out }),
+      ...(pins === undefined ? {} : { pins }),
       format: format as OutputFormat,
       isolate: seen.has("--isolate"),
       hostSweep: !seen.has("--no-host-sweep"),
@@ -111,7 +116,9 @@ export function helpText(): string {
     "plugin-qualify — qualify audio plugins for real-time hosting",
     "",
     "  plugin-qualify <uri|bundle-path>...   exactly the named plugins; a .lv2 bundle = every plugin in it",
-    "  plugin-qualify --all                  every plugin lilv finds (LV2_PATH honoured)",
+    "  plugin-qualify --all                  every CLAP plugin on CLAP_PATH, then ~/.clap, then /usr/lib/clap;",
+    "                                        refuses (exit 2) when LV2 bundles are on the LV2 path (LV2_PATH),",
+    "                                        which this entry point cannot measure",
     "",
     ...rows,
     "",

package/src/qualify-declarations.ts

@@ -69,22 +69,35 @@ export const SOAK_CALIBRATION_S = 30;
 export const CLAP_SCAN_TOOL_ENV = "OMX_CLAP_SCAN";
 export const CLAP_SCAN_TOOL_DEFAULT = "omx-clap-scan";
 
+/**
+ * The standard CLAP search path `--all` walks, in this order: every directory `CLAP_PATH` names
+ * (colon-separated), then `~/.clap`, then `/usr/lib/clap`. The system directory is the same on
+ * every distribution and architecture; it is never the library directory (`/usr/lib64`).
+ */
+export const CLAP_PATH_ENV = "CLAP_PATH";
+export const CLAP_USER_DIR = ".clap";
+export const CLAP_SYSTEM_DIR = "/usr/lib/clap";
+
 /** Seconds one run of the CLAP scanner may take over everything it was pointed at. */
 export const CLAP_SCAN_TIMEOUT_S = 300;
 
 /**
- * The CLAP prober (`native/clap-qualify.c`), the LV2 measurer (`native/lv2-measure.c`) and the
- * interposer both run under (`native/rt-interpose.c`): each located by one environment variable, else
- * the package's own build in `native/build/`, else the first of `NATIVE_TOOL_DIRS` that holds it.
+ * The CLAP prober (`native/clap-qualify.c`), the LV2 measurer (`native/lv2-measure.c`), the
+ * interposer both run under (`native/rt-interpose.c`) and the LV2 host probe
+ * (`native/lv2-host-probe.c`, a worker plugin driven through lilv as a host drives it, for a console
+ * that exports an LV2 plugin to test its host-facing half): each located by one environment variable,
+ * else the package's own build in `native/build/`, else the first of `NATIVE_TOOL_DIRS` that holds it.
  */
 export const CLAP_QUALIFY_TOOL_ENV = "OMX_CLAP_QUALIFY";
 export const LV2_MEASURE_TOOL_ENV = "OMX_LV2_MEASURE";
 export const RT_INTERPOSE_ENV = "OMX_RT_INTERPOSE";
+export const LV2_HOST_PROBE_TOOL_ENV = "OMX_LV2_HOST_PROBE";
 
 /** The file names of the native tools, in every place they are looked for. */
 export const CLAP_QUALIFY_TOOL_NAME = "clap-qualify";
 export const LV2_MEASURE_TOOL_NAME = "lv2_measure";
 export const RT_INTERPOSE_NAME = "rt_interpose.so";
+export const LV2_HOST_PROBE_TOOL_NAME = "lv2_host_probe";
 
 /**
  * The ONE list of the native tools the packages install, each with the setting that names it.
@@ -94,6 +107,7 @@ export const NATIVE_TOOLS: readonly { readonly name: string; readonly env: strin
   { name: CLAP_QUALIFY_TOOL_NAME, env: CLAP_QUALIFY_TOOL_ENV },
   { name: LV2_MEASURE_TOOL_NAME, env: LV2_MEASURE_TOOL_ENV },
   { name: RT_INTERPOSE_NAME, env: RT_INTERPOSE_ENV },
+  { name: LV2_HOST_PROBE_TOOL_NAME, env: LV2_HOST_PROBE_TOOL_ENV },
 ];
 
 /**
@@ -153,7 +167,7 @@ export const DEFAULT_HOSTING_POLICY: HostingPolicy = {
   soakDeadDropDb: 40,
 };
 
-/** What a host spends on one plugin instance (`2026-09-25-plugin-qualify.md` §3a) — the
+/** What a host spends on one plugin instance — the
  *  interchange's shape, since a document carries each profile's budget. */
 import type { HostBudget } from "./measurement/format.js";
 export type { HostBudget };
@@ -164,10 +178,13 @@ export type { HostBudget };
  * so it gets the same per-instance share, at 48 kHz / 128 frames. `jalv` gives each plugin its own
  * process and client, so a quarter core per instance, at 48 kHz / 256 frames. The last two are
  * declared defaults, not a measurement of anyone's board — a project brings its own profile file.
+ * `omx-clap-host` runs its plugins one JACK client each, called in turn on the server's one cycle,
+ * so it gets mod-host's share and pair.
  */
 export const HOST_BUDGETS = {
   "openmixer-console": { coreFractionCeiling: 0.05, rate: COST_REFERENCE_RATE, quantum: QUANTUM_FRAMES },
   jalv: { coreFractionCeiling: 0.25, rate: MEASURE_BASE_RATE, quantum: 256 },
   "mod-host": { coreFractionCeiling: 0.05, rate: MEASURE_BASE_RATE, quantum: 128 },
+  "omx-clap-host": { coreFractionCeiling: 0.05, rate: MEASURE_BASE_RATE, quantum: 128 },
 } as const satisfies Readonly<Record<string, HostBudget>>;
 

package/src/qualify-options.ts

@@ -32,7 +32,7 @@ export interface QualifyOption {
 }
 
 export const QUALIFY_OPTIONS: readonly QualifyOption[] = [
-  { flag: "--all", describe: "every plugin lilv finds (LV2_PATH honoured)" },
+  { flag: "--all", describe: "every CLAP plugin on the CLAP search path; refuses when LV2 bundles are on the LV2 path" },
   { flag: "--rates", value: "list", describe: "sample rates to measure at, comma-separated", default: QUALIFY_RATES.join(",") },
   { flag: "--quanta", value: "list", describe: "quanta (frames) to rate cost at, comma-separated", default: QUALIFY_QUANTA.join(",") },
   { flag: "--out", value: "dir", describe: "write one interchange JSON document per run into this directory" },
@@ -45,5 +45,11 @@ export const QUALIFY_OPTIONS: readonly QualifyOption[] = [
     describe: `judge against this host (${HOST_PROFILES.map((p) => p.id).join(", ")}, or a profile JSON file); repeat or comma-separate for one verdict per profile`,
     default: OPENMIXER_CONSOLE_PROFILE.id,
   },
+  {
+    flag: "--pins",
+    value: "file",
+    describe:
+      "write one pin per qualified plugin to this file, with its verdict, for plugin-hostd's pin_file (the verdict is the first host profile's)",
+  },
   { flag: "--help", describe: "this text" },
 ];

package/tools/ai-trace-commit-check.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+#
+# ai-trace-commit-check.sh: fail when a commit message carries an AI-attribution line.
+#
+#   ai-trace-commit-check.sh <range>          every commit in the range (e.g. origin/main..HEAD)
+#   ai-trace-commit-check.sh --msg-file FILE  one message (the commit-msg hook; # lines are git comments, skipped)
+#   ai-trace-commit-check.sh --text-file FILE any text, every line judged (pull request titles and bodies)
+#   ai-trace-commit-check.sh --selftest       fixtures plus a sabotage run
+#
+# Exit 0 clean, 1 a hit (each commit and offending line is named), 2 a range, file or pattern list that cannot be read
+# (any crash is 2). A caller refuses on 2: a checker that cannot judge is never a pass.
+# The patterns are ai-trace-patterns.json beside this script; AI_TRACE_PATTERNS names another JSON (self-tests).
+set -euo pipefail
+export AI_TRACE_SELF="${BASH_SOURCE[0]}"
+exec python3 -I - "$@" <<'PY'
+import json, os, re, subprocess, sys
+
+here = os.path.dirname(os.path.realpath(os.environ["AI_TRACE_SELF"]))
+pfile = os.environ.get("AI_TRACE_PATTERNS") or os.path.join(here, "ai-trace-patterns.json")
+
+
+def load():
+    with open(pfile, encoding="utf-8") as f:
+        return [(m["name"], re.compile(m["pattern"], re.I | re.M)) for m in json.load(f)["markers"]]
+
+
+def hits(text, markers):
+    out = []
+    for n, line in enumerate(text.splitlines(), 1):
+        for name, rx in markers:
+            if rx.search(line):
+                out.append((n, name, line.strip()))
+    return out
+
+
+def report(label, text, markers):
+    h = hits(text, markers)
+    for n, name, line in h:
+        print(f"{label}: line {n} [{name}]: {line}")
+    return len(h)
+
+
+def git(*a):
+    p = subprocess.run(["git", *a], capture_output=True, text=True)
+    if p.returncode:
+        print(f"ai-trace-commit-check: git {' '.join(a[:3])}: {p.stderr.strip()}", file=sys.stderr)
+        sys.exit(2)
+    return p.stdout
+
+
+def selftest():
+    # built from fragments: this file must not itself carry an attribution line
+    co, by, ai = "Co-Authored-", "By: ", "Cl" + "aude"
+    sess = "Cl" + "aude-Session: https://cl" + "aude.ai/code/session_01"
+    fx = {
+        "co-authored-by": f"Fix x\n\n{co}{by}{ai} Opus <noreply@anthro" + "pic.com>\n",
+        "claude-session": f"Fix x\n\n{sess}\n",
+        "generated-footer": f"Fix x\n\n\U0001F916 Generated with [{ai} Code](https://{ai.lower()}.com/{ai.lower()}-code)\n",
+        "claude.ai/code": f"Fix x\n\nsee https://{ai.lower()}.ai/code/session_9\n",
+    }
+    clean = f"Fix x\n\nGenerated by the build; mentions a hidden directory and a {co}{by}Pau line.\n"
+    def run(markers):
+        bad = [k for k, v in fx.items() if not hits(v, markers)]
+        if hits(clean, markers):
+            bad.append("clean-flagged")
+        return bad
+    m = load()
+    first = run(m)
+    print("selftest:", "GREEN" if not first else f"RED {first}")
+    sab = run([x for x in m if x[0] not in ("co-authored-by", "ai-co-author", "anthropic-noreply", "claude-session")])
+    print("sabotage (the co-author, email and session patterns removed):", "RED as expected" if sab else "still GREEN: blind")
+    return 0 if not first and sab else 1
+
+
+def main(a):
+    if a == ["--selftest"]:
+        return selftest()
+    markers = load()
+    if len(a) == 2 and a[0] == "--msg-file":
+        try:
+            text = open(a[1], encoding="utf-8", errors="replace").read()
+        except OSError as e:
+            print(f"ai-trace-commit-check: {e}", file=sys.stderr)
+            return 2
+        # lines git adds as comments are not part of the message
+        text = "\n".join(l for l in text.splitlines() if not l.startswith("#"))
+        return 1 if report("commit message", text, markers) else 0
+    if len(a) == 2 and a[0] == "--text-file":
+        try:
+            text = open(a[1], encoding="utf-8", errors="replace").read()
+        except OSError as e:
+            print(f"ai-trace-commit-check: {e}", file=sys.stderr)
+            return 2
+        return 1 if report("text", text, markers) else 0
+    if len(a) == 1 and not a[0].startswith("-"):
+        shas = git("rev-list", a[0]).split()
+        bad = 0
+        for sha in shas:
+            bad += report(sha[:12], git("log", "-1", "--format=%B", sha), markers)
+        print(f"ai-trace-commit-check: {len(shas)} commits, {bad} offending lines")
+        return 1 if bad else 0
+    print(__doc__ if False else "usage: ai-trace-commit-check.sh <range> | --msg-file FILE | --text-file FILE | --selftest", file=sys.stderr)
+    return 2
+
+
+try:
+    rc = main(sys.argv[1:])
+except Exception as e:  # a bad or missing pattern file, a decode error: unreadable, never "a hit"
+    print(f"ai-trace-commit-check: {type(e).__name__}: {e}", file=sys.stderr)
+    rc = 2
+sys.exit(rc)
+PY

package/tools/ai-trace-patterns.json

@@ -0,0 +1,33 @@
+{
+ "$comment": "SPDX-License-Identifier: GPL-3.0-or-later. The AI-attribution patterns (Python re, flags IGNORECASE|MULTILINE) read by ai-trace-commit-check.sh. Edit here only.",
+ "markers": [
+  {
+   "name": "robot-footer",
+   "pattern": "^[^\\S\\r\\n]*[_*>]*[^\\S\\r\\n]*🤖[^\\r\\n]*?(?:Claude|claude\\.(?:ai|com))[^\\r\\n]*"
+  },
+  {
+   "name": "generated-footer",
+   "pattern": "(?:🤖[^\\S\\r\\n]*)?Generated[^\\S\\r\\n]+(?:with|by)[^\\S\\r\\n]+\\[?Claude[^\\S\\r\\n]+Code\\]?(?:\\([^)\\s]*\\))?"
+  },
+  {
+   "name": "co-authored-by",
+   "pattern": "Co-Authored-By:[^\\S\\r\\n]*Claude\\b[^\\r\\n<`]*(?:<[^>\\r\\n]*>)?"
+  },
+  {
+   "name": "ai-co-author",
+   "pattern": "Co-Authored-By:[^\\S\\r\\n]*(?:Anthropic|OpenAI|ChatGPT|Copilot|Gemini|Codex|Cursor|Aider|Devin)\\b[^\\r\\n<`]*(?:<[^>\\r\\n]*>)?"
+  },
+  {
+   "name": "anthropic-noreply",
+   "pattern": "noreply@anthropic\\.com"
+  },
+  {
+   "name": "claude-session",
+   "pattern": "Claude-Session:[^\\S\\r\\n]*[^\\s`]*"
+  },
+  {
+   "name": "claude.ai/code",
+   "pattern": "\\[[^\\]\\r\\n]*\\]\\([^\\S\\r\\n]*<?https?://claude\\.ai/code[^)\\s]*>?[^\\S\\r\\n]*\\)|<?https?://claude\\.ai/code\\b[^\\s)>`]*>?"
+  }
+ ]
+}

package/tools/benchmark.py

@@ -1095,7 +1095,7 @@ LV2_WORKER_ERR_NO_SPACE = 3
 class WorkerQueue:
     """The host half of `worker:schedule`: jobs are QUEUED, and run between blocks, off `run()`.
 
-    Spec 2a (`2026-09-25-plugin-qualify.md`): a schedule that accepts a job and
+    A schedule that accepts a job and
     drops it measures an UNBUILT plugin — the Hex Chain amp read 0.9 us/sample that way against 5.4
     built. After every block the host calls `pump(interface)`: the plugin's `work()` for each
     queued job, then `work_response()` with whatever it answered, then `end_run()` once every answer

package/tools/lv2-measure.mjs

@@ -85,6 +85,22 @@ const HELP = `${TOOL_NAME} ${TOOL_VERSION} — measure LV2 plugin latency and CP
   --dry-run               Print the plan and probe nothing.
   --progress-json         Emit machine-readable progress on stderr, one '@progress {...}' per line.
   --help                  This text.
+
+The hosting pass's host features are omx-clap-core's LV2 feature provider; each of its options is
+a flag, passed to every run of lv2_measure and named in each plugin's record (featureOptions):
+
+  --features LIST         Kinds offered: map,unmap,options,bounded,worker,default-state,log
+                          (default: all but default-state; empty: none).
+  --strict                Refuse a plugin requiring a feature not offered, naming it (refusedFeature).
+  --no-strict             Hand it to its own instantiate without it (default).
+  --block-declares LIST   Buf-size declarations when bounded is offered: bounded,fixed,pow2
+                          (default: bounded; empty: none).
+  --block-min N           bufsz:minBlockLength (default: 1; 0: the run's block).
+  --block-max N           bufsz:maxBlockLength (default: 0, the run's block).
+  --block-nominal N       bufsz:nominalBlockLength (default: 0, the maximum).
+  --log MODE              log:log lines: silent, route (to stderr) or capture (into the record)
+                          (default: silent).
+  --log-capture-bytes N   The capture buffer, its NUL included (default: 4096).
 `;
 
 function fail(message, code = 2) {

package/tools/private-refs-check.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+#
+# private-refs-check.sh — this repository is public, so its tracked files state facts and never point
+# into a private repository: no private repository name, no private issue or pull request number, no
+# private branch name or file path, no name of a private specification file. Say what the value is and
+# why instead, and cite only public repositories (omx-dsp, omx-contract, omx-plugins, omx-clap-core, plugin-qualify).
+# Product-name mentions of OpenMixer, and values such as the org.openmixer.* CLAP ids, the
+# urn:openmixer:* LV2 URIs and the @openmixer npm scope, are not pointers and are not matched.
+#
+#   tools/private-refs-check.sh              the check, over every tracked file (generated ones included)
+#   tools/private-refs-check.sh --self-test  each sabotage, in every kind of file, must go red
+#
+# ALLOW lists the tracked files exempt from the check, each with the reason; nothing else is.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")/.." && pwd)"
+
+# <file> — <why it may name them>
+ALLOW=(
+  "tools/private-refs-check.sh"   # it spells the patterns it looks for
+)
+EXTRA_PATHSPEC=()                 # the self-test sets a bad one, to prove a git grep error is red
+
+# Extended regexps, matched case-insensitively. A new kind of pointer is one line here.
+PATTERNS=(
+  'FreeMixer/openmixer([^A-Za-z0-9_-]|$)'             # the private repository
+  'openmixer-ops'                                     # the private operations repository
+  'openmixer ?#[0-9]'                                 # one of its issues or pull requests
+  '[A-Za-z0-9_.]-dev#[0-9]'                           # an issue of a private *-dev repository
+  'integration/[A-Za-z0-9]'                           # a private integration branch
+  'packages/[a-z][a-z0-9-]+'                          # a path into the private repository's packages
+  '\.vue([^A-Za-z0-9_]|$)'                            # its web UI components
+  "openmixer's spec"                                  # its specification files
+  'docs/design/'                                      # its design documents
+  'harness/'                                          # its test harness
+  '20[0-9]{2}-[0-9]{2}-[0-9]{2}-[a-z][a-z0-9-]+\.md'  # a dated specification file name
+  'spec 20[0-9]{2}-[0-9]{2}-[0-9]{2}'                 # a citation of one
+)
+
+check() { # <root>
+  local root="$1" fail=0 args=() p a hits
+  for p in "${PATTERNS[@]}"; do args+=(-e "$p"); done
+  local excl=()
+  for a in "${ALLOW[@]}"; do excl+=(":(exclude)${a%% *}"); done
+  [ -n "$(git -C "$root" ls-files)" ] || { echo "private-refs-check: git lists no file" >&2; return 1; }
+  # git grep exits 1 for no match and 128 or more for an error; an error must not read as "no hits"
+  hits=$(git -C "$root" grep -nIiE "${args[@]}" -- . "${excl[@]}" "${EXTRA_PATHSPEC[@]}") || rc=$?
+  case "${rc:-0}" in 0|1) ;; *) echo "private-refs-check: git grep failed (exit $rc)" >&2; return 1 ;; esac
+  hits=$(printf '%s' "$hits" | cut -c1-200)
+  [ -z "$hits" ] || { printf '%s\n' "$hits" >&2; fail=1; }
+  [ "$fail" = 0 ] || { echo "private-refs-check: the lines above point into private repositories; state the fact instead" >&2; return 1; }
+  echo "private-refs-check: no tracked file points into a private repository"
+}
+
+if [ "${1:-}" = --self-test ]; then
+  scratch="$(mktemp -d)"; trap 'rm -rf "$scratch"' EXIT
+  fail=0
+  # a clean tree with one file of each kind the repository tracks; every sabotage writes one private pointer into one
+  mk() { rm -rf "$scratch/t"; mkdir -p "$scratch/t/src" "$scratch/t/tools" "$scratch/t/docs"
+    git -C "$scratch" init -q t
+    printf 'rdfs:comment "The OpenMixer console x." ;\nlv2:binary <x.so> ; # urn:openmixer:x\n' > "$scratch/t/src/x.ttl"
+    printf '// org.openmixer.x, @openmixer/x\n' > "$scratch/t/tools/gen.mjs"
+    printf '# Docs\n\nOpenMixer plugins.\n' > "$scratch/t/docs/a.md"
+    printf '/* x */\n' > "$scratch/t/src/x.h"; printf '#!/bin/sh\n# x\n' > "$scratch/t/tools/x.sh"; }
+  sab() { # <name> <file> <line>
+    mk; printf '%s\n' "$3" >> "$scratch/t/$2"; git -C "$scratch/t" add -A
+    if check "$scratch/t" >/dev/null 2>&1; then echo "SABOTAGE $1: STAYED GREEN"; fail=1; else echo "SABOTAGE $1: red"; fi; }
+  mk; git -C "$scratch/t" add -A
+  check "$scratch/t" >/dev/null || { echo "self-test: the clean tree is not green" >&2; exit 1; }
+  sab repo-in-header src/x.h                         '/* as FreeMixer/openmixer draws it */'
+  sab branch-in-sh   tools/x.sh                      '# drawn on integration/lean-engine'
+  sab issue-in-md    docs/a.md                       'see openmixer#1580'
+  sab path-in-md     docs/a.md                       'packages/web-ui/Foo.vue'
+  sab default-path   tools/x.sh                      'plugin=${P:-$root/../openmixer/packages/omx-plugins/bin/omx-delay.clap}'
+  sab ops-in-mjs     tools/gen.mjs                   '// see openmixer-ops'
+  sab dev-in-mjs     tools/gen.mjs                   '// omx-dsp-dev#32'
+  sab spec-in-mjs    tools/gen.mjs                   "// openmixer's spec 2026-10-09-plugin-from-contract.md"
+  sab ttl            src/x.ttl       'rdfs:comment "see FreeMixer/openmixer#12" ;'
+  sab header         src/x.h         '/* packages/core/src/x.ts */'
+  sab design-dir     docs/a.md                       'the notes in docs/design/specs'
+  sab harness-dir    tools/gen.mjs                   '// harness/dsp-check.sh'
+  mk; git -C "$scratch/t" add -A
+  if ( EXTRA_PATHSPEC=(":(bogus)x"); check "$scratch/t" >/dev/null 2>&1 ); then echo "SABOTAGE git-grep-error: STAYED GREEN"; fail=1; else echo "SABOTAGE git-grep-error: red"; fi
+  [ "$fail" = 0 ] || exit 1
+  check "$HERE" >/dev/null || { echo "self-test: the repository is not green" >&2; exit 1; }
+  echo "private-refs-check self-test: every sabotage red"
+  exit 0
+fi
+check "$HERE"