@openmixer/plugin-qualify 0.18.4 → 0.19.1

package/dist/qualify-sync.d.ts

@@ -1,5 +1,6 @@
 import { type HostProfile } from "./host-profiles.js";
 import { type PinEntry } from "./pins-file.js";
+import { type PoolRunner } from "./qualify-pool.js";
 import { type PinFilesRun } from "./hostd-pin-files.js";
 import { type ProbeRun } from "./probe-runner.js";
 import { type GridSpec } from "./measurement-grid.js";
@@ -16,7 +17,7 @@ export declare const ZYNTHIAN_LV2_DIRS: string[];
 export interface SyncSetting {
     readonly key: string;
     readonly meaning: string;
-    /** The default as `--help` and the README print it. */
+    /** The default as `--help` and docs/overview.md print it. */
     readonly default: string;
 }
 /** Every setting, declared once: the settings file, the flags (`--pin-file` for `pin_file`) and `--help` read this. */
@@ -70,6 +71,8 @@ export interface SyncArgs {
     readonly adapterOnly: boolean;
     /** `--isolated-only`: the missing isolated step of each record already judged, extending its run. */
     readonly isolatedOnly: boolean;
+    /** `--pool-only`: the pool step of each CLAP record already judged that owes it, extending its run and giving its pin the word. */
+    readonly poolOnly: boolean;
     readonly help: boolean;
     /** The settings given as flags, by key. */
     readonly values: ReadonlyMap<string, string>;
@@ -165,6 +168,12 @@ export declare const SYNC_CODE: {
  * plugin, a crash) is not. `undefined` for every other outcome.
  */
 export declare function machineReason(p: Pick<SyncPlugin, "outcome" | "code" | "detail">): string | undefined;
+/**
+ * The figure the records of a recorded entry never took, or `undefined`: a record whose probe ran before that figure's
+ * pass ({@link latencyNeverTaken}) owes a measurement, and the sync measures the entry again although its bytes are the
+ * ones it recorded. A record that cannot be read owes nothing here: the sync's other checks deal with it.
+ */
+export declare function figureOwed(entry: Pick<SyncEntry, "plugins">): "latency" | undefined;
 /** What the quick qualification never measures, stated in every record it writes. */
 export declare const QUICK_NOT_MEASURED: readonly NotMeasured[];
 export interface SyncPlugin {
@@ -218,6 +227,8 @@ export interface SyncContext {
     readonly pinFilesRun?: PinFilesRun;
     /** The isolated step, a stand-in in tests. */
     readonly isolatedRunner?: IsolatedRunner;
+    /** The pool step, a stand-in in tests. */
+    readonly poolRunner?: PoolRunner;
 }
 /**
  * Every pin of the state with the files plugin-hostd collects for its plugin now, measured again by nothing
@@ -242,6 +253,19 @@ export declare function isolatedPass(ctx: SyncContext, state: SyncState): {
     readonly isolated: number;
     readonly refused: number;
     readonly notRun: number;
+    readonly repinned: number;
+};
+/**
+ * The pool steps the CLAP records of a state still owe, each extending its record's run. A plugin's pin takes the pool word
+ * of its step (`cores`, or `off` for a plugin that was measured and gains nothing) and none for a plugin that does not ask
+ * for the pool. A step that could not run stays owed: the next pass tries it again.
+ */
+export declare function poolPass(ctx: SyncContext, state: SyncState): {
+    readonly state: SyncState;
+    readonly cores: number;
+    readonly off: number;
+    readonly notAsked: number;
+    readonly notRun: number;
 };
 /** The pin file's text: every whole pin of the state, the worse verdict kept for a uri pinned twice. */
 export declare function syncPinsText(state: SyncState): string;
@@ -315,6 +339,13 @@ export interface SyncSummary {
         readonly refused: number;
         readonly notRun: number;
     };
+    /** `--pool-only`: the plugins granted the thread pool, those measured and not granted it, those that do not ask for it, and those the step could not run for. */
+    readonly poolOnly?: {
+        readonly cores: number;
+        readonly off: number;
+        readonly notAsked: number;
+        readonly notRun: number;
+    };
     /** `--adapter-only`: the plugins run, those done already at these host versions, and those whose host could not be run. */
     readonly adapterOnly?: {
         readonly measured: number;
@@ -328,6 +359,16 @@ export interface SyncSummary {
  * line each; none when the directory does not exist yet or everything is open.
  */
 export declare function descriptorAccessProblems(dir: string): string[];
+/** What the records say per plugin, not per record: a CLAP plugin has a record per offer (.default, the console's
+ * in-process tier, and .custom, omx-clap-host's isolated tier), and is offered when any of its records is. */
+export interface PluginCounts {
+    readonly plugins: Readonly<Record<string, number>>;
+    readonly offered: Readonly<Record<string, number>>;
+    readonly notOffered: Readonly<Record<string, number>>;
+}
+export declare function pluginCounts(qualificationDir: string): PluginCounts;
+/** The per-plugin counts as one line: `plugins 1577 (clap 248, lv2 1329), offered 1399 (...), not offered 178 (...)`. */
+export declare function pluginCountsLine(c: PluginCounts): string;
 export declare function summaryLine(s: SyncSummary): string;
 export interface SyncLock {
     release(): Promise<void>;
@@ -351,6 +392,10 @@ export interface SyncRunOptions {
     readonly isolatedRunner?: IsolatedRunner;
     /** `--isolated-only`: take only the isolated steps records still owe. */
     readonly isolatedOnly?: boolean;
+    /** The pool step, a stand-in in tests. */
+    readonly poolRunner?: PoolRunner;
+    /** `--pool-only`: take only the pool steps records still owe. */
+    readonly poolOnly?: boolean;
     /** `--adapter-only`: take only the adapter runs; `force` takes those already done again. */
     readonly adapterOnly?: boolean;
     /** Stand-ins for the pass's hosts, in tests. */

package/dist/qualify-sync.js

@@ -23,20 +23,21 @@ import { createConnection } from "node:net";
 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, matchDistributed, readBoardModel, readDistributedLayer } from "./distributed-records.js";
+import { DISTRIBUTED_DIR_SYSTEM, EMPTY_LAYER, applyDistributed, distributedUri, hostClassOfBoard, outcomeOfVerdict, matchDistributed, readBoardModel, readDistributedLayer } from "./distributed-records.js";
 import { clapSearchPath, parseClapScan } from "./clap-loader.js";
 import { HOSTING_CODE } from "./hosting-codes.js";
 import { shippedHostProfile } from "./host-profiles.js";
 import { lv2BundlesOnPath, manifestPlugins } from "./lv2-loader.js";
-import { judgmentPinEntries, pinsFile } from "./pins-file.js";
+import { judgmentPinEntries, pinClearLine, pinLineUri, pinsFile } from "./pins-file.js";
+import { POOL_RESULT, completePool, judgePoolRun, pinAfterPool, pinFromRecordWithPool, poolEnv, spawnedPoolRunner } from "./qualify-pool.js";
 import { hostdPinFiles } from "./hostd-pin-files.js";
 import { qualifyTargets } from "./probe-runner.js";
 import { GRID_FULL, parseGridSpec } from "./measurement-grid.js";
 import { adapterPass } from "./qualify-adapter-pass.js";
 import { ISOLATED_RESULT, baseSteps, completeIsolated, isolatedCell, missingSteps, judgeIsolatedRun, owesIsolated, pinAfterStep, spawnedIsolatedRunner } from "./qualify-isolated.js";
-import { lv2World, rejudgeState, memoryPass } from "./qualify-rejudge.js";
+import { lv2World, rejudgeRecord, rejudgeState, rejudgeToolName, memoryPass } from "./qualify-rejudge.js";
 import { memoryBoundOf, parseMemoryLimit } from "./memory-bound.js";
-import { rewriteRecord, writeQualification } from "./qualification-record.js";
+import { QUALIFICATION_RECORD_SCHEMA, latencyNeverTaken, rewriteRecord, writeQualification } from "./qualification-record.js";
 import { ADMIT_STEP_MS_ENV, DESCRIPTOR_DIR_STATE_SUBDIR, DESCRIPTOR_DIR_SYSTEM, MEMORY_PASS_PROBE_NOTES, QUALIFY_QUANTA, QUALIFY_RATES } from "./qualify-declarations.js";
 import { toolsDir } from "./tool-paths.js";
 import { writeFileWhole } from "./whole-file.js";
@@ -100,6 +101,7 @@ export function parseSyncArgs(argv) {
     let memoryOnly = false;
     let adapterOnly = false;
     let isolatedOnly = false;
+    let poolOnly = false;
     let help = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
@@ -121,6 +123,8 @@ export function parseSyncArgs(argv) {
             adapterOnly = true;
         else if (a === "--isolated-only")
             isolatedOnly = true;
+        else if (a === "--pool-only")
+            poolOnly = true;
         else if (a === "--help")
             help = true;
         else if (a === "--grid-hosts")
@@ -137,11 +141,11 @@ export function parseSyncArgs(argv) {
         else
             return { ok: false, error: `unknown argument ${a}` };
     }
-    if (rejudge && (memoryOnly || adapterOnly || isolatedOnly || force || refreshPinsOnly))
-        return { ok: false, error: "--rejudge measures nothing: it goes with none of --memory-only, --adapter-only, --force and --refresh-pins" };
-    if ([memoryOnly, adapterOnly, isolatedOnly, refreshPinsOnly].filter(Boolean).length > 1)
-        return { ok: false, error: "--memory-only, --adapter-only and --refresh-pins are different runs: one at a time" };
-    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, rejudge, memoryOnly, adapterOnly, isolatedOnly, help, values } };
+    if (rejudge && (memoryOnly || adapterOnly || isolatedOnly || poolOnly || force || refreshPinsOnly))
+        return { ok: false, error: "--rejudge measures nothing: it goes with none of --memory-only, --adapter-only, --isolated-only, --pool-only, --force and --refresh-pins" };
+    if ([memoryOnly, adapterOnly, isolatedOnly, poolOnly, refreshPinsOnly].filter(Boolean).length > 1)
+        return { ok: false, error: "--memory-only, --adapter-only, --isolated-only, --pool-only and --refresh-pins are different runs: one at a time" };
+    return { ok: true, args: { ...(config === undefined ? {} : { config }), system, force, noDistributed, noWait, refreshPins: refreshPinsOnly, rejudge, memoryOnly, adapterOnly, isolatedOnly, poolOnly, help, values } };
 }
 export function syncHelpText() {
     const rows = SYNC_SETTINGS.map((s) => `  ${`${flagOf(s.key)} <value>`.padEnd(36)}${s.meaning}${s.default === "" ? "" : ` (default: ${s.default})`}`);
@@ -157,6 +161,7 @@ export function syncHelpText() {
         "  --rejudge                           derive every record's verdicts, tiers and pin again from the figures it holds; measures nothing",
         "  --memory-only                       measure only the footprint of each recorded plugin at the Pi's cells and merge it; with --force, those already merged too",
         "  --isolated-only                     run only the isolated step each record still owes, adding it to the record's run",
+        "  --pool-only                         run only the pool step each CLAP record still owes: a plugin that asks for the thread pool is run with it off and on, and its pin gets pool=cores or pool=off",
         "  --adapter-only                      run each LV2 plugin only under omx-clap-host's LV2 adapter at the Pi's cells, on private JACK servers, and merge it; with --force, those already done too",
         "  --grid-hosts                        the fast grid, the same as --grid hosts (7 cells with the shipped hosts)",
         "  --help                              this text",
@@ -448,6 +453,27 @@ export function machineReason(p) {
         return errno;
     return /wrote no document|cannot run the probe runner/.test(p.detail ?? "") ? "the measurement wrote no document" : undefined;
 }
+/**
+ * The figure the records of a recorded entry never took, or `undefined`: a record whose probe ran before that figure's
+ * pass ({@link latencyNeverTaken}) owes a measurement, and the sync measures the entry again although its bytes are the
+ * ones it recorded. A record that cannot be read owes nothing here: the sync's other checks deal with it.
+ */
+export function figureOwed(entry) {
+    for (const p of entry.plugins) {
+        if (p.record === undefined)
+            continue;
+        let r;
+        try {
+            r = JSON.parse(readFileSync(p.record, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (r.schema === QUALIFICATION_RECORD_SCHEMA && latencyNeverTaken(r))
+            return "latency";
+    }
+    return undefined;
+}
 /** What the quick qualification never measures, stated in every record it writes. */
 export const QUICK_NOT_MEASURED = [{ dimension: "stability", code: HOSTING_CODE.stabilityUnsoaked }];
 const EMPTY_STATE = { schema: SYNC_STATE_SCHEMA, entries: {} };
@@ -629,6 +655,13 @@ function judgedPlugins(ctx, runs, describeProblem) {
                 code = undefined;
             }
         }
+        // the pool is for a CLAP plugin that runs: the thread pool is granted by measuring it, here and nowhere else
+        if (judgment.output.plugin.format === "clap" && pin !== undefined && pin.verdict !== "refused" && outcome === "qualified") {
+            const runner = ctx.poolRunner ?? spawnedPoolRunner();
+            const step = judgePoolRun(runner(pin.uri, isolatedCell(record, host), poolEnv(ctx.env, ctx.settings.budgetS)));
+            steps.push(step);
+            pin = pinAfterPool(pin, step);
+        }
         rewriteRecord(recordPath, { ...record, run: { id: judgment.output.run.id, steps } });
         const plugin = { uri: pin?.uri ?? judgment.output.plugin.id, outcome, ...(code === undefined ? {} : { code }), ...(pin === undefined ? {} : { pin }), record: recordPath };
         return { plugin, judgedHere: judgment.hosts.some((h) => h.verdict.host === host) };
@@ -761,7 +794,7 @@ export function qualifyItem(ctx, item, files) {
  * a step that could not run stays owed: the next pass tries it again.
  */
 export function isolatedPass(ctx, state) {
-    const count = { isolated: 0, refused: 0, notRun: 0 };
+    const count = { isolated: 0, refused: 0, notRun: 0, repinned: 0 };
     const runner = ctx.isolatedRunner ?? spawnedIsolatedRunner();
     const host = ctx.settings.hostProfile.id;
     const entries = {};
@@ -781,8 +814,19 @@ export function isolatedPass(ctx, state) {
                     return p;
                 }
                 const done = completeIsolated(path, record, p.pin?.uri ?? record.plugin.id, isolatedCell(record, host), runner, isolatedEnv(ctx));
-                if (done === undefined)
-                    return p;
+                if (done === undefined) {
+                    // a plugin the isolated step already decided but the state holds no pin for: the record keeps the bytes and the
+                    // step, and the pin follows them (hostd names the files, as at every other pin)
+                    if (p.pin !== undefined)
+                        return p;
+                    const rebuilt = withHostdFiles(ctx, pinFromRecordWithPool(record));
+                    if (rebuilt === undefined)
+                        return p;
+                    count.repinned++;
+                    ctx.log(`${p.uri}: pinned again from its record (isolated step ${rebuilt.verdict ?? "undecided"})`);
+                    const { code: _c, ...rest } = p;
+                    return rest.outcome === "qualified" && rebuilt.verdict === "refused" ? { ...rest, outcome: "refused", 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);
                 const { pin: _pin, code: _code, ...rest } = p;
@@ -798,7 +842,50 @@ export function isolatedPass(ctx, state) {
             }),
         };
     }
-    return { ...count, state: count.isolated + count.refused + count.notRun === 0 ? state : { ...state, entries } };
+    return { ...count, state: count.isolated + count.refused + count.notRun + count.repinned === 0 ? state : { ...state, entries } };
+}
+/**
+ * The pool steps the CLAP records of a state still owe, each extending its record's run. A plugin's pin takes the pool word
+ * of its step (`cores`, or `off` for a plugin that was measured and gains nothing) and none for a plugin that does not ask
+ * for the pool. A step that could not run stays owed: the next pass tries it again.
+ */
+export function poolPass(ctx, state) {
+    const count = { cores: 0, off: 0, notAsked: 0, notRun: 0 };
+    const runner = ctx.poolRunner ?? spawnedPoolRunner();
+    const host = ctx.settings.hostProfile.id;
+    const entries = {};
+    for (const [key, entry] of Object.entries(state.entries)) {
+        entries[key] = {
+            ...entry,
+            plugins: entry.plugins.map((p) => {
+                if (p.record === undefined || !p.record.endsWith(".qualification.json") || p.pin === undefined || p.pin.verdict === "refused")
+                    return p;
+                const path = join(ctx.settings.qualificationDir, basename(p.record));
+                let record;
+                try {
+                    record = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    ctx.log(`${p.uri}: its record does not read; no pool step`);
+                    return p;
+                }
+                const done = completePool(path, record, p.pin.uri, isolatedCell(record, host), runner, poolEnv(ctx.env, ctx.settings.budgetS));
+                if (done === undefined)
+                    return p;
+                ctx.log(`${p.uri}: pool step ${done.step.result}${done.step.code === undefined ? "" : ` (${done.step.code})`}`);
+                if (done.step.result === POOL_RESULT.cores)
+                    count.cores++;
+                else if (done.step.result === POOL_RESULT.off)
+                    count.off++;
+                else if (done.step.result === POOL_RESULT.notAsked)
+                    count.notAsked++;
+                else
+                    count.notRun++;
+                return { ...p, pin: pinAfterPool(p.pin, done.step) };
+            }),
+        };
+    }
+    return { ...count, state: count.cores + count.off + count.notAsked + count.notRun === 0 ? state : { ...state, entries } };
 }
 // --- the distributed records ----------------------------------------------------------------------------------------
 /** The layer a run reads: none under `--force` or `--no-distributed`, or without a host class. */
@@ -839,10 +926,36 @@ function takeDistributed(ctx, layer, item, files) {
             ctx.log(`distributed: ${distributedUri(item, r)}: its record lacks the step${missing.length === 1 ? "" : "s"} ${missing.join(", ")}; measured here`);
             return undefined;
         }
+        if (latencyNeverTaken(r.record)) {
+            ctx.log(`distributed: ${distributedUri(item, r)}: its record never took the latency figure (a probe from before that pass); measured here`);
+            return undefined;
+        }
+    }
+    // The set was judged by the plugin-qualify that measured it. Its figures are carried across and judged again under
+    // today's rules, as an upgrade's are (`--rejudge`): a verdict of an older judge (RT-unsafe read as refused, before
+    // #196) is never taken as it stands. A record today's judge cannot decide for this host is measured here.
+    const by = rejudgeToolName();
+    const at = new Date(started).toISOString();
+    const records = [];
+    for (const r of match.records) {
+        let record;
+        try {
+            record = rejudgeRecord(r.record, readFileSync(join(r.path, "..", r.record.probe.file)), { host, by, at }).record;
+        }
+        catch (e) {
+            ctx.log(`distributed: ${distributedUri(item, r)}: ${e.message}; measured here`);
+            return undefined;
+        }
+        const v = record.verdicts.find((x) => x.host === host);
+        if (v !== undefined && outcomeOfVerdict(v) === "unmeasured") {
+            ctx.log(`distributed: ${distributedUri(item, r)}: judged again, ${v.deciding ?? "unknown"} for ${host}; measured here`);
+            return undefined;
+        }
+        records.push({ ...r, record });
     }
     let plugins;
     try {
-        plugins = applyDistributed(ctx.settings.qualificationDir, item, match, host);
+        plugins = applyDistributed(ctx.settings.qualificationDir, item, { ...match, records }, host);
     }
     catch (e) {
         ctx.log(`distributed: ${distributedUri(item, match.records[0])}: ${e.message}; measured here`);
@@ -882,7 +995,7 @@ function pinLinesOf(text) {
     const out = new Map();
     for (const line of text.split("\n"))
         if (line !== "" && !line.startsWith("#"))
-            out.set(line.split(" ")[1], line);
+            out.set(pinLineUri(line), line);
     return out;
 }
 /** The pin lines of `after` that `before` does not hold as they are. */
@@ -1096,8 +1209,48 @@ export function descriptorAccessProblems(dir) {
         problems.push(`${String(closed.length)} descriptor(s) in ${dir} cannot be read by other users, the console among them (first: ${closed[0]})`);
     return problems;
 }
+export function pluginCounts(qualificationDir) {
+    const offeredBy = new Map();
+    let files = [];
+    try {
+        files = readdirSync(qualificationDir).filter((f) => f.endsWith(".qualification.json"));
+    }
+    catch {
+        // no directory, no record
+    }
+    for (const f of files) {
+        let r;
+        try {
+            r = JSON.parse(readFileSync(join(qualificationDir, f), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (!r.plugin?.format || !r.plugin.id)
+            continue;
+        const key = `${r.plugin.format}\0${r.plugin.id}`;
+        offeredBy.set(key, (offeredBy.get(key) ?? false) || (r.tiers?.offeredOn?.length ?? 0) > 0);
+    }
+    const plugins = {}, offered = {}, notOffered = {};
+    for (const [key, isOffered] of offeredBy) {
+        const format = key.split("\0")[0];
+        plugins[format] = (plugins[format] ?? 0) + 1;
+        const into = isOffered ? offered : notOffered;
+        into[format] = (into[format] ?? 0) + 1;
+    }
+    return { plugins, offered, notOffered };
+}
+/** The per-plugin counts as one line: `plugins 1577 (clap 248, lv2 1329), offered 1399 (...), not offered 178 (...)`. */
+export function pluginCountsLine(c) {
+    const part = (m) => {
+        const keys = Object.keys(m).sort();
+        const total = keys.reduce((n, k) => n + m[k], 0);
+        return `${String(total)}${keys.length === 0 ? "" : ` (${keys.map((k) => `${k} ${String(m[k])}`).join(", ")})`}`;
+    };
+    return `plugins ${part(c.plugins)}, offered ${part(c.offered)}, not offered ${part(c.notOffered)}`;
+}
 export function summaryLine(s) {
-    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}${s.rejudge === undefined ? "" : `, rejudged ${String(s.rejudge.changed)}, unchanged ${String(s.rejudge.unchanged)}, owing ${String(s.rejudge.owing)}`}${s.memoryOnly === undefined ? "" : `, memory measured ${String(s.memoryOnly.measured)}, already ${String(s.memoryOnly.already)}, failed ${String(s.memoryOnly.failed)}, leaks not measured`}${s.adapterOnly === undefined ? "" : `, adapter run ${String(s.adapterOnly.measured)}, already ${String(s.adapterOnly.already)}, failed ${String(s.adapterOnly.failed)}`}, ${s.seconds.toFixed(1)} s`;
+    return `qualified ${String(s.qualified)}, skipped ${String(s.skipped)}, refused ${String(s.refused)}, crashed ${String(s.crashed)}, hung ${String(s.hung)}, unmeasured ${String(s.unmeasured)}, distributed ${String(s.distributed)}${s.refreshed ? `, pins refreshed ${String(s.refreshed)}` : ""}${s.rejudge === undefined ? "" : `, rejudged ${String(s.rejudge.changed)}, unchanged ${String(s.rejudge.unchanged)}, owing ${String(s.rejudge.owing)}`}${s.memoryOnly === undefined ? "" : `, memory measured ${String(s.memoryOnly.measured)}, already ${String(s.memoryOnly.already)}, failed ${String(s.memoryOnly.failed)}, leaks not measured`}${s.poolOnly === undefined ? "" : `, pool granted ${String(s.poolOnly.cores)}, off ${String(s.poolOnly.off)}, not asked ${String(s.poolOnly.notAsked)}, not run ${String(s.poolOnly.notRun)}`}${s.adapterOnly === undefined ? "" : `, adapter run ${String(s.adapterOnly.measured)}, already ${String(s.adapterOnly.already)}, failed ${String(s.adapterOnly.failed)}`}, ${s.seconds.toFixed(1)} s`;
 }
 /** The exit status `flock -n` returns when the lock is held (-E), told apart from a failure of flock itself. */
 const LOCK_HELD = 99;
@@ -1182,6 +1335,7 @@ function addSummaries(a, b) {
         ...(b.rejudge === undefined ? (a.rejudge === undefined ? {} : { rejudge: a.rejudge }) : { rejudge: b.rejudge }),
         ...(b.memoryOnly === undefined ? (a.memoryOnly === undefined ? {} : { memoryOnly: a.memoryOnly }) : { memoryOnly: b.memoryOnly }),
         ...(b.isolatedOnly === undefined ? (a.isolatedOnly === undefined ? {} : { isolatedOnly: a.isolatedOnly }) : { isolatedOnly: b.isolatedOnly }),
+        ...(b.poolOnly === undefined ? (a.poolOnly === undefined ? {} : { poolOnly: a.poolOnly }) : { poolOnly: b.poolOnly }),
         ...(b.adapterOnly === undefined ? (a.adapterOnly === undefined ? {} : { adapterOnly: a.adapterOnly }) : { adapterOnly: b.adapterOnly }),
     };
 }
@@ -1205,7 +1359,7 @@ async function runLocked(settings, options) {
     {
         const started = Date.now();
         const dirs = [...settings.clapDirs, ...settings.lv2Dirs];
-        const ctx = { settings, env, log, ...(options.pinFilesRun === undefined ? {} : { pinFilesRun: options.pinFilesRun }), ...(options.isolatedRunner === undefined ? {} : { isolatedRunner: options.isolatedRunner }) };
+        const ctx = { settings, env, log, ...(options.pinFilesRun === undefined ? {} : { pinFilesRun: options.pinFilesRun }), ...(options.isolatedRunner === undefined ? {} : { isolatedRunner: options.isolatedRunner }), ...(options.poolRunner === undefined ? {} : { poolRunner: options.poolRunner }) };
         // the pins first, before the quiet wait and any measurement: an upgrade of plugin-hostd that collects more files
         // than the pins on disk hold refuses those plugins until their pins name them (plugin-qualify#239)
         const fresh = refreshPins(ctx, readSyncState(settings.stateFile, log));
@@ -1228,6 +1382,13 @@ async function runLocked(settings, options) {
             const summary = await sendRefreshed(settings, r.state, fresh.refreshed.length, started, log);
             return { ...summary, isolatedOnly: { isolated: r.isolated, refused: r.refused, notRun: r.notRun } };
         }
+        if (options.poolOnly === true) {
+            const r = poolPass(ctx, fresh.state);
+            if (r.state !== fresh.state)
+                writeFileWhole(settings.stateFile, `${JSON.stringify(r.state, null, 1)}\n`);
+            const summary = await sendRefreshed(settings, r.state, fresh.refreshed.length, started, log);
+            return { ...summary, poolOnly: { cores: r.cores, off: r.off, notAsked: r.notAsked, notRun: r.notRun } };
+        }
         if (options.adapterOnly === true) {
             const r = adapterPass(ctx, fresh.state, { ...options.adapterPass, force: options.force === true });
             log(`adapter runs under ${Object.entries(r.versions).map(([k, v]) => `${k} ${v}`).join(", ")}`);
@@ -1283,7 +1444,8 @@ async function runLocked(settings, options) {
             for (const item of items) {
                 const recorded = recordedAsIs(item, entries[item.key]);
                 const retry = recorded.same ? entries[item.key].plugins.map(machineReason).find((r) => r !== undefined) : undefined;
-                if (recorded.same && options.force !== true && retry === undefined) {
+                const owed = recorded.same && options.force !== true && retry === undefined ? figureOwed(entries[item.key]) : undefined;
+                if (recorded.same && options.force !== true && retry === undefined && owed === undefined) {
                     if (pass === 0)
                         count.skipped += entries[item.key].plugins.length;
                     continue;
@@ -1305,6 +1467,8 @@ async function runLocked(settings, options) {
                 }
                 if (recorded.same && retry !== undefined)
                     log(`${item.key}: unmeasured last run by the machine (${retry}); measured again`);
+                if (owed !== undefined)
+                    log(`${item.key}: its record never took the ${owed} figure (a probe from before that pass); measured again`);
                 const files = recorded.files ?? digestFiles(item.root, item.files);
                 if (files === undefined) {
                     log(`${item.key}: a file of it cannot be read; skipped this run`);
@@ -1362,7 +1526,7 @@ async function runLocked(settings, options) {
             for (const f of pruneStale(settings, stateBefore, state))
                 log(`${f}: removed, its plugin is gone or changed`);
         // a plugin that was pinned and is not any more is also forgotten by a running daemon
-        const changed = [...changedPinLines(before, after), ...removedPinUris(before, after).map((uri) => `pin_clear ${uri}`)];
+        const changed = [...changedPinLines(before, after), ...removedPinUris(before, after).map(pinClearLine)];
         const sent = await sendPins(settings.hostdPort, settings.hostdFeedbackPort, changed);
         if ("unsent" in sent) {
             const why = {
@@ -1375,7 +1539,7 @@ async function runLocked(settings, options) {
         const replies = "replies" in sent ? sent.replies : [];
         for (let i = 0; i < replies.length; i++)
             if (replies[i] !== "resp 0")
-                log(`plugin-hostd answered ${replies[i]} to ${changed[i].split(" ")[1]}`);
+                log(`plugin-hostd answered ${replies[i]} to ${pinLineUri(changed[i])}`);
         const taken = replies.filter((r) => r === "resp 0").length;
         for (const [why, n] of byMachine)
             if (n > 1)