@openmixer/plugin-qualify 0.18.0 → 0.18.1

package/fixtures/records-0.16.1/in.lsp-plug.impulse_responses_mono@unversioned-d5235d2f5f53.custom.qualification.json

@@ -0,0 +1,145 @@
+{
+  "schema": "plugin-qualify.qualification-record/1",
+  "plugin": {
+    "format": "clap",
+    "id": "in.lsp-plug.impulse_responses_mono"
+  },
+  "binary": {
+    "path": "/usr/lib/clap/lsp-plugins.clap",
+    "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2",
+    "files": [
+      {
+        "path": "lsp-plugins.clap",
+        "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"
+      }
+    ],
+    "layout": {
+      "scheme": "omx-layout/1",
+      "sha256": "86f71f835f0db0150b6b219b738b97ae0d9d423d2305e29ebdb172b8e20a6381"
+    }
+  },
+  "verdicts": [
+    {
+      "host": "omx-clap-host",
+      "measured": true,
+      "rating": "unsuitable",
+      "qualified": false,
+      "hosting": "isolated",
+      "arm": "declaration",
+      "deciding": "hosting.rt-safety.violations-in-run",
+      "reasons": [
+        {
+          "dimension": "rtSafety",
+          "rating": "unsuitable",
+          "code": "hosting.rt-safety.violations-in-run",
+          "params": {
+            "allocations": 0,
+            "syscalls": 1,
+            "locks": 0
+          }
+        }
+      ]
+    }
+  ],
+  "tiers": {
+    "isolated": {
+      "host": "omx-clap-host",
+      "measured": true,
+      "qualified": false,
+      "rating": "unsuitable",
+      "deciding": "hosting.rt-safety.violations-in-run"
+    },
+    "offeredOn": [],
+    "dimmed": "omx-clap-host: hosting.rt-safety.violations-in-run"
+  },
+  "cost": [
+    {
+      "host": "omx-clap-host",
+      "rate": 48000,
+      "quantum": 128,
+      "reasons": [
+        {
+          "dimension": "cost",
+          "rating": "unknown",
+          "code": "hosting.cost.unmeasured-at-rate-and-quantum",
+          "params": {
+            "rate": 48000,
+            "quantum": 128
+          }
+        }
+      ]
+    }
+  ],
+  "measurements": {
+    "grid": [
+      {
+        "rate": 48000,
+        "quantum": 512,
+        "outcome": "probe.ok",
+        "latency": {
+          "declaredFrames": 0,
+          "measuredFrames": 0
+        },
+        "cost": {
+          "median": 213.506,
+          "percentile": {
+            "p": 95,
+            "value": 230.143
+          },
+          "blocks": 512,
+          "warmupBlocks": 64
+        },
+        "rtSafety": {
+          "interposer": true,
+          "swept": true,
+          "sweepApplicable": true,
+          "blocks": 512,
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 1,
+          "threadViolations": 0,
+          "processErrors": 0,
+          "events": [
+            "nanosleep"
+          ]
+        },
+        "noteSweep": {
+          "applicable": false
+        }
+      }
+    ]
+  },
+  "notMeasured": [
+    {
+      "dimension": "stability",
+      "code": "hosting.stability.unsoaked"
+    }
+  ],
+  "tool": {
+    "runner": "plugin-hostd-probe 0.13.1",
+    "child": "clap-qualify",
+    "interposer": "rt_interpose.so"
+  },
+  "measuredAt": "2026-10-28T20:56:58+00:00",
+  "probe": {
+    "file": "in.lsp-plug.impulse_responses_mono@unversioned-d5235d2f5f53.custom.probe.json",
+    "sha256": "bc818dfeff46238de3b5558ab8d54aa5677a18f6e3cad79c67bc117313d0a79d",
+    "bytes": 3894,
+    "protocol": {
+      "name": "plugin-hostd.probe-protocol",
+      "version": 1
+    },
+    "reason": "on-request",
+    "outcome": "probe.ok",
+    "complete": true,
+    "machineClass": {
+      "arch": "aarch64",
+      "family": "arm",
+      "coreBand": "3-4",
+      "clockBand": "1.5-2.5GHz",
+      "preemptRt": false,
+      "cstatesLimited": false
+    },
+    "meetsProtocol": false
+  }
+}

