@openmixer/plugin-qualify 0.9.0 → 0.11.0

package/src/probe-runner.ts

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * Measuring through plugin-hostd's probe runner (`plugin-hostd-probe run`). The runner starts the
+ * prober under limits (a wall clock that kills the whole process tree, CPU time, memory, files),
+ * and writes the probe output; plugin-qualify waits for the runner and reads the document. No
+ * timeout of ours sits around it: the runner owns the deadline, and a node timer that signalled only
+ * the direct child is exactly what the runner replaces.
+ *
+ * The runner's exit says whether there is a document: 0 and 1 write one (1 is a run whose steps did
+ * not all end well, which the document records), 2 is no document (usage, a required limit
+ * unavailable, an output that could not be written), 3 is no such plugin.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { ClapQualifyError, clapQualifyTools, proberOffer, type RtSafetyDocument } from "./clap-qualify.js";
+import type { HostProfile } from "./host-profiles.js";
+import { OPENMIXER_CONSOLE_PROFILE } from "./host-profiles.js";
+import type { PluginTarget } from "./loader.js";
+import { judgeProbeOutput, judgmentVerdicts, type Judgment } from "./probe-judge.js";
+import { readProbeOutput, type ProbeOutput } from "./probe-output.js";
+import type { QualifyVerdict } from "./qualify-cli.js";
+import {
+  CLAP_QUALIFY_TIMEOUT_S,
+  CLAP_SWEEP_BLOCKS,
+  CLAP_SWEEP_FRAMES,
+  LV2_HOSTING_BLOCK_FRAMES,
+  LV2_HOSTING_TIMEOUT_S,
+  PROBE_RUNNER_DEFAULT,
+  PROBE_RUNNER_ENV,
+} from "./qualify-declarations.js";
+
+export class ProbeRunnerError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ProbeRunnerError";
+  }
+}
+
+/** The runner: the declared setting when set, else the declared default (on `PATH`). */
+export function probeRunnerTool(env: Readonly<Record<string, string | undefined>>): string {
+  const named = env[PROBE_RUNNER_ENV];
+  return named === undefined || named === "" ? PROBE_RUNNER_DEFAULT : named;
+}
+
+/** What one run of the runner gave back; `error` is a spawn failure, `signal` a death. */
+export interface ProbeRunResult {
+  readonly status: number | null;
+  readonly signal?: string | null;
+  readonly stderr?: string;
+  readonly error?: Error;
+}
+
+/** Runs the runner. It is given no time limit of its own, since the runner keeps the deadline. */
+export type ProbeRun = (tool: string, args: readonly string[], env: Readonly<Record<string, string | undefined>>) => ProbeRunResult;
+
+const spawnRunner: ProbeRun = (tool, args, env) => {
+  const r = spawnSync(tool, [...args], { encoding: "utf8", env: { ...env }, maxBuffer: 64 << 20 });
+  return { status: r.status, signal: r.signal, stderr: r.stderr ?? "", ...(r.error === undefined ? {} : { error: r.error }) };
+};
+
+export interface ProbeTargetOptions {
+  /** The rates the plugin is measured at. */
+  readonly rates: readonly number[];
+  /** Host extensions to offer beyond the prober's own (a CLAP run). */
+  readonly offer?: readonly string[];
+  readonly run?: ProbeRun;
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  readonly exists?: (path: string) => boolean;
+}
+
+/** The runner's arguments for a CLAP file; `child` is the prober the runner starts. */
+export function clapRunnerArgs(
+  options: { rates: readonly number[]; offer?: readonly string[]; out: string; log: string; child: string },
+  binaryPath: string,
+  id: string | undefined,
+): string[] {
+  return [
+    "run",
+    "--child",
+    options.child,
+    "--rates",
+    options.rates.join(","),
+    "--quantum",
+    String(CLAP_SWEEP_FRAMES),
+    "--blocks",
+    String(CLAP_SWEEP_BLOCKS),
+    ...(options.offer === undefined || options.offer.length === 0 ? [] : ["--offer", options.offer.join(",")]),
+    "--wall-s",
+    String(CLAP_QUALIFY_TIMEOUT_S),
+    "--out",
+    options.out,
+    "--log",
+    options.log,
+    binaryPath,
+    ...(id === undefined ? [] : [id]),
+  ];
+}
+
+/**
+ * The runner's arguments for an LV2 plugin, named as `lv2:<uri>` and measured by the runner's own LV2
+ * child. The runner of plugin-hostd 0.4.0 starts a CLAP prober only (the LV2 child, plugin-hostd#76, is in no release yet), so
+ * against it this run ends with the runner's own refusal, which {@link runOne} reports.
+ */
+export function lv2RunnerArgs(options: { rates: readonly number[]; out: string; log: string }, uri: string): string[] {
+  return [
+    "run",
+    "--rates",
+    options.rates.join(","),
+    "--quantum",
+    String(LV2_HOSTING_BLOCK_FRAMES),
+    "--wall-s",
+    String(LV2_HOSTING_TIMEOUT_S),
+    "--out",
+    options.out,
+    "--log",
+    options.log,
+    `lv2:${uri}`,
+  ];
+}
+
+/** One probe output and the bytes it was read from (the bytes are what gets copied beside the record). */
+export interface ProbedTarget {
+  readonly bytes: Buffer;
+  readonly output: ProbeOutput;
+}
+
+function runOne(target: PluginTarget, options: ProbeTargetOptions): ProbedTarget {
+  const env = options.env ?? process.env;
+  const tool = probeRunnerTool(env);
+  const work = mkdtempSync(join(tmpdir(), "plugin-qualify-probe-"));
+  const out = join(work, "probe.json");
+  const log = join(work, "child.stderr.log");
+  try {
+    let args: string[];
+    let runEnv: Record<string, string | undefined> = { ...env };
+    let expectedId: string;
+    if (target.format === "clap") {
+      if (target.binaryPath === undefined) throw new ProbeRunnerError(`${target.uri}: no .clap to load; name the file or a directory holding it`);
+      expectedId = target.uri.startsWith("urn:clap:") ? target.uri.slice("urn:clap:".length) : target.uri;
+      const { tool: child, interposer } = clapQualifyTools(env, options.exists ?? existsSync);
+      args = clapRunnerArgs({ rates: options.rates, ...(options.offer === undefined ? {} : { offer: options.offer }), out, log, child }, target.binaryPath, expectedId);
+      runEnv = { ...env, LD_PRELOAD: interposer };
+    } else {
+      expectedId = target.uri;
+      args = lv2RunnerArgs({ rates: options.rates, out, log }, target.uri);
+    }
+    const r = (options.run ?? spawnRunner)(tool, args, runEnv);
+    if (r.error !== undefined) {
+      throw new ProbeRunnerError(`cannot run the probe runner "${tool}" (${r.error.message}): install plugin-hostd or set ${PROBE_RUNNER_ENV} to plugin-hostd-probe`);
+    }
+    if (r.signal) throw new ProbeRunnerError(`${tool} was killed (${r.signal}) measuring ${target.uri}`);
+    const said = (r.stderr ?? "").trim();
+    if (r.status === 3) throw new ProbeRunnerError(`${tool}: no such plugin ${target.uri}${said === "" ? "" : `: ${said}`}`);
+    if (r.status !== 0 && r.status !== 1) {
+      throw new ProbeRunnerError(`${tool} exited ${String(r.status)} measuring ${target.uri}, and wrote no document${said === "" ? "" : `: ${said}`}`);
+    }
+    let bytes: Buffer;
+    try {
+      bytes = readFileSync(out);
+    } catch {
+      throw new ProbeRunnerError(`${tool} exited ${String(r.status)} but wrote no document at the path it was given`);
+    }
+    const read = readProbeOutput(bytes.toString("utf8"));
+    if (!read.ok) throw new ProbeRunnerError(`${tool} wrote a document that is refused (${read.code}): ${read.problem}`);
+    if (read.output.plugin.id !== expectedId) {
+      throw new ProbeRunnerError(`${tool} measured ${read.output.plugin.id} when asked for ${expectedId}: not judged as the plugin asked for`);
+    }
+    return { bytes, output: read.output };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+/** The probe output of one target, through the runner. Throws {@link ProbeRunnerError} when there is none to judge. */
+export function probeTarget(target: PluginTarget, options: ProbeTargetOptions): ProbedTarget {
+  return runOne(target, options);
+}
+
+/** What the pass over a run's targets produced. */
+export interface ProbePass {
+  /** Every probe output that was judged, with its bytes, for the qualification directory. */
+  readonly runs: readonly { readonly bytes: Buffer; readonly judgment: Judgment }[];
+  readonly verdicts: readonly QualifyVerdict[];
+  /** The CLAP documents of today's judge, which the pins file is taken from. */
+  readonly documents: readonly RtSafetyDocument[];
+  /** Each target that could not be measured, with why; its verdict rows read `unknown`, unmeasured. */
+  readonly failures: readonly { readonly uri: string; readonly problem: string }[];
+}
+
+/**
+ * Measure every target through the runner, one run per target and set of offered extensions (a crash
+ * takes only that plugin), and judge each probe output under the profiles whose offer it was taken
+ * with. A CLAP profile the prober cannot stand in for is judged from the run with no offer and reads
+ * `unknown` there, as before. An LV2 plugin has one run for every profile.
+ */
+export function qualifyTargets(
+  targets: readonly PluginTarget[],
+  options: ProbeTargetOptions & { readonly profiles?: readonly HostProfile[] },
+): ProbePass {
+  const profiles = options.profiles ?? [OPENMIXER_CONSOLE_PROFILE];
+  const runs: { bytes: Buffer; judgment: Judgment }[] = [];
+  const verdicts: QualifyVerdict[] = [];
+  const documents: RtSafetyDocument[] = [];
+  const failures: { uri: string; problem: string }[] = [];
+  for (const target of targets) {
+    const byOffer = new Map<string, { offer: readonly string[]; profiles: HostProfile[] }>();
+    for (const profile of profiles) {
+      const offer = target.format === "clap" ? (proberOffer(profile) ?? []) : [];
+      const key = offer.join(",");
+      const entry = byOffer.get(key) ?? { offer, profiles: [] };
+      entry.profiles.push(profile);
+      byOffer.set(key, entry);
+    }
+    const judged = new Map<string, QualifyVerdict>();
+    // a target's runs and documents count only when every one of its runs gave a probe output: one that
+    // failed leaves the target not measured, and then nothing of it is recorded or pinned
+    const targetRuns: { bytes: Buffer; judgment: Judgment }[] = [];
+    try {
+      for (const { offer, profiles: forOffer } of byOffer.values()) {
+        const probed = probeTarget(target, { ...options, offer });
+        const judgment = judgeProbeOutput(probed.output, forOffer);
+        targetRuns.push({ bytes: probed.bytes, judgment });
+        for (const v of judgmentVerdicts(judgment)) judged.set(v.host, v);
+      }
+    } catch (e) {
+      if (!(e instanceof ProbeRunnerError) && !(e instanceof ClapQualifyError)) throw e;
+      failures.push({ uri: target.uri, problem: e.message });
+      for (const profile of profiles) {
+        verdicts.push({ uri: target.uri, host: profile.id, measured: false, rating: "unknown", qualified: false, deciding: "not-measured" });
+      }
+      continue;
+    }
+    for (const r of targetRuns) {
+      runs.push(r);
+      documents.push(...r.judgment.documents);
+    }
+    for (const profile of profiles) verdicts.push(judged.get(profile.id)!);
+  }
+  return { runs, verdicts, documents, failures };
+}

package/src/qualification-record.ts

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The qualification record: what plugin-qualify wrote down about one plugin binary and one offer
+ * after judging its probe output, kept in `qualification_dir`. Evidence, not a constraint: no
+ * reader refuses a descriptor because of it.
+ *
+ * Two files, always together. The record is the judgment; beside it is a byte copy of the probe
+ * output it judged, because the probe directory is runtime and may be wiped. The record names the
+ * copy and the SHA-256 of the copy's bytes, so the facts outlive the run without hostd keeping a
+ * second store, and a reader can tell that the figures it holds are the ones the verdict came from.
+ *
+ * Not yet in the record: the fingerprint of the descriptor's controls, since the descriptor is
+ * written by the scan (stage 5) and plugin-qualify does not read one yet.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { Judgment, RecordReason } from "./probe-judge.js";
+import { sha256Hex, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
+
+export const QUALIFICATION_RECORD_SCHEMA = "plugin-qualify.qualification-record/1";
+
+/** One host's verdict in the record. */
+export interface RecordVerdict {
+  readonly host: string;
+  /** False when the run did not finish: the rating is `unknown` and the reason is the run's outcome. */
+  readonly measured: boolean;
+  readonly rating: string;
+  readonly qualified: boolean;
+  readonly hosting: "in-process" | "isolated";
+  /** The code that decided it; absent for `suitable`. */
+  readonly deciding?: string;
+  readonly reasons: readonly RecordReason[];
+}
+
+export interface QualificationRecord {
+  readonly schema: typeof QUALIFICATION_RECORD_SCHEMA;
+  readonly plugin: { readonly format: string; readonly id: string; readonly name?: string };
+  /** The plugin's version when it was tested; a newer installed one is shown as "tested on X, installed Y". */
+  readonly testedVersion?: string;
+  readonly binary: ProbeOutput["binary"];
+  readonly verdicts: readonly RecordVerdict[];
+  /** The cost reasons at each host's rate and quantum, beside the verdicts. */
+  readonly cost: readonly { readonly host: string; readonly rate: number; readonly quantum: number; readonly reasons: readonly RecordReason[] }[];
+  /** The figures as measured, per rate and quantum. */
+  readonly measurements: { readonly grid: readonly ProbeGridPoint[]; readonly behaviour?: Readonly<Record<string, unknown>> };
+  /** Who measured and when. */
+  readonly tool: Readonly<Record<string, string>>;
+  readonly measuredAt: string;
+  /** The probe output this record judged. */
+  readonly probe: {
+    readonly file: string;
+    readonly sha256: string;
+    readonly bytes: number;
+    readonly protocol: { readonly name: string; readonly version: number };
+    readonly reason?: string;
+    readonly outcome: string;
+    readonly complete: boolean;
+    readonly machineClass: Readonly<Record<string, string | boolean>>;
+    /** Whether the machine met the protocol's optimised profile: a figure that did not is not a reference figure. */
+    readonly meetsProtocol: boolean;
+  };
+}
+
+const safe = (text: string): string => text.replace(/[^A-Za-z0-9._-]/g, "_");
+
+/** `<id>@<version>-<sha256 first 12>.<offer>`: one binary and one offer, whatever the run. */
+export function qualificationBaseName(output: ProbeOutput): string {
+  return `${safe(output.plugin.id)}@${safe(output.plugin.version ?? "unversioned")}-${output.binary.sha256.slice(0, 12)}.${safe(output.offer.id)}`;
+}
+
+export const recordFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.qualification.json`;
+export const probeCopyFileName = (output: ProbeOutput): string => `${qualificationBaseName(output)}.probe.json`;
+
+export function buildQualificationRecord(judgment: Judgment, copy: { file: string; sha256: string; bytes: number }): QualificationRecord {
+  const o = judgment.output;
+  return {
+    schema: QUALIFICATION_RECORD_SCHEMA,
+    plugin: { format: o.plugin.format, id: o.plugin.id, ...(o.plugin.name === undefined ? {} : { name: o.plugin.name }) },
+    ...(o.plugin.version === undefined ? {} : { testedVersion: o.plugin.version }),
+    binary: o.binary,
+    verdicts: judgment.hosts.map((h) => ({
+      host: h.verdict.host,
+      measured: h.verdict.measured,
+      rating: h.verdict.rating,
+      qualified: h.verdict.qualified,
+      hosting: h.hosting,
+      ...(h.verdict.deciding === undefined ? {} : { deciding: h.verdict.deciding }),
+      reasons: h.reasons,
+    })),
+    cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),
+    measurements: { grid: o.grid, ...(o.behaviour === undefined ? {} : { behaviour: o.behaviour }) },
+    tool: o.run.tools,
+    measuredAt: o.run.startedAt,
+    probe: {
+      file: copy.file,
+      sha256: copy.sha256,
+      bytes: copy.bytes,
+      protocol: o.run.protocol,
+      ...(o.run.reason === undefined ? {} : { reason: o.run.reason }),
+      outcome: o.run.outcome,
+      complete: o.run.complete,
+      machineClass: o.machine.class,
+      meetsProtocol: o.machine.profile.meetsProtocol,
+    },
+  };
+}
+
+/** The record of a judgment, with the copy fields taken from the bytes that were judged. */
+export function qualificationRecordOf(probeBytes: Uint8Array, judgment: Judgment): QualificationRecord {
+  return buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(probeBytes), bytes: probeBytes.length });
+}
+
+/** A file whole or not at all: written beside its name and renamed over it. */
+function writeWhole(path: string, bytes: string | Uint8Array): void {
+  const pending = `${path}.new`;
+  writeFileSync(pending, bytes);
+  renameSync(pending, path);
+}
+
+export interface WrittenQualification {
+  readonly recordPath: string;
+  readonly probePath: string;
+  readonly record: QualificationRecord;
+}
+
+/**
+ * Write the byte copy of the probe output, then the record that names it. The copy goes first, and the
+ * record names the SHA-256 of the copy as it is on disk, read back, so a record never names bytes that
+ * are not there. A rescan of the same binary and offer replaces both.
+ */
+export function writeQualification(dir: string, probeBytes: Uint8Array, judgment: Judgment): WrittenQualification {
+  mkdirSync(dir, { recursive: true });
+  const probePath = join(dir, probeCopyFileName(judgment.output));
+  writeWhole(probePath, probeBytes);
+  const copy = readFileSync(probePath);
+  const record = buildQualificationRecord(judgment, { file: probeCopyFileName(judgment.output), sha256: sha256Hex(copy), bytes: copy.length });
+  const recordPath = join(dir, recordFileName(judgment.output));
+  writeWhole(recordPath, `${JSON.stringify(record, null, 2)}\n`);
+  return { recordPath, probePath, record };
+}

package/src/qualify-cli.ts

@@ -118,7 +118,7 @@ export function helpText(): string {
     "  plugin-qualify <uri|bundle-path>...   exactly the named plugins; a .lv2 bundle = every plugin in it",
     "  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",
+    "                                        whose plugins --all does not enumerate: name them instead",
     "",
     ...rows,
     "",

package/src/qualify-declarations.ts

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+import { ORACLE_FLOOR_RATES, RT_HARD_TARGET } from "@openmixer/omx-contract";
+
 /**
  * EVERY NUMBER plugin-qualify uses, declared once. The CLI's defaults and `--help`, the rating, and the Python tools (through the generated
  * `tools/_declarations.py`) all READ these; a consumer holding its own copy is what the package's
@@ -26,11 +28,11 @@ export const MEASURE_BASE_RATE = 48000;
  */
 export const OPERATIONAL_RATE_FLOOR = 48000;
 
-/** The rates a run measures when `--rates` is not given — recorded in `run.rates`. */
-export const QUALIFY_RATES: readonly number[] = [44100, MEASURE_BASE_RATE, COST_REFERENCE_RATE, 192000];
+/** The rates a run measures when `--rates` is not given — recorded in `run.rates`: omx-contract's ORACLE_FLOOR_RATES. */
+export const QUALIFY_RATES: readonly number[] = ORACLE_FLOOR_RATES;
 
-/** The quanta (frames) a run rates cost at when `--quanta` is not given. */
-export const QUALIFY_QUANTA: readonly number[] = [128, 256, 512, QUANTUM_FRAMES];
+/** The quanta (frames) a run rates cost at when `--quanta` is not given: the contract's hard-target quantum, then 256, 512 and the reference. */
+export const QUALIFY_QUANTA: readonly number[] = [RT_HARD_TARGET.quantum, 256, 512, QUANTUM_FRAMES];
 
 /** Seconds one plugin's offline pass may take before its worker is killed and it reads as a timeout. */
 export const PLUGIN_TIMEOUT_S = 15;
@@ -77,23 +79,37 @@ export const CLAP_SCAN_TOOL_DEFAULT = "omx-clap-scan";
 export const CLAP_PATH_ENV = "CLAP_PATH";
 export const CLAP_USER_DIR = ".clap";
 export const CLAP_SYSTEM_DIR = "/usr/lib/clap";
+/** Names a directory to read in place of `CLAP_SYSTEM_DIR`: a package root, or a test that must not see what the host installed there. */
+export const CLAP_SYSTEM_DIR_ENV = "OMX_CLAP_SYSTEM_DIR";
+
+/**
+ * The ONE setting that locates plugin-hostd's probe runner: the environment variable that names the
+ * `plugin-hostd-probe` binary, and what is run when it is unset (looked up on `PATH`). The runner is
+ * plugin-hostd's, not a tool of this package, so it is not one of `NATIVE_TOOLS`.
+ */
+export const PROBE_RUNNER_ENV = "OMX_PROBE_RUNNER";
+export const PROBE_RUNNER_DEFAULT = "plugin-hostd-probe";
 
 /** 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.
@@ -103,6 +119,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 },
 ];
 
 /**
@@ -162,7 +179,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 };
@@ -173,10 +190,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/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)>`]*>?"
+  }
+ ]
+}