@openmixer/plugin-qualify 0.20.0 → 0.20.1

package/src/distributed-records.ts

@@ -12,8 +12,10 @@
  * treats the plugin as one it measured.
  */
 import { readFileSync, readdirSync } from "node:fs";
+import { machine } from "node:os";
 import { join, resolve } from "node:path";
 
+import { cellKey, type GridCell } from "./measurement-grid.js";
 import { clapPinUri, pinVerdictOf, type PinEntry } from "./pins-file.js";
 import { integrityOfProbeOutput } from "./probe-judge.js";
 import { readProbeOutput, sha256Hex } from "./probe-output.js";
@@ -60,6 +62,20 @@ export function hostClassOfBoard(model: string | undefined): string | undefined
   return m === null ? undefined : `rpi${m[1]!}`;
 }
 
+/** The architecture `uname -m` names, or `undefined` when it cannot be read. */
+export function readMachine(): string | undefined {
+  try {
+    return machine();
+  } catch {
+    return undefined;
+  }
+}
+
+/** The host class of a machine with no board name, by `uname -m`: `x86-64` for an x86_64 one; none for an architecture without a class. */
+export function hostClassOfMachine(arch: string | undefined): string | undefined {
+  return arch?.trim() === "x86_64" ? "x86-64" : undefined;
+}
+
 /** One distributed record, read: where it is, what it says, and the set it came with. */
 export interface DistributedRecord {
   readonly path: string;
@@ -156,26 +172,38 @@ export function outcomeOfVerdict(v: Pick<RecordVerdict, "measured" | "rating" |
   return v.rating === "unsuitable" ? "refused" : "unmeasured";
 }
 
+/** The cells a record's grid holds, by rate then quantum: where the set it came in was measured. */
+export function recordCells(record: Pick<QualificationRecord, "measurements">): GridCell[] {
+  const seen = new Map<string, GridCell>();
+  for (const p of record.measurements?.grid ?? []) seen.set(cellKey(p), { rate: p.rate, quantum: p.quantum });
+  return [...seen.values()].sort((a, b) => a.rate - b.rate || a.quantum - b.quantum);
+}
+
 /** What the layer makes of one item. */
 export type DistributedMatch =
   /** No distributed record names the plugin: it is measured, and nothing is said. */
   | { readonly status: "none" }
   /** Every reason a record found was not taken, one line each; the plugin is measured. */
   | { readonly status: "ignored"; readonly lines: readonly string[] }
-  | { readonly status: "applies"; readonly set: string; readonly records: readonly DistributedRecord[]; readonly files: readonly string[] };
+  /** A set applies; `lines` names every set tried before it and why it was passed over. */
+  | { readonly status: "applies"; readonly set: string; readonly records: readonly DistributedRecord[]; readonly files: readonly string[]; readonly lines: readonly string[] };
 
 /**
  * Whether the item is taken from the layer. The records that find it are tried one set at a time, in the order the
  * layer read them. Of a set, only the records whose every file is installed with the SHA-256 it recorded (computed
  * here by `digest`) count: a record of other bytes is another build of the plugin and is passed over. The set applies
  * when at least one record of these bytes holds a verdict for `host`, and none of those verdicts is one the source
- * could not measure; a set with no record of these bytes is a binary that differs.
+ * could not measure; a set with no record of these bytes is a binary that differs. A set is per machine class, rate
+ * and quantum: of these records, only the ones whose grid holds every cell in `cells` (the cells the sync runs at)
+ * count, so a set measured at another cell is passed over, naming the cells it was measured at, and never answers a
+ * sync at this one by the order its name sorts in (#317). No cells given asks nothing of the grid.
  */
 export function matchDistributed(
   layer: DistributedLayer,
   item: SyncItem,
   host: string,
   digest: (files: readonly string[]) => readonly FileDigest[] | undefined,
+  cells: readonly GridCell[] = [],
 ): DistributedMatch {
   const found = item.format === "clap" ? layer.clap.get(resolve(join(item.root, item.files[0]!))) : layer.lv2.get(item.uri ?? "");
   if (found === undefined || found.length === 0) return { status: "none" };
@@ -195,7 +223,16 @@ export function matchDistributed(
       say(`distributed: ${distributedUri(item, found.find((r) => r.set === set)!)}: binary differs`);
       continue;
     }
-    const judged = records.filter((r) => r.record.verdicts.some((v) => v.host === host));
+    const atCell = records.filter((r) => {
+      const held = new Set(recordCells(r.record).map(cellKey));
+      return cells.every((c) => held.has(cellKey(c)));
+    });
+    if (atCell.length === 0) {
+      const measuredAt = [...new Set(records.flatMap((r) => recordCells(r.record).map(cellKey)))];
+      say(`distributed: ${distributedUri(item, records[0]!)}: set ${set} measured at ${measuredAt.length === 0 ? "no cell" : measuredAt.join(", ")}`);
+      continue;
+    }
+    const judged = atCell.filter((r) => r.record.verdicts.some((v) => v.host === host));
     if (judged.length === 0) {
       say(`distributed: ${distributedUri(item, records[0]!)}: no verdict for ${host} in ${set}`);
       continue;
@@ -205,7 +242,7 @@ export function matchDistributed(
       say(`distributed: ${distributedUri(item, unmeasured)}: unmeasured in ${set}, measured here`);
       continue;
     }
-    return { status: "applies", set, records, files: [...new Set(records.flatMap((r) => r.record.binary.files.map((f) => f.path)))] };
+    return { status: "applies", set, records: atCell, files: [...new Set(atCell.flatMap((r) => r.record.binary.files.map((f) => f.path)))], lines };
   }
   return { status: "ignored", lines };
 }

package/src/index.ts

@@ -24,6 +24,8 @@ export * from "./cost-fields.js";
 export * from "./probe-output.js";
 export * from "./probe-judge.js";
 export * from "./qualification-record.js";
+export * from "./judgement-line.js";
+export * from "./judged-layer.js";
 export * from "./probe-runner.js";
 export * from "./measurement-grid.js";
 export * from "./memory-bound.js";

package/src/judged-layer.ts

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The judged layer of a plugin-db entry, from a qualification record: plugin-qualify is that layer's one writer
+ * (plugin-db's records design note, FreeMixer/plugin-db#10). The reader never parses a record; it reads the layer this writes, so every field
+ * the state function reads is set here, from the record and from what plugin-qualify declares once:
+ *
+ * - the latency line (`LATENCY_LINE_MS`), written beside each cell's figure (`latencyMs`), so a surface shows the
+ *   figure within or over the line and keeps no tier word (openmixer plugin-system design 7.15);
+ * - the rules the record was judged by (`judgementRules`), the minor of the plugin-qualify that judged it: a rule
+ *   changes only in a minor, so a patch release leaves every record current;
+ * - the hosting epoch of the host the verdict is for (`HOSTING_EPOCH`).
+ *
+ * One layer is one verdict under one host: the host plugin-hostd runs a plugin with. Its verdict is the one the pins
+ * file gives the same bytes (`pinVerdictOf` of the isolated tier's host, omx-clap-host, which is plugin-hostd's
+ * worker). A record whose verdict for that host was not measured has no judged layer: the reader then answers
+ * unqualified, with its reason.
+ */
+import { judgementRules, latencyMsOf, LATENCY_LINE_MS } from "./judgement-line.js";
+import { pinVerdictOf, type PinVerdict } from "./pins-file.js";
+import { QUALIFICATION_RECORD_SCHEMA, ISOLATED_TIER_HOST, type QualificationRecord } from "./qualification-record.js";
+import type { SuitabilityRating } from "./rating.js";
+
+/** The host a judged layer is written for: the one that runs plugins, in workers of its own (PLUGIN_DB_ISOLATION_HOSTS). */
+export const JUDGED_HOST = "plugin-hostd";
+
+/**
+ * The hosting epoch of each host a layer is written for. The epoch is the host owner's to move, when a release of it
+ * changes how it hosts; plugin-hostd has declared no hosting change since records were written, so its epoch is 0.
+ */
+export const HOSTING_EPOCH = { [JUDGED_HOST]: 0 } as const satisfies Readonly<Record<string, number>>;
+
+/** The plugin-db envelope version this writes (plugin-db data/store.schema.json). */
+export const PLUGIN_DB_ENVELOPE = 1;
+
+/** The pin a layer is written for, as plugin-db's pinned layer holds it. */
+export interface LayerPin {
+  /** The `omx-files/1` SHA-256 of the plugin's files. */
+  readonly files: string;
+  /** `<scheme>:<sha256>` of the parameter layout, or null when the pin holds none. */
+  readonly layout: string | null;
+}
+
+export interface JudgedCell {
+  readonly rate: number;
+  readonly quantum: number;
+  readonly latencyMs?: number;
+}
+
+export interface JudgedBody {
+  readonly verdict: PinVerdict;
+  readonly machineClass: string;
+  readonly host: { readonly name: string; readonly version: string; readonly hostingEpoch: number };
+  readonly rules: string;
+  readonly recordSchema: string;
+  readonly cells: readonly JudgedCell[];
+  readonly conditions: Readonly<Record<string, string>>;
+  readonly latencyLineMs: number;
+}
+
+export interface JudgedLayer {
+  readonly envelope: typeof PLUGIN_DB_ENVELOPE;
+  readonly layer: "judged";
+  readonly address: string;
+  readonly pin: LayerPin;
+  readonly writer: "plugin-qualify";
+  readonly body: JudgedBody;
+}
+
+/** What the converter is given beside the record: the class word, the pin, and the rules when the record states none. */
+export interface JudgedLayerInput {
+  /** The machine class word the record was measured on (`rpi5`, `x86-64`): the set's host class. */
+  readonly machineClass: string;
+  readonly pin: LayerPin;
+  /** plugin-db's address; by default `<format>:<id>`. */
+  readonly address?: string;
+  /** The rules of a record that states none: the plugin-qualify version that judged its set (the set's provenance). */
+  readonly judgedBy?: string;
+}
+
+/** Why a record has no judged layer, when it has none. */
+export type NoLayer = { readonly layer: null; readonly reason: string };
+
+/** The version of a tool named `<name> <version>` in the record's `tool`. */
+function versionOf(record: QualificationRecord, name: string): string | undefined {
+  for (const v of Object.values(record.tool)) {
+    const m = new RegExp(`^${name.replace(/[-.]/g, "\\$&")} (\\S+)$`).exec(v);
+    if (m) return m[1];
+  }
+  return undefined;
+}
+
+/** The cells of the record: each measured rate and quantum, with its latency in milliseconds when one was measured. */
+export function judgedCells(record: QualificationRecord): JudgedCell[] {
+  return record.measurements.grid
+    .filter((p) => p.outcome === "probe.ok")
+    .map((p) => {
+      const frames = (p.latency as { measuredFrames?: number }).measuredFrames;
+      return { rate: p.rate, quantum: p.quantum, ...(frames === undefined ? {} : { latencyMs: latencyMsOf(frames, p.rate) }) };
+    });
+}
+
+/**
+ * The judged layer of a record, or why there is none. The verdict is the isolated tier host's, as the pins file gives
+ * it; the host is plugin-hostd at the probe runner's version, which is plugin-hostd's.
+ */
+export function judgedLayerOf(record: QualificationRecord, input: JudgedLayerInput): JudgedLayer | NoLayer {
+  if (record.schema !== QUALIFICATION_RECORD_SCHEMA) return { layer: null, reason: `record schema ${JSON.stringify(record.schema)} is not ${QUALIFICATION_RECORD_SCHEMA}` };
+  const tierHost = ISOLATED_TIER_HOST[record.plugin.format];
+  const v = record.verdicts.find((r) => r.host === tierHost);
+  if (v === undefined) return { layer: null, reason: `no verdict under ${tierHost ?? `a host for ${record.plugin.format}`}` };
+  const verdict = v.measured ? pinVerdictOf(v.rating as SuitabilityRating) : undefined;
+  if (verdict === undefined) return { layer: null, reason: `${tierHost}: not measured (${v.deciding ?? v.rating})` };
+  const hostVersion = versionOf(record, "plugin-hostd-probe");
+  if (hostVersion === undefined) return { layer: null, reason: "the record names no plugin-hostd-probe version" };
+  const rules = record.rules ?? (input.judgedBy === undefined ? undefined : judgementRules(input.judgedBy));
+  if (rules === undefined) return { layer: null, reason: "the record states no rules, and no judgedBy was given" };
+  return {
+    envelope: PLUGIN_DB_ENVELOPE,
+    layer: "judged",
+    address: input.address ?? `${record.plugin.format}:${record.plugin.id}`,
+    pin: input.pin,
+    writer: "plugin-qualify",
+    body: {
+      verdict,
+      machineClass: input.machineClass,
+      host: { name: JUDGED_HOST, version: hostVersion, hostingEpoch: HOSTING_EPOCH[JUDGED_HOST] },
+      rules,
+      recordSchema: record.schema,
+      cells: judgedCells(record),
+      conditions: {},
+      latencyLineMs: record.latencyLineMs ?? LATENCY_LINE_MS,
+    },
+  };
+}
+
+export interface JudgedLayerArgs {
+  readonly record: string;
+  readonly machineClass: string;
+  readonly files: string;
+  readonly layout: string | null;
+  readonly judgedBy?: string;
+  readonly address?: string;
+  /** Print the body only, as `plugin-db put <address> judged --writer plugin-qualify` reads it from stdin. */
+  readonly body: boolean;
+}
+
+export function judgedLayerHelpText(): string {
+  return [
+    "usage: plugin-qualify judged-layer <record.qualification.json> --machine-class <word> --files <sha256>",
+    "                                   [--layout <scheme>:<sha256>] [--judged-by <version>] [--address <address>] [--body]",
+    "",
+    "Print the plugin-db judged layer of a qualification record, for the pin plugin-db holds (its files digest and",
+    "layout). --judged-by names the plugin-qualify that judged a record stating no rules (the set's provenance). --body",
+    "prints the body only, for `plugin-db put <address> judged --writer plugin-qualify`. A record whose verdict under",
+    "plugin-hostd's worker was not measured has no layer: the reason is printed and the exit status is 1.",
+    "",
+  ].join("\n");
+}
+
+export type ParsedJudgedLayerArgs = { ok: true; args: JudgedLayerArgs } | { ok: true; help: true } | { ok: false; error: string };
+
+export function parseJudgedLayerArgs(argv: readonly string[]): ParsedJudgedLayerArgs {
+  const opts: Record<string, string> = {};
+  const files: string[] = [];
+  let body = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--help" || a === "-h") return { ok: true, help: true };
+    if (a === "--body") body = true;
+    else if (["--machine-class", "--files", "--layout", "--judged-by", "--address"].includes(a)) {
+      const v = argv[++i];
+      if (v === undefined || v.startsWith("--")) return { ok: false, error: `${a} needs a value` };
+      opts[a] = v;
+    } else if (a.startsWith("--")) return { ok: false, error: `unknown option ${a}` };
+    else files.push(a);
+  }
+  if (files.length !== 1) return { ok: false, error: "name one record" };
+  const machineClass = opts["--machine-class"];
+  const pinFiles = opts["--files"];
+  if (machineClass === undefined) return { ok: false, error: "--machine-class is required" };
+  if (pinFiles === undefined || !/^[0-9a-f]{64}$/.test(pinFiles)) return { ok: false, error: "--files must be the 64 hex digits of the files pin" };
+  const layout = opts["--layout"] ?? null;
+  if (layout !== null && !/^[^:]+:[0-9a-f]{64}$/.test(layout)) return { ok: false, error: "--layout must be <scheme>:<sha256>" };
+  return {
+    ok: true,
+    args: {
+      record: files[0]!,
+      machineClass,
+      files: pinFiles,
+      layout,
+      body,
+      ...(opts["--judged-by"] === undefined ? {} : { judgedBy: opts["--judged-by"] }),
+      ...(opts["--address"] === undefined ? {} : { address: opts["--address"] }),
+    },
+  };
+}

package/src/judgement-line.ts

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * What plugin-qualify's judgement declares once and writes into every record (and so into every judged layer): the
+ * latency line and the rules a record was judged by (openmixer plugin-system design 7.15, plugin-db records.md).
+ */
+import { readFileSync } from "node:fs";
+
+/** The latency line, in milliseconds: declared once, here, and written into every record and judged layer. */
+export const LATENCY_LINE_MS = 5;
+
+/** A measured latency in milliseconds at its rate, rounded to the microsecond. */
+export const latencyMsOf = (frames: number, rate: number): number => Math.round((frames * 1e9) / rate) / 1e6;
+
+const VERSION: string = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+/** The rules a plugin-qualify of this version judges by: `plugin-qualify-rules/<major>.<minor>`. */
+export function judgementRules(version: string = VERSION): string {
+  const m = /^(\d+)\.(\d+)\.\d+/.exec(version);
+  if (m === null) throw new Error(`judgementRules: ${JSON.stringify(version)} is no version`);
+  return `plugin-qualify-rules/${m[1]}.${m[2]}`;
+}

package/src/measurement/cli.ts

@@ -35,7 +35,7 @@
 import { join } from "node:path";
 
 import type { MeasurementDocument, MeasurementRun, MeasuredPlugin } from "./format.js";
-import { buildMeasurementDocument } from "./format.js";
+import { buildMeasurementDocument, readIntegrity } from "./format.js";
 import { measuredPluginsFromProbeOutput } from "./probe-json.js";
 import { buildRun, costMethodFromProbeProvenance, hostFromProbeProvenance } from "./provenance.js";
 import type { MeasurementHost, LatencyMethod } from "./format.js";
@@ -237,10 +237,17 @@ export function buildPipeline(options: MeasureOptions, native?: HostingTools): P
     });
   }
 