package/fixtures/records-0.16.1/in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.probe.json

@@ -0,0 +1,52 @@
+{
+  "format": "plugin-hostd.probe-output",
+  "formatVersion": "1.1",
+  "run": {
+    "id": "20261028T210152Z-321dd-bb8cc3c7",
+    "startedAt": "2026-10-28T21:01:52+00:00",
+    "elapsedMs": 332,
+    "complete": true,
+    "outcome": "probe.ok",
+    "reason": "on-request",
+    "protocol": {"name": "plugin-hostd.probe-protocol", "version": 1},
+    "tools": {"runner": "plugin-hostd-probe 0.13.1", "child": "clap-qualify", "interposer": "rt_interpose.so"},
+    "via": "runner"
+  },
+  "plugin": {"format": "clap", "id": "in.lsp-plug.trigger_midi_mono"},
+  "binary": {"path": "/usr/lib/clap/lsp-plugins.clap", "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2", "files": [{"path": "lsp-plugins.clap", "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"}], "layout": {"scheme": "omx-layout/1", "sha256": "5a2b073f777379e75dcd931ff9930352d12dcfab9e1fb599d3b1d45d62fe3e1d"}},
+  "machine": {
+    "class": {"arch": "aarch64", "family": "arm", "coreBand": "3-4", "clockBand": "1.5-2.5GHz", "preemptRt": false, "cstatesLimited": false},
+    "profile": {"governor": "powersave", "turbo": false, "smt": false, "preempt": "PREEMPT",
+      "cpuidle": [],
+      "meetsProtocol": false, "unmet": ["probe.profile.governor", "probe.profile.not-pinned"]},
+    "pinnedCpus": "0-3"
+  },
+  "offer": {"id": "custom", "clapExtensions": ["clap.log", "clap.thread-check", "clap.latency", "clap.params", "clap.audio-ports", "clap.state", "clap.note-ports", "clap.note-name", "clap.voice-info", "clap.event-registry", "clap.timer-support", "clap.posix-fd-support", "clap.thread-pool", "clap.tail", "clap.surround/4", "clap.ambisonic/3", "clap.audio-ports-config", "clap.preset-load/2", "clap.track-info/1", "clap.remote-controls/2"], "realtime": "none"},
+  "limits": {"set": "default",
+    "applied": [
+      {"limit": "wall-clock", "value": 60, "unit": "s", "by": "supervisor"},
+      {"limit": "cpu-time", "value": 540, "unit": "s", "by": "rlimit"},
+      {"limit": "memory", "value": 4294967296, "unit": "bytes", "by": "rlimit"},
+      {"limit": "files", "value": 256, "unit": "count", "by": "rlimit"},
+      {"limit": "file-size", "value": 67108864, "unit": "bytes", "by": "rlimit"},
+      {"limit": "core-dump", "value": 0, "unit": "bytes", "by": "rlimit"},
+      {"limit": "rt-priority", "value": 0, "by": "rlimit"},
+      {"limit": "no-new-privs", "by": "prctl"}
+    ],
+    "unavailable": [
+      {"limit": "tasks", "code": "probe.limit.not-implemented"}
+    ]
+  },
+  "steps": [
+    {"step": "hash", "outcome": "probe.ok", "elapsedMs": 0},
+    {"step": "lifecycle", "outcome": "probe.ok", "elapsedMs": 332, "exitStatus": 0},
+    {"step": "instantiate", "outcome": "probe.ok", "elapsedMs": 0, "detail": "read from the child's line"},
+    {"step": "latency", "rate": 48000, "quantum": 512, "outcome": "probe.ok", "elapsedMs": 0, "detail": "read from the child's line"},
+    {"step": "rt-safety", "outcome": "probe.ok", "elapsedMs": 0, "detail": "counts are totals over every rate, read from the child's line"},
+    {"step": "note-sweep", "outcome": "probe.ok", "elapsedMs": 0, "detail": "counts are totals over every rate, read from the child's line"}
+  ],
+  "grid": [
+    {"rate": 48000, "quantum": 512, "outcome": "probe.ok", "latency": {"declaredFrames": 0, "measuredFrames": 0, "method": "impulse-onset"}, "cost": {"unit": "ns-per-sample", "median": 47.9961, "percentile": {"p": 95, "value": 57.2365}, "min": 31.5742, "max": 114.258, "blocks": 512, "warmupBlocks": 64}, "rtSafety": {"interposer": true, "swept": true, "sweepApplicable": true, "blocks": 512, "allocations": 0, "locks": 0, "syscalls": 0, "threadViolations": 0, "processErrors": 0, "events": []}, "noteSweep": {"applicable": true, "dialect": "midi", "allocations": 0, "locks": 0, "syscalls": 1}}
+  ],
+  "logs": [{"name": "stderr", "path": "/tmp/plugin-qualify-probe-0t8B87/child.stderr.log", "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "bytes": 0}]
+}

package/fixtures/records-0.16.1/in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.qualification.json

@@ -0,0 +1,155 @@
+{
+  "schema": "plugin-qualify.qualification-record/1",
+  "plugin": {
+    "format": "clap",
+    "id": "in.lsp-plug.trigger_midi_mono"
+  },
+  "binary": {
+    "path": "/usr/lib/clap/lsp-plugins.clap",
+    "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2",
+    "files": [
+      {
+        "path": "lsp-plugins.clap",
+        "sha256": "d5235d2f5f53eb3641dc9225ff5a912b5eae718cd0abbecd46350dba666f19a2"
+      }
+    ],
+    "layout": {
+      "scheme": "omx-layout/1",
+      "sha256": "5a2b073f777379e75dcd931ff9930352d12dcfab9e1fb599d3b1d45d62fe3e1d"
+    }
+  },
+  "verdicts": [
+    {
+      "host": "omx-clap-host",
+      "measured": true,
+      "rating": "unsuitable",
+      "qualified": false,
+      "hosting": "isolated",
+      "arm": "declaration",
+      "deciding": "hosting.rt-safety.violations-under-notes",
+      "reasons": [
+        {
+          "dimension": "rtSafety",
+          "rating": "suitable",
+          "code": "hosting.rt-safety.clean-under-sweep",
+          "params": {
+            "blocks": 512
+          }
+        },
+        {
+          "dimension": "rtSafety",
+          "rating": "unsuitable",
+          "code": "hosting.rt-safety.violations-under-notes",
+          "params": {
+            "allocations": 0,
+            "syscalls": 1,
+            "locks": 0
+          }
+        }
+      ]
+    }
+  ],
+  "tiers": {
+    "isolated": {
+      "host": "omx-clap-host",
+      "measured": true,
+      "qualified": false,
+      "rating": "unsuitable",
+      "deciding": "hosting.rt-safety.violations-under-notes"
+    },
+    "offeredOn": [],
+    "dimmed": "omx-clap-host: hosting.rt-safety.violations-under-notes"
+  },
+  "cost": [
+    {
+      "host": "omx-clap-host",
+      "rate": 48000,
+      "quantum": 128,
+      "reasons": [
+        {
+          "dimension": "cost",
+          "rating": "unknown",
+          "code": "hosting.cost.unmeasured-at-rate-and-quantum",
+          "params": {
+            "rate": 48000,
+            "quantum": 128
+          }
+        }
+      ]
+    }
+  ],
+  "measurements": {
+    "grid": [
+      {
+        "rate": 48000,
+        "quantum": 512,
+        "outcome": "probe.ok",
+        "latency": {
+          "declaredFrames": 0,
+          "measuredFrames": 0
+        },
+        "cost": {
+          "median": 47.9961,
+          "percentile": {
+            "p": 95,
+            "value": 57.2365
+          },
+          "blocks": 512,
+          "warmupBlocks": 64
+        },
+        "rtSafety": {
+          "interposer": true,
+          "swept": true,
+          "sweepApplicable": true,
+          "blocks": 512,
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 0,
+          "threadViolations": 0,
+          "processErrors": 0,
+          "events": []
+        },
+        "noteSweep": {
+          "applicable": true,
+          "dialect": "midi",
+          "allocations": 0,
+          "locks": 0,
+          "syscalls": 1
+        }
+      }
+    ]
+  },
+  "notMeasured": [
+    {
+      "dimension": "stability",
+      "code": "hosting.stability.unsoaked"
+    }
+  ],
+  "tool": {
+    "runner": "plugin-hostd-probe 0.13.1",
+    "child": "clap-qualify",
+    "interposer": "rt_interpose.so"
+  },
+  "measuredAt": "2026-10-28T21:01:52+00:00",
+  "probe": {
+    "file": "in.lsp-plug.trigger_midi_mono@unversioned-d5235d2f5f53.custom.probe.json",
+    "sha256": "17986ad33bc5087175fcce9512761cc28fb66d18beb01598ee2e72b5c5302fa6",
+    "bytes": 3978,
+    "protocol": {
+      "name": "plugin-hostd.probe-protocol",
+      "version": 1
+    },
+    "reason": "on-request",
+    "outcome": "probe.ok",
+    "complete": true,
+    "machineClass": {
+      "arch": "aarch64",
+      "family": "arm",
+      "coreBand": "3-4",
+      "clockBand": "1.5-2.5GHz",
+      "preemptRt": false,
+      "cstatesLimited": false
+    },
+    "meetsProtocol": false
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/plugin-qualify",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "Qualify audio plugins for real-time hosting: scan, offline latency and cost measurement, and a fail-closed rating.",
   "type": "module",
   "license": "GPL-3.0-or-later",

package/src/distributed-records.ts

@@ -153,7 +153,7 @@ export function distributedUri(item: SyncItem, r: DistributedRecord): string {
 }
 
 /** What the sync's own judgment would make of the record's verdict for the host, as `outcomeOf` reads a run. */
-function outcomeOfVerdict(v: RecordVerdict): SyncOutcome {
+export function outcomeOfVerdict(v: Pick<RecordVerdict, "measured" | "rating" | "deciding">): SyncOutcome {
   if (!v.measured) return v.deciding === "probe.crashed" ? "crashed" : v.deciding === "probe.timeout" ? "hung" : "unmeasured";
   if (v.rating === "suitable" || v.rating === "conditional") return "qualified";
   return v.rating === "unsuitable" ? "refused" : "unmeasured";

package/src/host-admission.ts

@@ -12,6 +12,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 import type { HostProfile } from "./host-profiles.js";
+import { ADMIT_STEP_MS_ENV } from "./qualify-declarations.js";
 
 /** The profile ids whose verdict is measured by a run. */
 export const ADMITTED_HOSTS = ["mod-host", "jalv"] as const;
@@ -29,13 +30,16 @@ export function admittedHostOf(profile: HostProfile): AdmittedHost | undefined {
  */
 export const ADAPTER_HOST = "omx-clap-host";
 
+/** The profiles whose LV2 plugins run under that adapter: omx-clap-host, and the Pi boards it runs on (`host-profiles.ts`). */
+export const ADAPTER_RUN_HOSTS: readonly string[] = [ADAPTER_HOST, "openmixer-pi-4gb", "openmixer-pi-8gb"];
+
 /**
  * Whether this run decides the profile's verdict for a plugin of this format. A mod-host or jalv run always does, an
  * unmeasured one making the verdict unknown; the adapter's only when it measured, since the omx-clap-host verdict
  * otherwise stands on the measurement.
  */
 export function runDecides(profile: HostProfile, format: string, admission: HostAdmission): boolean {
-  return admittedHostOf(profile) !== undefined || (profile.id === ADAPTER_HOST && format === "lv2" && admission.measured);
+  return admittedHostOf(profile) !== undefined || (ADAPTER_RUN_HOSTS.includes(profile.id) && format === "lv2" && admission.measured);
 }
 
 /** What running the plugin under one host came to. */
@@ -144,7 +148,10 @@ const MOD_HOST_ADMIT = fileURLToPath(new URL("../tools/mod-host-admit.mjs", impo
 /** The runs against the installed hosts. */
 export const SPAWNED_ADMISSIONS: AdmissionRuns = {
   adapter(uri, env) {
-    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout: MOD_HOST_ADMISSION_MS, ...(env === undefined ? {} : { env: { ...env } }) });
+    // two commands at the limit the pass gives each, and the tool's own start and end: it kills the host itself first
+    const stepMs = Number(env?.[ADMIT_STEP_MS_ENV] ?? 0);
+    const timeout = stepMs > 0 ? 2 * stepMs + 15000 : MOD_HOST_ADMISSION_MS;
+    const r = spawnSync(process.execPath, [MOD_HOST_ADMIT, uri, ADAPTER_HOST], { encoding: "utf8", timeout, killSignal: "SIGKILL", ...(env === undefined ? {} : { env: { ...env } }) });
     if (r.error !== undefined || r.status !== 0) {
       throw new Error(`${ADAPTER_HOST} admission of ${uri} gave no answer (${r.error?.message ?? `exit ${String(r.status)}`}): ${(r.stderr ?? "").trim()}`);
     }
@@ -158,7 +165,10 @@ export const SPAWNED_ADMISSIONS: AdmissionRuns = {
     return JSON.parse(r.stdout) as ModHostRun;
   },
   jalv(uri, env) {
-    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, input: "", ...(env === undefined ? {} : { env: { ...env } }) });
+    // SIGKILL at the deadline: jalv hosting some plugins ignores SIGTERM, and one stuck in jack_client_open never reaches
+    // the loop that reads the flag TERM sets, so a TERM left spawnSync waiting with it (#187). Alive at the deadline is
+    // all the verdict asks, so nothing is lost by not letting it exit cleanly.
+    const r = spawnSync("jalv", ["-n", "plugin-qualify", uri], { encoding: "utf8", timeout: JALV_HOSTED_MS, killSignal: "SIGKILL", input: "", ...(env === undefined ? {} : { env: { ...env } }) });
     const code = (r.error as NodeJS.ErrnoException | undefined)?.code;
     if (code === "ENOENT") return { installed: false, stillRunning: false, status: null, signal: null, stderr: "" };
     return { installed: true, stillRunning: code === "ETIMEDOUT", status: r.status, signal: code === "ETIMEDOUT" ? null : r.signal, stderr: r.stderr ?? "" };

package/src/index.ts

@@ -31,6 +31,8 @@ export * from "./probe-merge.js";
 export * from "./judge-cli.js";
 export * from "./whole-file.js";
 export * from "./qualify-sync.js";
+export * from "./qualify-rejudge.js";
+export * from "./qualify-adapter-pass.js";
 export * from "./distributed-records.js";
 export * from "./records-package.js";
 export * from "./host-admission.js";

package/src/probe-judge.ts

@@ -51,6 +51,11 @@ export interface JudgeFacts {
    * judged by it as well as by its declaration; one that has none is judged from its declaration alone.
    */
   readonly admissions?: Readonly<Record<string, HostAdmission>>;
+  /**
+   * The run each profile's verdict needs and the figures do not hold, by profile id (`qualify-rejudge.ts`): an `unknown`
+   * reason in that verdict, so that a verdict never claims a run nobody made.
+   */
+  readonly owed?: Readonly<Record<string, RecordReason>>;
 }
 
 /** A sum of one count over the points, or `undefined` when a point lacks it: a missing count is not zero. */
@@ -244,7 +249,7 @@ function costOf(output: ProbeOutput, profile: HostProfile): HostJudgment["cost"]
  * first word; a grid point that failed under a run that says `probe.ok` is a document that contradicts
  * itself, and is read as the failure it records rather than as a pass that skipped the point.
  */
-function failedOutcome(output: ProbeOutput): string | undefined {
+export function failedOutcome(output: ProbeOutput): string | undefined {
   if (output.run.outcome !== PROBE_OK) return output.run.outcome;
   // a cell that outgrew the memory bound is a recorded outcome of that cell, judged per host below, not the run's end
   return output.grid.find((p) => p.outcome !== PROBE_OK && p.outcome !== PROBE_NOT_ATTEMPTED && !isOutOfMemory(p.outcome))?.outcome;
@@ -313,6 +318,8 @@ export function judgeProbeOutput(output: ProbeOutput, profiles: readonly HostPro
         };
       }
     }
+    const owed = facts.owed?.[profile.id];
+    if (owed !== undefined) reasons = [owed, ...reasons];
     const rating = worstRating(reasons.map((r) => r.rating));
     const deciding = decidingOf(reasons, rating);
     return {

package/src/probe-runner.ts

@@ -22,7 +22,7 @@ import type { HostProfile } from "./host-profiles.js";
 import { OPENMIXER_CONSOLE_PROFILE, shippedHostProfile } from "./host-profiles.js";
 import { IN_PROCESS_TIER_HOST, ISOLATED_TIER_HOST } from "./qualification-record.js";
 import type { PluginTarget } from "./loader.js";
-import { ADAPTER_HOST, SPAWNED_ADMISSIONS, admitPlugin, admitUnderAdapter, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
+import { ADAPTER_RUN_HOSTS, SPAWNED_ADMISSIONS, admitPlugin, admitUnderAdapter, admittedHostOf, type AdmissionRuns, type HostAdmission } from "./host-admission.js";
 import { judgeProbeOutput, judgmentVerdicts, type Judgment } from "./probe-judge.js";
 import { readProbeOutput, type ProbeOutput } from "./probe-output.js";
 import { budgetCells, gridCells, hostCells, runnerInvocations, type GridCell, type GridSpec, type RunnerInvocation } from "./measurement-grid.js";
@@ -299,7 +299,7 @@ export function qualifyTargets(
     // an LV2 plugin is also run once under plugin-hostd's LV2 adapter, recorded beside the verdicts (#223)
     const adapter = target.format === "lv2" ? admitUnderAdapter(target.uri, admissionRuns, admissionEnv) : undefined;
     // and that run decides its omx-clap-host verdict, the isolated tier
-    if (adapter !== undefined) admissions[ADAPTER_HOST] = adapter;
+    if (adapter !== undefined) for (const host of ADAPTER_RUN_HOSTS) admissions[host] = adapter;
     if (target.format === "lv2") {
       for (const profile of judgedProfiles) {
         const host = admittedHostOf(profile);

package/src/qualification-record.ts

@@ -43,6 +43,28 @@ export interface RecordVerdict {
   readonly reasons: readonly RecordReason[];
 }
 
+/**
+ * An LV2 plugin's run under the adapter. The top is what the judge reads. `--adapter-only` adds the versions of the hosts
+ * it ran under, when, and how each cell went.
+ */
+export interface AdapterBlock {
+  readonly host: string;
+  readonly measured: boolean;
+  readonly admitted: boolean;
+  readonly code?: string;
+  readonly params: Readonly<Record<string, string | number>>;
+  readonly versions?: Readonly<Record<string, string>>;
+  readonly measuredAt?: string;
+  readonly cells?: readonly {
+    readonly rate: number;
+    readonly quantum: number;
+    readonly measured: boolean;
+    readonly admitted: boolean;
+    readonly code?: string;
+    readonly params: Readonly<Record<string, string | number>>;
+  }[];
+}
+
 /** One tier of the console as a verdict: the host it is judged under and whether the plugin qualified there. */
 export interface TierVerdict {
   readonly host: string;
@@ -50,9 +72,15 @@ export interface TierVerdict {
   readonly qualified: boolean;
   readonly rating: string;
   readonly deciding?: string;
+  /** The isolated tier of a `conditional` plugin: it is offered, and runs alone in a worker of its own, never grouped. */
+  readonly runsAlone?: true;
 }
 
-/** The console's two tiers (what the console's roster offers): offered where the verdict qualified, dimmed with the reason when neither did. */
+/**
+ * The console's two tiers (what the console's roster offers): in-process where its verdict qualified; isolated where its
+ * verdict qualified or is `conditional`, which pins `isolated` and runs alone (`runsAlone`); dimmed with the reason when
+ * neither. `qualified` stays `rating === "suitable"`, as the interchange's reader holds it.
+ */
 export interface RecordTiers {
   readonly inProcess?: TierVerdict;
   readonly isolated?: TierVerdict;
@@ -117,8 +145,11 @@ const word = (key: keyof typeof MEASUREMENT_UNMEASURED_REASONS): string => MEASU
 /** The same, for the test. */
 export const memoryOfCellForTest = (p: ProbeGridPoint): Pick<RecordGridPoint, "memory"> => memoryOfCell(p);
 
+/** The contract's word for a cell whose run ended with this outcome, `probe-error` for one it has no word of. */
+export const unmeasuredWordOf = (outcome: string): string => OUTCOME_WORD[outcome] ?? word("probeError");
+
 /** A cell's footprint with what it comes to; only a footprint with no reason beside it comes to anything a client may add up. */
-function memoryOfCell(p: ProbeGridPoint): Pick<RecordGridPoint, "memory"> {
+export function memoryOfCell(p: ProbeGridPoint): Pick<RecordGridPoint, "memory"> {
   if (p.memory === undefined) return {};
   const first = p.memory.unmeasuredReason === undefined ? firstInstanceKb(p.memory) : undefined;
   const per = p.memory.unmeasuredReason === undefined ? perInstanceKb(p.memory) : undefined;
@@ -181,6 +212,51 @@ export interface HistoryBlock {
   readonly verdicts: readonly ({ readonly host: string } & Adjustment)[];
 }
 
+/** One measurement a record lacks, and what it keeps from being decided. */
+export interface OwedMeasurement {
+  /** `adapter-run`: the plugin under omx-clap-host's LV2 adapter. `host-run`: under the host named. `qualification`: the whole of it. */
+  readonly measurement: "adapter-run" | "host-run" | "qualification";
+  readonly host?: string;
+  readonly code: string;
+  readonly detail?: string;
+}
+
+/**
+ * The verdicts are not the ones of the run that took the figures: `plugin-qualify-sync --rejudge` derived them later, from
+ * those figures, under the rules of `by`. `figures` says who took the figures and when; the verdicts claim nothing more.
+ */
+export interface RejudgedBlock {
+  /** The UTC time the verdicts last changed. */
+  readonly at: string;
+  /** The plugin-qualify whose rules judged them. */
+  readonly by: string;
+  readonly figures: {
+    readonly tool: Readonly<Record<string, string>>;
+    readonly measuredAt: string;
+    readonly runId: string;
+    /** The footprints, when a memory-only pass took them later than the rest. */
+    readonly memory?: { readonly tool: Readonly<Record<string, string>>; readonly measuredAt: string };
+    /** The adapter run, when an adapter-only pass took it later than the rest. */
+    readonly adapter?: { readonly versions: Readonly<Record<string, string>>; readonly measuredAt: string };
+  };
+  /** What these verdicts could not decide and left `unknown`; absent when nothing is owed. */
+  readonly owes?: readonly OwedMeasurement[];
+}
+
+/** The memory-only pass that took this record's footprints: every other figure is older and comes from `tool`. */
+export interface MemoryRunBlock {
+  readonly tool: Readonly<Record<string, string>>;
+  readonly measuredAt: string;
+  readonly runId: string;
+  readonly cells: readonly {
+    readonly rate: number;
+    readonly quantum: number;
+    /** How the cell's run ended; its figures are in the grid's point of that cell. */
+    readonly outcome: string;
+    readonly memoryLimit?: { readonly bytes: number; readonly mechanism: string };
+  }[];
+}
+
 export interface QualificationRecord {
   readonly schema: typeof QUALIFICATION_RECORD_SCHEMA;
   readonly plugin: { readonly format: string; readonly id: string; readonly name?: string };
@@ -192,7 +268,7 @@ export interface QualificationRecord {
    * An LV2 plugin run under plugin-hostd's LV2 adapter (omx-clap-host), as under mod-host: admitted, or refused with
    * its code, or `measured: false` when it was not tried. Beside the verdicts, which it does not change (#223).
    */
-  readonly adapter?: { readonly host: string; readonly measured: boolean; readonly admitted: boolean; readonly code?: string; readonly params: Readonly<Record<string, string | number>> };
+  readonly adapter?: AdapterBlock;
   readonly tiers: RecordTiers;
   /** The cost reasons at each host's rate and quantum, beside the verdicts; an instrument's with the notes it held. */
   readonly cost: readonly {
@@ -223,6 +299,10 @@ export interface QualificationRecord {
   readonly history?: readonly HistoryBlock[];
   /** Where the record came from when it was not measured on this device: the distributed set's provenance, as the set's package wrote it. */
   readonly provenance?: Readonly<Record<string, unknown>>;
+  /** Present when the verdicts were derived later from the figures below, measuring nothing. */
+  readonly rejudged?: RejudgedBlock;
+  /** Present when a memory-only pass merged footprints into the grid. */
+  readonly memoryRun?: MemoryRunBlock;
   /** The probe output this record judged. */
   readonly probe: {
     readonly file: string;
@@ -264,18 +344,32 @@ function tierOf(judgment: Judgment, host: string | undefined): TierVerdict | und
 export function tiersOf(judgment: Judgment): RecordTiers {
   const inProcess = tierOf(judgment, IN_PROCESS_TIER_HOST);
   const isolated = tierOf(judgment, ISOLATED_TIER_HOST[judgment.output.plugin.format]);
+  const runsAlone = isolated?.measured === true && isolated.rating === "conditional";
   const offeredOn: ("in-process" | "isolated")[] = [];
   if (inProcess?.qualified === true) offeredOn.push("in-process");
-  if (isolated?.qualified === true) offeredOn.push("isolated");
+  if (isolated?.qualified === true || runsAlone) offeredOn.push("isolated");
   const why = [inProcess, isolated].flatMap((t) => (t === undefined ? [] : [`${t.host}: ${t.deciding ?? t.rating}`]));
   return {
     ...(inProcess === undefined ? {} : { inProcess }),
-    ...(isolated === undefined ? {} : { isolated }),
+    ...(isolated === undefined ? {} : { isolated: { ...isolated, ...(runsAlone ? { runsAlone: true as const } : {}) } }),
     offeredOn,
     ...(offeredOn.length === 0 ? { dimmed: why.length === 0 ? "no tier was judged" : why.join("; ") } : {}),
   };
 }
 
+/** A judgment's verdicts as the record writes them. */
+export const verdictRows = (judgment: Judgment): RecordVerdict[] =>
+  judgment.hosts.map((h) => ({
+    host: h.verdict.host,
+    measured: h.verdict.measured,
+    rating: h.verdict.rating,
+    qualified: h.verdict.qualified,
+    hosting: h.hosting,
+    arm: h.arm,
+    ...(h.verdict.deciding === undefined ? {} : { deciding: h.verdict.deciding }),
+    reasons: h.reasons,
+  }));
+
 export function buildQualificationRecord(
   judgment: Judgment,
   copy: { file: string; sha256: string; bytes: number },
@@ -287,16 +381,7 @@ export function buildQualificationRecord(
     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,
-      arm: h.arm,
-      ...(h.verdict.deciding === undefined ? {} : { deciding: h.verdict.deciding }),
-      reasons: h.reasons,
-    })),
+    verdicts: verdictRows(judgment),
     ...(judgment.adapter === undefined ? {} : { adapter: judgment.adapter }),
     tiers: tiersOf(judgment),
     cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),