audit-tools 0.34.5 → 0.34.7

package/dist/audit/cli/nextStepHelpers.js

@@ -5,7 +5,7 @@
  * top-level cmdNextStep dispatcher, keeping each module focused on a single
  * concern.
  */
-import { access, unlink } from "node:fs/promises";
+import { access, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { advance, isFileMissingError, readJsonFile, writeJsonFile, readProviderConfirmationInput, } from "audit-tools/shared";
 import { loadArtifactBundle, promoteFinalAuditReport, writeCoreArtifacts, } from "../io/artifacts.js";
@@ -82,7 +82,7 @@ export async function stampSystemicChallengeSkipped(artifactsDir, bundle) {
 }
 import { driveRollingAuditDispatch, resolveAuditRollingEngineEnabled, resolveHostDispatchProviderName, } from "./rollingAuditDispatch.js";
 import { buildAuditSourcePools, isInProcessAuditPool, auditNodeClaimRegistry, auditHybridSettledPath, } from "./hybridDispatch.js";
-import { planHybridDispatch, readSettledPools, addSettledPool, readConfirmedDispatchPolicy, resolveDispatchExclusion, captureZeroCapacityFriction, PROVIDER_CONFIRMATION_FRICTION_RUN_KEY, } from "audit-tools/shared";
+import { planHybridDispatch, readSettledPools, addSettledPool, readConfirmedDispatchPolicy, readConfirmedCapabilityRanks, resolveDispatchExclusion, captureZeroCapacityFriction, PROVIDER_CONFIRMATION_FRICTION_RUN_KEY, } from "audit-tools/shared";
 import { resolveHostDispatchCapability } from "./args.js";
 /**
  * Re-drive an in-process rolling dispatch up to `maxRetries` times with exponential
@@ -221,7 +221,8 @@ export async function buildTerminalStep(params, bundle, state, blockedReason) {
  *   - `return`      → caller should emit the embedded result to cmdNextStep.
  *   - `fallthrough` → no incoming artifacts; run the deterministic executor.
  */
-export async function handleGraphEnrichmentBranch(params, bundle, state, analyzersRef) {
+export async function handleGraphEnrichmentBranch(params, bundle, state, analyzersRef, deps = {}) {
+    const runStep = deps.runStep ?? runAuditStep;
     // Fold-level pause detection is single-sourced in `hostInputPause` so the drain
     // stop predicate (`nextStepPausesForHostInput`) and this fold agree EXACTLY on
     // when the analyzer-install consent / edge-reasoning turns are owed.
@@ -232,8 +233,14 @@ export async function handleGraphEnrichmentBranch(params, bundle, state, analyze
     };
     const unresolved = graphEnrichmentUnresolvedAnalyzers(bundle, pauseInputs);
     if (unresolved.length > 0) {
-        const incoming = await tryConsumeIncoming(params.artifactsDir, "analyzer-decisions.json");
-        if (incoming && incoming.value !== null && typeof incoming.value === "object") {
+        const incoming = await consumeObjectIncoming(params.artifactsDir, "analyzer-decisions.json");
+        if (incoming.status === "quarantined") {
+            // A non-object top-level value used to be neither merged, deleted, nor
+            // diagnosed — the file lingered in incoming/ and the analyzer_install
+            // step re-emitted silently forever. Quarantined + diagnosed instead.
+            return { action: "continue" };
+        }
+        if (incoming.status === "ok") {
             const settings = {};
             for (const [id, value] of Object.entries(incoming.value)) {
                 if (value === "ephemeral" ||
@@ -274,15 +281,37 @@ export async function handleGraphEnrichmentBranch(params, bundle, state, analyze
         if (candidates.length > 0) {
             const edgeReasoningIncoming = await tryConsumeIncoming(params.artifactsDir, "edge-reasoning.json");
             if (edgeReasoningIncoming) {
-                await runAuditStep({
+                // Same hazard class as the design-review quarantine fix: a malformed
+                // submission used to no-op silently inside applyEdgeReasoning (it never
+                // throws), the unconditional unlink then destroyed the file, and the
+                // identical edge_reasoning step re-emitted with zero signal. Tolerant-
+                // unwrap first (EdgeReasoningResults is a single-array-property object,
+                // so the same "exactly one array-valued top-level property" rule
+                // applies, and a bare rewrites array is accepted too); anything else is
+                // quarantined and named in the re-emitted step's prompt.
+                const unwrapped = unwrapIncomingArray(edgeReasoningIncoming.value);
+                if (!unwrapped.ok) {
+                    const quarantinePath = await quarantineIncomingFile(params.artifactsDir, edgeReasoningIncoming.path, "edge-reasoning.json");
+                    await recordEdgeReasoningRejection(params.artifactsDir, {
+                        filename: "edge-reasoning.json",
+                        quarantine_path: quarantinePath,
+                        reason: unwrapped.reason,
+                        rejected_at: new Date().toISOString(),
+                    });
+                    return { action: "continue" };
+                }
+                // Apply BEFORE deleting the incoming file: if runStep throws (locks,
+                // crash), the submission survives for the retry instead of being lost.
+                await runStep({
                     root: params.root,
                     artifactsDir: params.artifactsDir,
                     analyzers: analyzersRef.value,
                     graphLlmEdgeReasoning: true,
-                    edgeReasoningResultsPath: edgeReasoningIncoming.path,
+                    edgeReasoningResults: { rewrites: unwrapped.array },
                     since: params.since,
                 });
                 await unlink(edgeReasoningIncoming.path).catch(() => { });
+                await clearEdgeReasoningRejection(params.artifactsDir);
                 return { action: "continue" };
             }
             return { action: "return", result: { kind: "edge_reasoning", state, bundle, candidates } };
@@ -310,45 +339,245 @@ function passIsStale(bundle, pass) {
     const snapshot = bundle.design_review_snapshots?.[pass];
     return snapshot ? isDesignReviewStale(snapshot, bundle) : false;
 }
+/** Human-readable description of why an incoming value is neither an array nor a single-array-wrapped object. */
+function describeIncomingShapeMismatch(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "an array"; // reachable from consumeObjectIncoming (an array is not a key→value map)
+    const t = typeof value;
+    if (t !== "object")
+        return `a bare ${t}`;
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return "an empty object";
+    const arrayKeys = entries.filter(([, v]) => Array.isArray(v)).map(([k]) => k);
+    const allKeys = entries.map(([k]) => k).join(", ");
+    if (arrayKeys.length === 0) {
+        return `an object with no array-valued properties (keys: ${allKeys})`;
+    }
+    return (`an object with ${arrayKeys.length} array-valued propert${arrayKeys.length === 1 ? "y" : "ies"} ` +
+        `out of ${entries.length} total key(s) (${allKeys}) — exactly one top-level array property is ` +
+        `required for the tolerant unwrap`);
+}
+/**
+ * Move a malformed incoming submission to `<artifactsDir>/quarantine/` rather
+ * than deleting it. Falls back to copy+unlink if `rename` fails (e.g. a
+ * cross-device incoming/ mount) so the content is never lost.
+ */
+async function quarantineIncomingFile(artifactsDir, filePath, originalFilename) {
+    const quarantineDir = join(artifactsDir, "quarantine");
+    await mkdir(quarantineDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const quarantinePath = join(quarantineDir, `${originalFilename}.${timestamp}.json`);
+    try {
+        await rename(filePath, quarantinePath);
+    }
+    catch {
+        try {
+            const content = await readFile(filePath, "utf8");
+            await writeFile(quarantinePath, content, "utf8");
+        }
+        catch {
+            // Best-effort: nothing left to quarantine if even the read failed.
+        }
+        await unlink(filePath).catch(() => { });
+    }
+    return quarantinePath;
+}
+/**
+ * The single tolerant-unwrap rule: a bare array is accepted as-is; a top-level
+ * object wrapping exactly one array-valued property is unambiguous and is
+ * accepted as that array. Anything else fails with a shape description.
+ * Single-sourced so `consumeArrayIncoming` and the edge-reasoning gate cannot
+ * drift on what shapes are accepted.
+ */
+function unwrapIncomingArray(value) {
+    if (Array.isArray(value))
+        return { ok: true, array: value };
+    if (value !== null && typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 1 && Array.isArray(entries[0][1])) {
+            return { ok: true, array: entries[0][1] };
+        }
+    }
+    return { ok: false, reason: describeIncomingShapeMismatch(value) };
+}
+/**
+ * Read a JSON `incoming/` file expected to be an array (or a top-level object
+ * wrapping exactly one array-valued property, the tolerant unwrap). Accepts
+ * either shape and deletes the source file; any other shape is quarantined
+ * (never unlinked-and-discarded) and reported with a reason.
+ */
+export async function consumeArrayIncoming(artifactsDir, filename) {
+    const incoming = await tryConsumeIncoming(artifactsDir, filename);
+    if (!incoming)
+        return { status: "absent" };
+    const { value, path } = incoming;
+    const unwrapped = unwrapIncomingArray(value);
+    if (unwrapped.ok) {
+        await unlink(path).catch(() => { });
+        return { status: "ok", value: unwrapped.array, path };
+    }
+    const quarantinePath = await quarantineIncomingFile(artifactsDir, path, filename);
+    return { status: "quarantined", quarantinePath, originalFilename: filename, reason: unwrapped.reason };
+}
+/**
+ * Read a JSON `incoming/` file expected to be a plain top-level object (a
+ * key → value map, e.g. analyzer-decisions.json). A non-object value — null,
+ * an array, a bare primitive — is quarantined with a stderr diagnostic rather
+ * than left lingering in `incoming/` (where it used to make the emitting step
+ * re-ask silently forever). Unlike `consumeArrayIncoming`, an accepted file is
+ * NOT deleted here — the caller unlinks after applying, so a crash mid-apply
+ * retains the submission for the retry.
+ */
+export async function consumeObjectIncoming(artifactsDir, filename) {
+    const incoming = await tryConsumeIncoming(artifactsDir, filename);
+    if (!incoming)
+        return { status: "absent" };
+    const { value, path } = incoming;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return { status: "ok", value: value, path };
+    }
+    const reason = describeIncomingShapeMismatch(value);
+    const quarantinePath = await quarantineIncomingFile(artifactsDir, path, filename);
+    process.stderr.write(`[audit-code] ${filename} quarantined to ${quarantinePath}: expected a JSON object, got ${reason}. ` +
+        `Fix the shape and resubmit.\n`);
+    return { status: "quarantined", quarantinePath, reason };
+}
+function edgeReasoningRejectionPath(artifactsDir) {
+    return join(artifactsDir, "quarantine", "edge-reasoning.rejection.json");
+}
+async function recordEdgeReasoningRejection(artifactsDir, rejection) {
+    await mkdir(join(artifactsDir, "quarantine"), { recursive: true });
+    await writeJsonFile(edgeReasoningRejectionPath(artifactsDir), rejection);
+}
+async function clearEdgeReasoningRejection(artifactsDir) {
+    await unlink(edgeReasoningRejectionPath(artifactsDir)).catch(() => { });
+}
+/**
+ * Render the host-facing notice for a pending quarantined edge-reasoning
+ * submission, naming the quarantined file and the shape error — so the
+ * re-emitted edge_reasoning step tells the host its prior submission was
+ * rejected and why, rather than silently asking again. Returns `undefined`
+ * when there is nothing to report.
+ */
+export async function renderEdgeReasoningRejectionNotice(artifactsDir) {
+    let rejection;
+    try {
+        rejection = await readJsonFile(edgeReasoningRejectionPath(artifactsDir));
+    }
+    catch (error) {
+        if (isFileMissingError(error))
+            return undefined;
+        throw error;
+    }
+    return [
+        "## Prior submission rejected",
+        "",
+        "Your last edge-reasoning submission did not match the expected shape and was " +
+            "quarantined (not applied, not silently discarded). Fix the shape and resubmit:",
+        "",
+        `- \`${rejection.filename}\` quarantined to \`${rejection.quarantine_path}\` (${rejection.rejected_at}): ${rejection.reason}`,
+        "",
+        'Expected shape: {"rewrites":[{"from":"...","to":"...","kind":"...","reason":"..."}]} — ' +
+            "a bare JSON array of rewrites is also accepted.",
+    ].join("\n");
+}
+/**
+ * Record a quarantined design-review submission on `design_assessment` (and
+ * persist immediately) so the note survives the same-call `continue`
+ * re-derivation. A no-op when `design_assessment` doesn't exist yet — in
+ * practice unreachable, since `design_assessment_current` is a
+ * higher-priority obligation than either design-review pass (PRIORITY in
+ * nextStep.ts), so `design_assessment` always exists by the time this branch
+ * runs.
+ */
+async function recordRejectedDesignReviewSubmission(artifactsDir, existing, pass, quarantined) {
+    if (!existing)
+        return;
+    const entry = {
+        pass,
+        filename: quarantined.originalFilename,
+        quarantine_path: quarantined.quarantinePath,
+        reason: quarantined.reason,
+        rejected_at: new Date().toISOString(),
+    };
+    existing.rejected_submissions = [
+        ...(existing.rejected_submissions ?? []).filter((r) => r.pass !== pass),
+        entry,
+    ];
+    await writeJsonFile(join(artifactsDir, "design_assessment.json"), existing);
+}
+/**
+ * Render a host-facing notice for any pending quarantined design-review
+ * submissions matching the given passes, naming the quarantined file and the
+ * shape error — so a re-emitted design-review step tells the host its prior
+ * submission was rejected and why, rather than silently asking again.
+ * Returns `undefined` when there is nothing to report.
+ */
+export function renderDesignReviewRejectionNotice(bundle, passes) {
+    const rejected = (bundle.design_assessment?.rejected_submissions ?? []).filter((r) => passes.includes(r.pass));
+    if (rejected.length === 0)
+        return undefined;
+    const lines = [
+        "## Prior submission rejected",
+        "",
+        "Your last submission for this pass did not match the expected shape and was " +
+            "quarantined (not merged, not silently discarded). Fix the shape and resubmit:",
+        "",
+    ];
+    for (const r of rejected) {
+        lines.push(`- **${r.pass}** — \`${r.filename}\` quarantined to \`${r.quarantine_path}\` (${r.rejected_at}): ${r.reason}`);
+    }
+    lines.push("", "Expected shape: a JSON array of findings, or a top-level object wrapping exactly " +
+        'one array-valued property (e.g. `{"findings": [...]}`).');
+    return lines.join("\n");
+}
 export async function handleDesignReviewBranch(params, bundle, state) {
     const existing = bundle.design_assessment;
-    // Legacy: consume old combined findings file. Always unlink when present to
-    // prevent accumulation, even when design_assessment is absent (COR-68f07c3e).
-    const legacyIncoming = await tryConsumeIncoming(params.artifactsDir, "design-review-findings.json");
-    if (legacyIncoming) {
-        await unlink(legacyIncoming.path).catch(() => { });
-        if (Array.isArray(legacyIncoming.value) && existing) {
-            existing.review_findings = groundDesignFindings(legacyIncoming.value, bundle.repo_manifest);
+    // Legacy: consume old combined findings file. Tolerant-unwrap or quarantine
+    // (never a bare unconditional delete) — see the quarantine block comment above.
+    const legacyResult = await consumeArrayIncoming(params.artifactsDir, "design-review-findings.json");
+    if (legacyResult.status === "quarantined") {
+        await recordRejectedDesignReviewSubmission(params.artifactsDir, existing, "legacy", legacyResult);
+        return { action: "continue" };
+    }
+    if (legacyResult.status === "ok") {
+        if (existing) {
+            existing.review_findings = groundDesignFindings(legacyResult.value, bundle.repo_manifest);
             existing.reviewed = true;
+            existing.rejected_submissions = (existing.rejected_submissions ?? []).filter((r) => r.pass !== "legacy");
             await writeJsonFile(join(params.artifactsDir, "design_assessment.json"), existing);
             return { action: "continue" };
         }
-        // File consumed (deleted) but no target to merge into — keep folding.
+        // File consumed but no target to merge into — keep folding.
         return { action: "continue" };
     }
+    // absent: fall through to the contract/conceptual check.
     // New: consume contract-findings and/or conceptual-findings independently.
-    const contractIncoming = await tryConsumeIncoming(params.artifactsDir, "design-review-contract-findings.json");
-    const conceptualIncoming = await tryConsumeIncoming(params.artifactsDir, "design-review-conceptual-findings.json");
+    const contractResult = await consumeArrayIncoming(params.artifactsDir, "design-review-contract-findings.json");
+    const conceptualResult = await consumeArrayIncoming(params.artifactsDir, "design-review-conceptual-findings.json");
     let consumed = false;
-    // Always delete incoming files when present; only merge data when existing
-    // design_assessment is present (COR-68f07c3e).
-    if (contractIncoming) {
-        await unlink(contractIncoming.path).catch(() => { });
-        if (Array.isArray(contractIncoming.value) && existing) {
-            existing.contract_findings = groundDesignFindings(contractIncoming.value, bundle.repo_manifest);
-            existing.contract_reviewed = true;
-            consumed = true;
-        }
+    if (contractResult.status === "quarantined") {
+        await recordRejectedDesignReviewSubmission(params.artifactsDir, existing, "contract", contractResult);
     }
-    if (conceptualIncoming) {
-        await unlink(conceptualIncoming.path).catch(() => { });
-        if (Array.isArray(conceptualIncoming.value) && existing) {
-            existing.conceptual_findings = groundDesignFindings(conceptualIncoming.value, bundle.repo_manifest);
-            existing.conceptual_reviewed = true;
-            consumed = true;
-        }
+    else if (contractResult.status === "ok" && existing) {
+        existing.contract_findings = groundDesignFindings(contractResult.value, bundle.repo_manifest);
+        existing.contract_reviewed = true;
+        existing.rejected_submissions = (existing.rejected_submissions ?? []).filter((r) => r.pass !== "contract");
+        consumed = true;
+    }
+    if (conceptualResult.status === "quarantined") {
+        await recordRejectedDesignReviewSubmission(params.artifactsDir, existing, "conceptual", conceptualResult);
     }
-    if (contractIncoming || conceptualIncoming) {
+    else if (conceptualResult.status === "ok" && existing) {
+        existing.conceptual_findings = groundDesignFindings(conceptualResult.value, bundle.repo_manifest);
+        existing.conceptual_reviewed = true;
+        existing.rejected_submissions = (existing.rejected_submissions ?? []).filter((r) => r.pass !== "conceptual");
+        consumed = true;
+    }
+    if (contractResult.status !== "absent" || conceptualResult.status !== "absent") {
         // Item C: the design-review fan-out results are in — release the host-fan-out
         // panel's leases now, before the coverage packet dispatch that follows, rather
         // than letting them linger to the 20-min TTL and depress its headroom.
@@ -362,10 +591,10 @@ export async function handleDesignReviewBranch(params, bundle, state) {
         // rather than a blind full re-run. Capture after the design_assessment write
         // so the projection reflects the persisted findings.
         const reviewedAt = new Date().toISOString();
-        if (contractIncoming) {
+        if (contractResult.status === "ok") {
             await captureDesignReviewSnapshot(params.artifactsDir, "contract", existing.contract_findings ?? [], bundle, reviewedAt);
         }
-        if (conceptualIncoming) {
+        if (conceptualResult.status === "ok") {
             await captureDesignReviewSnapshot(params.artifactsDir, "conceptual", existing.conceptual_findings ?? [], bundle, reviewedAt);
         }
         return { action: "continue" };
@@ -819,6 +1048,14 @@ export async function checkFinalizationCycle(ctx) {
 function gateKeys(gate) {
     return (gate?.newlyReachable ?? []).map((b) => b.key);
 }
+/**
+ * The capability-evidence delta as bare model ids. Read through the shared gate object
+ * on every call for exactly the same reason as {@link gateKeys} — the executor clears
+ * it on promotion, and a stale read re-selects `PRIORITY[0]` forever.
+ */
+function gateUnevidencedCapability(gate) {
+    return gate?.unevidencedCapability ?? [];
+}
 /**
  * A deterministic-executor `emit` of a blocked step — the `!progress_made`
  * dead-end the hand loop returned directly from `executeAndRecord`.
@@ -853,6 +1090,7 @@ async function runDeterministicExecutor(bundle, ctx) {
     // executor for the one the engine actually picked.
     const decision = decideNextStep(bundle, {
         newlyReachableBackends: gateKeys(ctx.params.providerConfirmationGate),
+        unevidencedCapabilityPools: gateUnevidencedCapability(ctx.params.providerConfirmationGate),
     });
     const noProgress = await checkNoProgressBeforeDispatch({
         index: ctx.iterationRef.value,
@@ -902,6 +1140,7 @@ function deriveObligationState(id, gate) {
             return "satisfied";
         const state = deriveAuditState(bundle, {
             newlyReachableBackends: gateKeys(gate),
+            unevidencedCapabilityPools: gateUnevidencedCapability(gate),
         });
         const found = state.obligations.find((o) => o.id === id);
         if (!found)
@@ -945,10 +1184,42 @@ export function buildAuditObligations(gate) {
                     // Operator has submitted → consume it (writes both canonical artifacts).
                     return runDeterministicExecutor(bundle, ctx);
                 }
-                if ((gate?.newlyReachable.length ?? 0) > 0 && gate?.autonomous) {
-                    // G3, autonomous: a backend the operator never confirmed became reachable
-                    // and there is nobody to ask. Fold to the executor, which fail-closed-
-                    // excludes it + records the friction — never emit a prompt no one will read.
+                // `?.` on the property too, not just `gate` itself: unlike the old single
+                // `||` expression (whose short-circuit meant a fixture setting only one of
+                // the two fields never evaluated the other), both are now read
+                // unconditionally below, so an omitted field must degrade to `0`, not throw.
+                const capabilityDelta = (gate?.unevidencedCapability?.length ?? 0) > 0;
+                const reachDelta = (gate?.newlyReachable?.length ?? 0) > 0;
+                if (gate?.autonomous && capabilityDelta) {
+                    // R3-3: autonomous ≠ "no LLM" — it means no HUMAN operator. `next-step`
+                    // still returns a prompt contract to the host agent driving the run, so a
+                    // capability-evidence delta on an autonomous run EMITS the ranker prompt
+                    // addressed to that host LLM instead of folding to the executor (which
+                    // today can only promote the pools unranked — a loud fail-open, not a
+                    // fix). The reach delta, if also present, does NOT get asked here: reach
+                    // is never an LLM's call (the executor fails it closed regardless of what
+                    // this submission says — see `intakeExecutors.ts`'s `authoredByLlm`), so
+                    // the prompt omits that section entirely and the reach delta is resolved
+                    // on a LATER attended re-confirmation, not this one.
+                    return {
+                        kind: "emit",
+                        step: {
+                            kind: "provider_confirmation",
+                            state: deriveAuditState(bundle, {
+                                newlyReachableBackends: gateKeys(gate),
+                                unevidencedCapabilityPools: gateUnevidencedCapability(gate),
+                            }),
+                            bundle,
+                        },
+                    };
+                }
+                if (gate?.autonomous && reachDelta) {
+                    // G3, autonomous, reach-only (no capability delta): a backend the operator
+                    // never confirmed became reachable and there is nobody to ask — and unlike
+                    // capability, reach is not something an LLM may answer on the operator's
+                    // behalf either (see the executor's sharp edge). Fold to the executor,
+                    // which fail-closed-excludes it + records the friction — never emit a
+                    // prompt no one will read.
                     //
                     // Scoped to the DELTA case deliberately: a first-time confirmation (no
                     // artifact at all) still pauses even under `autonomous_mode`, exactly as
@@ -966,6 +1237,7 @@ export function buildAuditObligations(gate) {
                         kind: "provider_confirmation",
                         state: deriveAuditState(bundle, {
                             newlyReachableBackends: gateKeys(gate),
+                            unevidencedCapabilityPools: gateUnevidencedCapability(gate),
                         }),
                         bundle,
                     },
@@ -1206,6 +1478,10 @@ async function runHostDelegationObligation(bundle, ctx) {
     const auditExcludedBackends = resolveDispatchExclusion(await readConfirmedDispatchPolicy(ctx.params.root));
     const { pools: auditSourcePools, zeroedByExclusion } = await buildAuditSourcePools(hybridCfg, {
         excludedBackends: auditExcludedBackends,
+        // These pools ARE the headless rolling drive's `poolsOverride`, not a preview —
+        // omitting the ranks here would leave every headless audit run fail-opening at the
+        // capability floor, the exact behavior this obligation exists to remove.
+        capabilityRanks: await readConfirmedCapabilityRanks(ctx.params.root),
         // D1 cross-class collision rule: an attended host identity colliding with a
         // folded source keeps exactly one pool (the in-process source survives — the
         // engine drives that one account; a non-in-process collider is dropped).