+  // a run of the prober's dimensions alone takes the pin too: a plugin measured with no integrity block cannot be pinned
+  // from its figures (plugin-qualify#316), and the measurer names the files without instantiating anything
+  const pinned = !hosting && probed && native !== undefined && (options.plugins !== undefined || current !== undefined);
+  if (pinned && native !== undefined) {
+    steps.push({ id: "pin", command: native.tool, args: ["--pin"], perPlugin: true, produces: join(options.workDir, "pins.jsonl") });
+  }
+
   return {
     steps,
     ...(probed && current !== undefined ? { finalCatalog: current } : {}),
-    ...(hosting && options.plugins === undefined && current !== undefined ? { hostingScan: current } : {}),
+    ...((hosting || pinned) && options.plugins === undefined && current !== undefined ? { hostingScan: current } : {}),
     ...(costProvenance === undefined ? {} : { costProvenance }),
   };
 }
@@ -599,6 +606,8 @@ export interface AssemblyInput {
   readonly catalog?: unknown;
   /** The hosting pass's lines ({@link hostingLine}), one per plugin. Absent when it did not run. */
   readonly hosting?: readonly unknown[];
+  /** The measurer's `--pin` lines ({@link hostingLine}), one per plugin, for a run with no hosting pass. Absent when the pin step did not run. */
+  readonly pins?: readonly unknown[];
   /** The cost pass's provenance JSON, already parsed. Absent on a latency-only run. */
   readonly costProvenance?: unknown;
   /** Host facts, for a run whose provenance the cost pass did not write. */
@@ -636,6 +645,7 @@ export function assembleDocument(input: AssemblyInput): MeasurementDocument {
   const plugins: MeasuredPlugin[] =
     probed.length > 0 && input.catalog !== undefined ? measuredPluginsFromProbeOutput(input.catalog, probed) : [];
   if (input.hosting !== undefined) mergeHosting(plugins, measuredPluginsFromSweep({ measurements: input.hosting }), input.options.dimensions);
+  if (input.pins !== undefined) mergePins(plugins, input.pins);
   const costMethod = costMethodFromProbeProvenance(input.costProvenance);
   const host = hostFromProbeProvenance(input.costProvenance) ?? input.host;
   const run: MeasurementRun = buildRun({
@@ -655,6 +665,20 @@ export function assembleDocument(input: AssemblyInput): MeasurementDocument {
   return buildMeasurementDocument(run, plugins);
 }
 
+/** The pin lines folded into the prober's plugins, by URI: a plugin without one keeps none, and a line for a plugin not measured adds none. */
+function mergePins(plugins: MeasuredPlugin[], rows: readonly unknown[]): void {
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) continue;
+    const r = row as Record<string, unknown>;
+    const integrity = readIntegrity(r["integrity"]);
+    const at = plugins.findIndex((p) => p.uri === r["uri"]);
+    if (integrity === undefined || at < 0) continue;
+    const p = plugins[at]!;
+    const version = typeof r["version"] === "string" && r["version"] !== "" ? r["version"] : undefined;
+    plugins[at] = { ...p, ...(p.integrity === undefined ? { integrity } : {}), ...(p.version === undefined && version !== undefined ? { version } : {}) };
+  }
+}
+
 /**
  * The hosting pass's plugins folded into the prober's, by URI: each keeps the hosting dimensions the
  * run asked for and the pin, and a plugin only the hosting pass measured joins with its own topology.

package/src/measurement/format.ts

@@ -303,6 +303,8 @@ export interface MemoryFootprint {
   /** Activated, after processing: what a long-running host carries. */
   readonly atRestKb?: number;
   readonly notesHeldKb?: number;
+  /** The notes held (voices sounding) when `notesHeldKb` was read, the count `basis` says where it came from. */
+  readonly notesHeld?: number;
   readonly secondInstanceKb?: number;
   readonly basis?: VoiceBasis;
   readonly unmeasuredReason?: string;
@@ -950,6 +952,11 @@ function readLatency(value: unknown): LatencyMeasurement | undefined {
 }
 
 /** A KB figure: finite and never negative. */
+function notesCount(value: unknown): number | undefined {
+  const n = positiveNumber(value);
+  return n !== undefined && Number.isInteger(n) ? n : undefined;
+}
+
 function kilobytes(value: unknown): number | undefined {
   const n = finiteNumber(value);
   return n !== undefined && n >= 0 ? n : undefined;
@@ -963,6 +970,7 @@ export function readMemoryFootprint(value: unknown): MemoryFootprint | undefined
     ...optional("afterActivateKb", kilobytes(value.afterActivateKb)),
     ...optional("atRestKb", kilobytes(value.atRestKb)),
     ...optional("notesHeldKb", kilobytes(value.notesHeldKb)),
+    ...optional("notesHeld", notesCount(value.notesHeld)),
     ...optional("secondInstanceKb", kilobytes(value.secondInstanceKb)),
     ...optional("basis", isVoiceBasis(value.basis) ? value.basis : undefined),
     ...reasonOf(value),

package/src/qualification-record.ts

@@ -20,11 +20,12 @@ import { join } from "node:path";
 
 import type { Adjustment } from "./history-adjust.js";
 import type { Judgment, RecordReason } from "./probe-judge.js";
-import { sha256Hex, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
+import { sha256Hex, PROBE_NOT_ATTEMPTED, PROBE_OK, type ProbeGridPoint, type ProbeOutput } from "./probe-output.js";
 import type { VoicesHeld } from "./measurement/format.js";
 import { writeFileWhole } from "./whole-file.js";
 import { HOSTING_CODE } from "./hosting-codes.js";
 import { MEASUREMENT_UNMEASURED_REASONS } from "@openmixer/omx-contract";
+import { judgementRules, latencyMsOf, LATENCY_LINE_MS } from "./judgement-line.js";
 
 export const QUALIFICATION_RECORD_SCHEMA = "plugin-qualify.qualification-record/1";
 
@@ -201,6 +202,8 @@ export type RecordGridPoint = Omit<ProbeGridPoint, "latency" | "memory"> & {
   /** The footprint as measured, with what it comes to: what a client adding the plugin reads (`memory-budget.ts`). */
   readonly memory?: MemoryFootprint & { readonly firstInstanceKb?: number; readonly perInstanceKb?: number };
   readonly latency: (Omit<NonNullable<ProbeGridPoint["latency"]>, "measuredFrames"> & { readonly measuredFrames: number }) | UnmeasuredLatency;
+  /** The measured latency in milliseconds at the cell's rate, beside the record's `latencyLineMs`; absent when none was measured. */
+  readonly latencyMs?: number;
 };
 
 const UNMEASURED_WORDS: ReadonlySet<string> = new Set(Object.values(MEASUREMENT_UNMEASURED_REASONS).map((r) => r.word));
@@ -220,12 +223,20 @@ export function memoryOfCell(p: ProbeGridPoint): Pick<RecordGridPoint, "memory">
   return { memory: { ...p.memory, ...(first === undefined ? {} : { firstInstanceKb: first }), ...(per === undefined ? {} : { perInstanceKb: per }) } };
 }
 
+/** A grid point as the record writes it: its footprint, its latency or why there is none, and the latency in milliseconds. */
+export function gridPointOf(output: ProbeOutput, p: ProbeGridPoint): RecordGridPoint {
+  const latency = latencyOfCell(output, p);
+  const frames = (latency as { measuredFrames?: number }).measuredFrames;
+  return { ...p, ...memoryOfCell(p), latency, ...(frames === undefined ? {} : { latencyMs: latencyMsOf(frames, p.rate) }) };
+}
+
 /** The unmeasured word of a cell whose run did not end well, by its outcome code. */
 const OUTCOME_WORD: Readonly<Record<string, string>> = {
   "probe.crashed": word("probeCrashed"),
   "probe.timeout": word("probeTimeout"),
   "probe.refused-instantiation": word("refusedInstantiation"),
   "probe.non-finite-output": word("nonFiniteOutput"),
+  [PROBE_NOT_ATTEMPTED]: word("notAttempted"),
 };
 
 /**
@@ -361,6 +372,10 @@ export interface QualificationRecord {
   /** Who measured and when. */
   readonly tool: Readonly<Record<string, string>>;
   readonly measuredAt: string;
+  /** The latency line the cells' `latencyMs` stand against (`LATENCY_LINE_MS`); absent on a record written before it was declared. */
+  readonly latencyLineMs?: number;
+  /** The rules the verdicts were judged by (`judgementRules`); absent on a record written before they were stated. */
+  readonly rules?: string;
   /** The second verdict, per host class of the history that was read; absent until `adjust --history` has run. */
   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. */
@@ -483,13 +498,15 @@ export function buildQualificationRecord(
     tiers: tiersOf(judgment),
     cost: judgment.hosts.map((h) => ({ host: h.verdict.host, ...h.cost })),
     measurements: {
-      grid: o.grid.map((p) => ({ ...p, ...memoryOfCell(p), latency: latencyOfCell(o, p) })),
+      grid: o.grid.map((p) => gridPointOf(o, p)),
       ...(o.behaviour === undefined ? {} : { behaviour: o.behaviour }),
       ...(unmeasuredFigures(o).length === 0 ? {} : { unmeasured: unmeasuredFigures(o) }),
     },
     ...(notMeasured.length === 0 ? {} : { notMeasured }),
     tool: o.run.tools,
     measuredAt: o.run.startedAt,
+    latencyLineMs: LATENCY_LINE_MS,
+    rules: judgementRules(),
     probe: {
       file: copy.file,
       sha256: copy.sha256,

package/src/qualify-isolated.ts

@@ -100,16 +100,18 @@ function figuresOf(run: IsolatedRunFacts): IsolatedFigures | undefined {
 
 /**
  * A verdict whose only gap is memory nobody measured: it reads `unknown` and every reason that is not `suitable` is
- * `hosting.memory.unmeasured`. Nothing says the plugin is unfit, so it is hosted in a worker of its own until its
- * footprint is measured, and the isolated step is what shows it running alone.
+ * `hosting.memory.unmeasured`, or a `conditional` one the isolated step answers (an RT violation seen in the run). Nothing
+ * says the plugin is unfit, so it is hosted in a worker of its own until its footprint is measured, and the isolated step
+ * is what shows it running alone. A conditional reason beside the memory gap owes the step as a conditional verdict does:
+ * whether one run saw a violation and another did not must not decide whether the step is run (#319).
  */
 export function memoryGapOnly(v: Pick<RecordVerdict, "measured" | "rating" | "reasons">): boolean {
   if (!v.measured || v.rating !== "unknown") return false;
   const open = v.reasons.filter((r) => r.rating !== "suitable");
-  return open.length > 0 && open.every((r) => r.code === HOSTING_CODE.memoryUnmeasured);
+  return open.some((r) => r.code === HOSTING_CODE.memoryUnmeasured) && open.every((r) => r.code === HOSTING_CODE.memoryUnmeasured || r.rating === "conditional");
 }
 
-/** Whether a record's outcome calls for the isolated step: rated `conditional` by some host, a memory gap and nothing else, or a probe that crashed or hung. */
+/** Whether a record's outcome calls for the isolated step: rated `conditional` by some host, a memory gap and nothing else unanswered, or a probe that crashed or hung. */
 export function owesIsolated(record: QualificationRecord): boolean {
   return PROBE_FAILED_HARD.has(record.probe.outcome) || record.verdicts.some((v) => v.measured && (v.rating === "conditional" || memoryGapOnly(v)));
 }

package/src/qualify-sync.ts

@@ -24,7 +24,7 @@ import { homedir, tmpdir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 
 import { clapQualifyTools } from "./clap-qualify.js";
-import { DISTRIBUTED_DIR_SYSTEM, EMPTY_LAYER, applyDistributed, distributedUri, hostClassOfBoard, outcomeOfVerdict, matchDistributed, readBoardModel, readDistributedLayer, type DistributedLayer } from "./distributed-records.js";
+import { DISTRIBUTED_DIR_SYSTEM, EMPTY_LAYER, applyDistributed, distributedUri, hostClassOfBoard, hostClassOfMachine, outcomeOfVerdict, matchDistributed, readBoardModel, readMachine, readDistributedLayer, type DistributedLayer } from "./distributed-records.js";
 import { clapSearchPath, parseClapScan } from "./clap-loader.js";
 import { HOSTING_CODE } from "./hosting-codes.js";
 import { shippedHostProfile, type HostProfile } from "./host-profiles.js";
@@ -34,7 +34,7 @@ import { POOL_RESULT, completePool, judgePoolRun, pinAfterPool, pinFromRecordWit
 import { hostdPinFiles, type PinFilesRun } from "./hostd-pin-files.js";
 import type { Judgment } from "./probe-judge.js";
 import { qualifyTargets, type ProbeRun } from "./probe-runner.js";
-import { GRID_FULL, parseGridSpec, type GridSpec } from "./measurement-grid.js";
+import { GRID_FULL, hostCells, parseGridSpec, type GridCell, type GridSpec } from "./measurement-grid.js";
 import { adapterPass, type AdapterPassOptions, type AdapterPassResult } from "./qualify-adapter-pass.js";
 import { ISOLATED_RESULT, baseSteps, completeIsolated, isolatedCell, missingSteps, judgeIsolatedRun, owesIsolated, pinAfterStep, spawnedIsolatedRunner, type IsolatedRunner } from "./qualify-isolated.js";
 import { lv2World, rejudgeRecord, rejudgeState, rejudgeToolName, memoryPass, type MemoryPassResult, type RejudgeResult } from "./qualify-rejudge.js";
@@ -228,6 +228,7 @@ export function resolveSyncSettings(
   env: Readonly<Record<string, string | undefined>>,
   home: string = homedir(),
   boardModel: () => string | undefined = readBoardModel,
+  machineArch: () => string | undefined = readMachine,
 ): { ok: true; settings: SyncSettings } | { ok: false; error: string } {
   const get = (key: string): string | undefined => args.values.get(key) ?? file.get(key);
   const state = env["XDG_STATE_HOME"] !== undefined && env["XDG_STATE_HOME"] !== "" ? env["XDG_STATE_HOME"] : join(home, ".local", "state");
@@ -276,7 +277,7 @@ export function resolveSyncSettings(
         ? [DISTRIBUTED_DIR_SYSTEM]
         : [dataHome, ...dataDirs].map((d) => join(d, "omx", "qualification"));
   const classNamed = get("host_class");
-  const hostClass = classNamed !== undefined && classNamed !== "" ? classNamed : hostClassOfBoard(boardModel());
+  const hostClass = classNamed !== undefined && classNamed !== "" ? classNamed : hostClassOfBoard(boardModel()) ?? hostClassOfMachine(machineArch());
   if (hostClass !== undefined && !/^[A-Za-z0-9][A-Za-z0-9._+-]*$/.test(hostClass)) return { ok: false, error: `host_class ${hostClass} is not a directory name` };
   return {
     ok: true,
@@ -681,7 +682,10 @@ export function refreshPins(ctx: SyncContext, state: SyncState): { state: SyncSt
       const pin = plugin.pin;
       if (pin === undefined || pin.integrity.files === undefined) return plugin;
       const r = hostdPinFiles(pin.uri, ctx.settings.lv2Dirs, ctx.env, ...(ctx.pinFilesRun === undefined ? [] : [ctx.pinFilesRun]));
-      if (!r.ok) return plugin;
+      if (!r.ok) {
+        ctx.log(`${pin.uri}: pin files not refreshed: ${r.detail}`);
+        return plugin;
+      }
       const old = new Map(pin.integrity.files.map((f) => [f.path, f.sha256]));
       const changed = r.files.filter((f) => old.has(f.path) && old.get(f.path) !== f.sha256).map((f) => f.path);
       const same = r.files.length === old.size && r.files.every((f) => old.get(f.path) === f.sha256);
@@ -931,7 +935,9 @@ export function isolatedPass(ctx: SyncContext, state: SyncState): { readonly sta
           return rest.outcome === "qualified" && rebuilt.verdict === "refused" ? { ...rest, outcome: "refused" as const, pin: rebuilt } : { ...rest, pin: rebuilt };
         }
         ctx.log(`${p.uri}: isolated step ${done.step.result}${done.step.code === undefined ? "" : ` (${done.step.code})`}`);
-        const pin = pinAfterStep(p.pin, done.step);
+        // a plugin the state holds no pin for is pinned from the record the step now completes: the bytes it names and the word
+        // the step earned (plugin-qualify#316: 38 plugins read hosting.memory.unmeasured and had none)
+        const pin = p.pin !== undefined ? pinAfterStep(p.pin, done.step) : withHostdFiles(ctx, pinFromRecordWithPool(done.record));
         const { pin: _pin, code: _code, ...rest } = p;
         if (done.step.result === ISOLATED_RESULT.isolated) {
           count.isolated++;
@@ -985,6 +991,14 @@ export function poolPass(ctx: SyncContext, state: SyncState): { readonly state:
 
 // --- the distributed records ----------------------------------------------------------------------------------------
 
+/**
+ * The cells a sync runs at, which a distributed set must hold to apply (#317): the grid's own cells when it names them
+ * (`grid 48000/512`), else the cells the host profile judges cost and memory at.
+ */
+export function syncCells(settings: Pick<SyncSettings, "grid" | "hostProfile">): GridCell[] {
+  return settings.grid.kind === "cells" ? [...settings.grid.cells] : hostCells(settings.hostProfile);
+}
+
 /** The layer a run reads: none under `--force` or `--no-distributed`, or without a host class. */
 function distributedLayerOf(settings: SyncSettings, force: boolean, log: (line: string) => void): DistributedLayer {
   if (force || !settings.distributed) return EMPTY_LAYER;
@@ -1007,12 +1021,10 @@ function takeDistributed(ctx: SyncContext, layer: DistributedLayer, item: SyncIt
   if (layer.records === 0) return undefined;
   const started = Date.now();
   const host = ctx.settings.hostProfile.id;
-  const match = matchDistributed(layer, item, host, (paths) => digestFiles(item.root, paths, files));
+  const match = matchDistributed(layer, item, host, (paths) => digestFiles(item.root, paths, files), syncCells(ctx.settings));
   if (match.status === "none") return undefined;
-  if (match.status === "ignored") {
-    for (const line of match.lines) ctx.log(line);
-    return undefined;
-  }
+  for (const line of match.lines) ctx.log(line);
+  if (match.status === "ignored") return undefined;
   for (const r of match.records) {
     const missing = missingSteps(r.record);
     if (missing.length > 0) {