abelien-harness 0.4.0 → 0.6.0

package/skills/abelien-hardware/scripts/search-index-release.mjs

@@ -21,6 +21,12 @@ function parseJson(bytes, code, key) {
   catch { throw releaseError(code, `invalid JSON object: ${key}`, { key }); }
 }
 
+// 回滚点只作记录：旧 catalog 坏了也不阻断本次激活，release_id 记 null。
+function previousReleaseId(object) {
+  try { return JSON.parse(Buffer.from(object.bytes).toString("utf8")).release_id ?? null; }
+  catch { return null; }
+}
+
 function safeFile(root, relative) {
   const base = path.resolve(root);
   const file = path.resolve(base, relative);
@@ -133,10 +139,7 @@ async function bootstrapRemoteManifest({ config, catalog, sourceDir, fetchImpl,
     if (actual !== entry.sha256) throw releaseError("REMOTE_WIKI_MISMATCH", "remote Wiki SHA-256 does not match Manifest", { key, expected_sha256: entry.sha256, actual_sha256: actual });
   });
   const key = `${config.prefix}${catalog.source_manifest.object_key || "_manifest.json"}`;
-  await putTosObject(config, key, manifestBytes, {
-    fetchImpl,
-    headers: { "content-type": "application/json", "if-none-match": "*", "x-amz-meta-sha256": sha256(manifestBytes) },
-  });
+  await putImmutable(config, key, manifestBytes, fetchImpl);
   const uploaded = await getTosObject(config, key, { fetchImpl });
   if (sha256(uploaded.bytes) !== catalog.source_manifest.sha256) {
     throw releaseError("SOURCE_MANIFEST_MISMATCH", "uploaded Wiki Manifest SHA-256 mismatch", { key });
@@ -144,6 +147,15 @@ async function bootstrapRemoteManifest({ config, catalog, sourceDir, fetchImpl,
   return { key, etag: uploaded.etag, sha256: catalog.source_manifest.sha256, bootstrapped: true, verified_wiki_objects: manifest.length };
 }
 
+function objectContentType(key) {
+  if (key.endsWith(".gz")) return "application/gzip";
+  if (key.endsWith(".md")) return "text/markdown; charset=utf-8";
+  return "application/json";
+}
+
+// 阿里云 OSS 的 S3 兼容写入没有条件 PUT：If-None-Match / If-Match 一律 400 NotImplemented，
+// x-oss-forbid-overwrite 被忽略照常覆盖。不可变对象因此靠"先读后写 + 回读 SHA"：键按内容寻址，
+// 并发写同一键只会写入同一份字节；已存在但字节不同即冲突失败，不覆盖。
 async function putImmutable(config, key, bytes, fetchImpl) {
   const expected = sha256(bytes);
   const existing = await getTosObject(config, key, { fetchImpl, optional: true });
@@ -152,14 +164,10 @@ async function putImmutable(config, key, bytes, fetchImpl) {
     if (actual !== expected) throw releaseError("IMMUTABLE_OBJECT_CONFLICT", "release object already exists with different bytes", { key, expected_sha256: expected, actual_sha256: actual });
     return { key, sha256: expected, reused: true };
   }
-  try {
-    await putTosObject(config, key, bytes, {
-      fetchImpl,
-      headers: { "content-type": key.endsWith(".gz") ? "application/gzip" : "application/json", "if-none-match": "*" },
-    });
-  } catch (cause) {
-    if (cause.code !== "TOS_HTTP_STATUS" || cause.details?.status !== 412) throw cause;
-  }
+  await putTosObject(config, key, bytes, {
+    fetchImpl,
+    headers: { "content-type": objectContentType(key), "x-amz-meta-sha256": expected },
+  });
   const uploaded = await getTosObject(config, key, { fetchImpl });
   const actual = sha256(uploaded.bytes);
   if (actual !== expected) throw releaseError("INDEX_UPLOAD_VERIFY_FAILED", "uploaded release object SHA-256 mismatch", { key, expected_sha256: expected, actual_sha256: actual });
@@ -290,11 +298,15 @@ export async function publishHardwareSearchIndex({ sourceDir, outputDir, release
     const uploaded = await mapConcurrent(local.files, Number.isFinite(limit) ? limit : 6, item =>
       putImmutable(config, `${config.prefix}${item.key}`, item.bytes, fetchImpl));
 
-    const catalogHeaders = {
-      "content-type": "application/json",
-      ...(previousCatalog ? { "if-match": `"${previousCatalog.etag}"` } : { "if-none-match": "*" }),
-    };
-    await putTosObject(config, catalogKey, local.catalogBytes, { fetchImpl, headers: catalogHeaders });
+    // OSS 没有条件 PUT（见 putImmutable），激活前按内容 SHA 重读比对；OSS 对 JSON 对象不回 ETag，
+    // 故不能比 ETag。重读到写入之间仍有窗口，写后 verify 的 release_id 比对兜住输掉的竞争。
+    const previousSha256 = previousCatalog ? sha256(previousCatalog.bytes) : null;
+    const currentCatalog = await getTosObject(config, catalogKey, { fetchImpl, optional: true });
+    const currentSha256 = currentCatalog ? sha256(currentCatalog.bytes) : null;
+    if (currentSha256 !== previousSha256) {
+      throw releaseError("CATALOG_ACTIVATION_RACE", "active catalog changed while this release was uploading", { expected_sha256: previousSha256, actual_sha256: currentSha256 });
+    }
+    await putTosObject(config, catalogKey, local.catalogBytes, { fetchImpl, headers: { "content-type": "application/json" } });
     const verified = await verifyPublishedIndex({ env, fetchImpl, concurrency: limit });
     if (verified.release_id !== local.catalog.release_id) {
       throw releaseError("CATALOG_ACTIVATION_RACE", "active catalog is not the release just published", { expected_release_id: local.catalog.release_id, actual_release_id: verified.release_id });
@@ -308,6 +320,7 @@ export async function publishHardwareSearchIndex({ sourceDir, outputDir, release
       uploaded_shards: uploaded.filter(item => !item.reused).length,
       reused_shards: uploaded.filter(item => item.reused).length,
       catalog_key: catalogKey,
+      previous_catalog: previousCatalog ? { sha256: previousSha256, release_id: previousReleaseId(previousCatalog) } : null,
       verified,
       smoke: smokeResult,
     };

package/skills/abelien-hardware/scripts/selection-request.mjs

@@ -1,8 +1,7 @@
-import { createHash } from "node:crypto";
-export const canonical = value => value === null || typeof value !== "object" ? JSON.stringify(value)
-  : Array.isArray(value) ? `[${value.map(canonical).join(",")}]`
-    : `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
-export const digest = value => createHash("sha256").update(canonical(value)).digest("hex");
+// One canonical/digest for every evidence hash: the kernel writes Volc receipts with it, so verification must use the same function.
+import { canonical, digest } from "../../abelien-harness/scripts/web/common.mjs";
+import { validateFitEnvelope } from "./dimensions.mjs";
+export { canonical, digest };
 // Bind recall to complete requirements and slots, never an Agent summary.
 export const selectionRequestDigest = input => digest({ requirements: input.requirements ?? {}, slots: input.slots ?? [] });
 
@@ -19,6 +18,8 @@ export function validateSelectionSlots(slots) {
       || !validCategoryPath(slot.category_path)
       || !slot.hard_constraints || typeof slot.hard_constraints !== "object" || Array.isArray(slot.hard_constraints))
       invalid(`slots[${index}] needs slot_id, function, explicit integer quantity, three nonempty category levels (no null), and hard_constraints object; read level1/level2 guides before correcting the reply`);
+    // Optional structure zone budget (P2-06.03); its absence keeps the original behavior.
+    if (slot.fit_envelope !== undefined) validateFitEnvelope(slot.fit_envelope);
   }
   return slots;
 }

package/skills/abelien-hardware/scripts/tos-wiki-search.mjs

@@ -1,5 +1,6 @@
 import zlib from "node:zlib";
-import { dimensionFields, evaluateDimensions, orderByDimensionTier, sameDimensionMetadata, screenDimensions, shortlistByDimensionTier, validateRequirementEnvelopes } from "./dimensions.mjs";
+import { dimensionFields, evaluateDimensions, orderByDimensionTier, sameDimensionMetadata, screenDimensions, shortlistByDimensionTier, validateFitEnvelope, validateRequirementEnvelopes } from "./dimensions.mjs";
+import { electricalFields } from "./electrical.mjs";
 import { selectionRequestDigest, validCategoryPath } from "./selection-request.mjs";
 import { createTosConfig, getTosObject, sha256 } from "./tos-object-store.mjs";
 
@@ -82,13 +83,15 @@ export function parseHardwareWiki(content) {
     "schema", "type", "title", "description", "manufacturer", "model", "aliases", "resource_urn", "record_id",
     "record_version", "status", "category_path", "category_leaf", "primary_function", "integration_level",
     "hardware_form", "component_kind", "functional_capabilities", "capability_coverage", "source_url", "source_updated_at",
-    "dimensions_mm", "dimension_basis", "dimension_geometry", "dimension_source", "interfaces",
+    "dimensions_mm", "dimension_basis", "dimension_geometry", "dimension_source", "interfaces", "electrical", "electrical_source",
   ];
   const meta = {};
   for (const key of wanted) {
-    const line = frontMatter.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
-    if (line) {
-      if (key === "dimension_source" || key === "dimensions_mm") {
+    // Same-line value only: \s* would cross the newline and read the next line as this key's value.
+    // An empty value (including YAML block style) is treated as absent, as before these keys were read.
+    const line = frontMatter.match(new RegExp(`^${key}:[ \\t]*(.*)$`, "m"));
+    if (line && line[1].trim()) {
+      if (["dimension_source", "dimensions_mm", "electrical", "electrical_source"].includes(key)) {
         try { meta[key] = JSON.parse(line[1]); }
         catch { throw error("WIKI_INVALID", `${key} must be generated inline JSON`); }
       } else meta[key] = scalar(line[1]);
@@ -234,6 +237,7 @@ function validateInput(input) {
     if (!slot?.slot_id || !validCategoryPath(slot.category_path)) {
       throw error("VALIDATION", "each hardware search slot needs slot_id and three nonempty category_path levels (no null)");
     }
+    if (slot.fit_envelope !== undefined) validateFitEnvelope(slot.fit_envelope);
   }
 }
 
@@ -270,6 +274,7 @@ function candidateFromDocument(document, config, ranking, includeContent, indexS
     title: meta.title,
     name: meta.title,
     ...dimensionFields(meta),
+    ...electricalFields(meta),
     ...(meta.interfaces !== undefined ? { interfaces: meta.interfaces } : {}),
     category_path: meta.category_path,
     integration_level: meta.integration_level,
@@ -347,7 +352,7 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     }
     const index = await loadIndex(descriptor);
     const semanticQuery = semanticQueryFor(input, slot);
-    const screen = screenDimensions(index.records, input.requirements);
+    const screen = screenDimensions(index.records, input.requirements, slot);
     const rankedIndex = screen.survivors.map(({ record: entry, check }) => ({
       entry, check,
       ranking: scoreIndexEntry(entry, semanticQuery, input.policy?.prefer_system_candidates !== false),
@@ -359,7 +364,7 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     const candidates = orderByDimensionTier(loaded.map(({ document, indexRanking }) => {
       const ranking = scoreDocument(document, semanticQuery, input.policy?.prefer_system_candidates !== false);
       const candidate = candidateFromDocument(document, config, ranking, includeContent, indexRanking.score);
-      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements) };
+      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements, slot) };
     }).sort((a, b) => b.semantic_score - a.semantic_score || b.index_score - a.index_score || String(a.model).localeCompare(String(b.model))), candidate => candidate.dimension_check.status);
     if (candidates.length === 0) unmatchedSlots.push(slot.slot_id);
     results.push({
@@ -405,7 +410,7 @@ async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, m
     const candidates = shortlistByDimensionTier(loaded.map(document => {
       const ranking = scoreDocument(document, semanticQuery, input.policy?.prefer_system_candidates !== false);
       const candidate = candidateFromDocument(document, config, ranking, includeContent, ranking.score);
-      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements) };
+      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements, slot) };
     }).filter(candidate => candidate.dimension_check.status !== "incompatible").sort((a, b) => b.semantic_score - a.semantic_score || String(a.model).localeCompare(String(b.model))), topK, maxFetch, candidate => candidate.dimension_check.status);
     if (candidates.length === 0) unmatchedSlots.push(slot.slot_id);
     results.push({

package/skills/abelien-hardware/scripts/volc-web-search.mjs

@@ -1,28 +1,11 @@
-import { failure, text, timed } from "./web-common.mjs";
-import { sha256 } from "./public-page.mjs";
-import { digest } from "./selection-request.mjs";
+// Hardware binding of the kernel Volc client (P2-13.03). Codes, messages and receipts are unchanged.
+import { createVolcSearch } from "../../abelien-harness/scripts/web/volc.mjs";
 import { redactHardwareResponse } from "./response-redaction.mjs";
-import { receiptRequestId, validVolcResult } from "./web-receipt.mjs";
-export const volcQueryRequest = item => ({ Query: item.query, SearchType: "web", Count: item.count ?? 10, Filter: { NeedUrl: true, NeedContent: false }, ContentFormats: "markdown", QueryControl: { QueryRewrite: false } });
-export function validateVolcCapability(body) {
-  if (!text(body.Query) || !Number.isSafeInteger(body.Count) || body.Count < 1 || body.Count > 50) throw failure("HARDWARE_WEB_CAPABILITY", "Volc Query must be nonempty and Count 1–50; original input is retained without truncation");
-}
-export async function volcWebSearch(body, { env, fetchImpl = fetch, timeoutMs }) {
-  validateVolcCapability(body);
-  const key = env.WEB_SEARCH_API_KEY;
-  if (!text(key) || /[\r\n\0]/.test(key)) throw failure("HARDWARE_WEB_CONFIG", "WEB_SEARCH_API_KEY is required from the trusted host");
-  try {
-    return await timed(async signal => {
-      const response = await fetchImpl("https://open.feedcoopapi.com/search_api/web_search", { method: "POST", redirect: "error", signal, headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" }, body: JSON.stringify(body) });
-      const raw = redactHardwareResponse(await response.text(), env), saved = { raw, raw_sha256: sha256(raw), response: null, response_sha256: null, request_id: null, http_status: response.status, received_at: new Date().toISOString() };
-      try { saved.response = JSON.parse(raw); saved.response_sha256 = digest(saved.response); saved.request_id = receiptRequestId({ ...saved, provider: "volcengine" }); } catch { /* Keep full received text. */ }
-      const reject = (code, message, unknown = false) => { const error = failure(code, message, { http_status: response.status }); Object.defineProperties(error, { providerEvidence: { value: saved }, ambiguous: { value: unknown } }); throw error; };
-      if (response.status >= 500) reject("HARDWARE_WEB_PROVIDER", "Volc server outcome is unknown", true);
-      if (response.status < 200 || response.status >= 300) reject([401, 403].includes(response.status) ? "HARDWARE_WEB_AUTH" : response.status === 429 ? "HARDWARE_WEB_RATE_LIMIT" : "HARDWARE_WEB_PROVIDER", "Volc HTTP request rejected");
-      const error = saved.response?.ResponseMetadata?.Error;
-      if (error) reject("HARDWARE_WEB_PROVIDER", "Volc reported an explicit error", !/^(104\d\d|700429)$/.test(String(error.Code ?? error.CodeN)));
-      if (!validVolcResult(saved.response)) reject("HARDWARE_WEB_RESPONSE", "Volc result is malformed or ambiguous", true);
-      return saved;
-    }, timeoutMs);
-  } catch (error) { if (error?.code?.startsWith("HARDWARE_WEB_")) throw error; throw failure("HARDWARE_WEB_TRANSPORT", "Volc transport outcome is unknown"); }
-}
+const volc = createVolcSearch({
+  codes: { capability: "HARDWARE_WEB_CAPABILITY", config: "HARDWARE_WEB_CONFIG", provider: "HARDWARE_WEB_PROVIDER", auth: "HARDWARE_WEB_AUTH",
+    rateLimit: "HARDWARE_WEB_RATE_LIMIT", response: "HARDWARE_WEB_RESPONSE", transport: "HARDWARE_WEB_TRANSPORT", timeout: "HARDWARE_WEB_TIMEOUT" },
+  ownsError: error => Boolean(error?.code?.startsWith("HARDWARE_WEB_")),
+  redact: redactHardwareResponse,
+  timeoutMessage: "hardware network request timed out",
+});
+export const { volcMaxCount, volcQueryRequest, legacyVolcQueryRequest, validateVolcCapability, volcWebSearch } = volc;

package/skills/abelien-hardware/scripts/web-common.mjs

@@ -1,9 +1,7 @@
+// Generic helpers live in the kernel (P2-13.03); this module binds hardware's codes and keeps hardware-only checks.
 import { selectionRequestDigest, digest, validateSelectionSlots } from "./selection-request.mjs";
-export const record = value => value && typeof value === "object" && !Array.isArray(value);
-export const text = value => typeof value === "string" && value.trim().length > 0;
-export function failure(code, message, details) { return Object.assign(new Error(message), { code, ...(details ? { details } : {}) }); }
-export function invalid(message) { throw failure("VALIDATION", message); }
-export function onlyKeys(value, keys, label) { if (!record(value) || Object.keys(value).some(key => !keys.includes(key))) invalid(`${label} has unsupported fields`); }
+import { record, text, failure, invalid, timed as kernelTimed } from "../../abelien-harness/scripts/web/common.mjs";
+export { record, text, failure, invalid, onlyKeys } from "../../abelien-harness/scripts/web/common.mjs";
 export async function boundRecall(input, readResource) {
   if (typeof readResource !== "function" || !/^hardware-recall:[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(input?.recall_id ?? "")) invalid("persisted recall_id and trusted resource reader required");
   if (!record(input.requirements)) invalid("original requirements required");
@@ -22,12 +20,11 @@ export function positiveEnv(env, name, fallback) {
 export function webConfig(env = {}) {
   const dnsTransport = env.ABELIEN_HARDWARE_WEB_DNS_TRANSPORT || "system";
   if (!["system", "doh"].includes(dnsTransport)) throw failure("HARDWARE_WEB_CONFIG", "web DNS transport must be system or doh");
-  return { dnsTransport, timeoutMs: positiveEnv(env, "ABELIEN_HARDWARE_WEB_SEARCH_TIMEOUT_MS", 30000),
+  // Prismer (query, URL-load and Parse) is temporarily off by default (P2-05.02).
+  const prismer = env.ABELIEN_HARDWARE_WEB_PRISMER || "disabled";
+  if (!["enabled", "disabled"].includes(prismer)) throw failure("HARDWARE_WEB_CONFIG", "Prismer switch must be enabled or disabled");
+  return { dnsTransport, prismer, timeoutMs: positiveEnv(env, "ABELIEN_HARDWARE_WEB_SEARCH_TIMEOUT_MS", 30000),
     pageTimeoutMs: positiveEnv(env, "ABELIEN_HARDWARE_WEB_PAGE_TIMEOUT_MS", 30000),
     parseTimeoutMs: positiveEnv(env, "ABELIEN_HARDWARE_WEB_PARSE_TIMEOUT_MS", 120000) };
 }
-export async function timed(operation, timeoutMs, code = "HARDWARE_WEB_TIMEOUT") {
-  const controller = new AbortController(); let timer;
-  try { return await Promise.race([operation(controller.signal), new Promise((_, reject) => { timer = setTimeout(() => { reject(failure(code, "hardware network request timed out")); controller.abort(); }, timeoutMs); })]); }
-  finally { clearTimeout(timer); }
-}
+export const timed = (operation, timeoutMs, code = "HARDWARE_WEB_TIMEOUT") => kernelTimed(operation, timeoutMs, code, "hardware network request timed out");

package/skills/abelien-hardware/scripts/web-integrity.mjs

@@ -115,7 +115,7 @@ export function verifyCheckpointExtension(checkpoint, latest, readBlob) {
   try {
     const before = checkpoint?.body, after = latest?.body;
     if (!before || !after || checkpoint.id !== latest.id || checkpoint.kind !== "hardware-web-evidence" || latest.kind !== checkpoint.kind
-      || !fixed(before, after, ["id", "provider", "protocol", "schema_version", "provider_policy", "recall_id", "recall_digest", "request_digest", "requirements", "slots", "plan_digest", "unresolved_slots"])
+      || !fixed(before, after, ["id", "provider", "protocol", "schema_version", "provider_policy", "recall_id", "recall_digest", "request_digest", "requirements", "slots", "plan_digest", "unresolved_slots", "prismer_switch"])
       || !prefix(before.query_plans, after.query_plans) || !prefix(before.unknowns, after.unknowns)
       || !prefix(before.searches, after.searches, before.protocol === chainProtocol ? group : attempt) || !prefix(before.pages, after.pages, page)) reject();
   } catch { reject(); }

package/skills/abelien-hardware/scripts/web-provider-chain.mjs

@@ -6,7 +6,7 @@ import { prismerRequest } from "./prismer.mjs";
 import { volcQueryRequest, validateVolcCapability, volcWebSearch } from "./volc-web-search.mjs";
 import { jsonReceipt } from "./web-receipt.mjs";
 import { redactHardwareResponse } from "./response-redaction.mjs";
-import { chainPolicy, chainProtocol, receiptFields, primaryQuery, sourceOperation, operationId, permitsFallback, expectedSelection, selectedReceipt, queryResults, projectQuery, sourceProjection, trustedResult, validateChainIntegrity } from "./provider-chain-contract.mjs";
+import { chainPolicy, chainProtocol, pinPrismerSwitch, receiptFields, primaryQuery, sourceOperation, operationId, permitsFallback, expectedSelection, selectedReceipt, queryResults, projectQuery, sourceProjection, trustedResult, validateChainIntegrity } from "./provider-chain-contract.mjs";
 
 // An effect is dispatched only after its original attempt has been saved. Receipt
 // persistence is outside the request catch: a storage failure cannot authorize fallback.
@@ -29,6 +29,7 @@ export async function searchProviderChain({ input, source, existing, env, readRe
   // Parse observations update the authoritative array and projection together.
   for (const page of evidence.pages) if (page.selected_attempt_id) page.attempt = selectedReceipt(page);
   const config = input.unresolved_slots.length ? webConfig(env) : null;
+  if (config) config.prismer = pinPrismerSwitch(evidence, config.prismer);
   const request = (path, body, timeoutMs, method = "POST") => prismerRequest(path, { body, env, fetchImpl, timeoutMs, method });
   const redact = raw => redactHardwareResponse(raw, env);
   const checkUrl = url => {
@@ -76,8 +77,13 @@ export async function searchProviderChain({ input, source, existing, env, readRe
     if (attempt.kind === "parse" && text(receipt.response?.taskId)) { attempt.task_id = receipt.response.taskId; attempt.status = "pending"; }
     await save();
   };
+  const skipPrismer = async attempt => { Object.assign(attempt, { status: "unavailable", reason: "prismer_disabled" }); await save(); };
   const chooseQuery = async (entry, item) => {
-    if (!entry.attempts.length) { const attempt = makeAttempt(entry, "prismer", "query", entry.request); await dispatch(attempt, () => request("/api/context/load", attempt.request, config.timeoutMs)); }
+    if (!entry.attempts.length) {
+      const attempt = makeAttempt(entry, "prismer", "query", entry.request);
+      if (config.prismer === "disabled") await skipPrismer(attempt);
+      else await dispatch(attempt, () => request("/api/context/load", attempt.request, config.timeoutMs));
+    }
     if (permitsFallback(entry.attempts[0], true) && entry.attempts.length === 1) { const attempt = makeAttempt(entry, "volcengine", "query", volcQueryRequest(item)); await dispatch(attempt, () => volcWebSearch(attempt.request, { env, fetchImpl, timeoutMs: config.timeoutMs })); }
     const selected = expectedSelection(entry, true);
     if (!selected) throw failure("HARDWARE_WEB_RECONCILIATION_REQUIRED", "original query effect is not known selectable");
@@ -131,7 +137,8 @@ export async function searchProviderChain({ input, source, existing, env, readRe
     const operation = sourceOperation(page.source_url);
     if (!page.attempts.length) {
       const attempt = makeAttempt(page, "prismer", operation.kind, operation.request);
-      await dispatch(attempt, () => request(operation.path, attempt.request, operation.kind === "parse" ? config.parseTimeoutMs : config.pageTimeoutMs));
+      if (config.prismer === "disabled") await skipPrismer(attempt);
+      else await dispatch(attempt, () => request(operation.path, attempt.request, operation.kind === "parse" ? config.parseTimeoutMs : config.pageTimeoutMs));
     }
     if (permitsFallback(page.attempts[0], false) && page.attempts.length === 1) {
       const attempt = makeAttempt(page, "direct_https", "direct_page", { url: page.source_url, method: "GET" });

package/skills/abelien-hardware/scripts/web-receipt.mjs

@@ -1,8 +1,11 @@
 import { digest } from "./selection-request.mjs";
 import { text } from "./web-common.mjs";
 import { sha256 } from "./public-page.mjs";
+import { validVolcResult, volcRequestId } from "../../abelien-harness/scripts/web/volc.mjs";
+export { validVolcResult };
 export const receiptRequestId = attempt => {
-  const id = attempt?.provider === "volcengine" ? attempt.response?.ResponseMetadata?.RequestId : attempt?.response?.requestId;
+  if (attempt?.provider === "volcengine") return volcRequestId(attempt.response);
+  const id = attempt?.response?.requestId;
   return text(id) ? id : null;
 };
 export function intactReceipt(attempt) {
@@ -14,7 +17,6 @@ export const successfulReceipt = attempt => intactReceipt(attempt) && attempt.ht
   && (attempt.provider === "volcengine" ? validVolcResult(attempt.response)
     : attempt.provider === "direct_https" ? ["read", "unavailable"].includes(attempt.response?.status)
       : attempt.response?.success === true && !attempt.response.error);
-export const validVolcResult = response => text(response?.ResponseMetadata?.RequestId) && !response.ResponseMetadata.Error && response.success !== false && Array.isArray(response.Result?.WebResults);
 export function jsonReceipt(response, httpStatus, provider, envRedact) {
   const raw = envRedact(JSON.stringify(response)), value = JSON.parse(raw);
   const saved = { raw, raw_sha256: sha256(raw), response: value, response_sha256: digest(value), received_at: new Date().toISOString(), http_status: httpStatus };

package/skills/abelien-hardware/scripts/web-search-plan.mjs

@@ -1,9 +1,17 @@
 import { onlyKeys, text, invalid, boundRecall } from "./web-common.mjs";
+import { volcMaxCount } from "./volc-web-search.mjs";
+
+const cjk = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 
 // Shared read-only plan validation. Do not normalize model intent or access
 // credentials/configuration/checkpoints before this original-source binding.
-export async function validateHardwareWebPlan({ input, readResource }) {
-  onlyKeys(input, ["requirements", "slots", "recall_id", "unresolved_slots"], "web search input");
+// The shape check alone is used for a plan already frozen in saved evidence.
+// plan_rules is an explicit opt-in written by the current workflow definitions; a run pinned
+// to an older definition omits it and keeps the rules its definition was published with.
+export const currentPlanRules = "volc-english-5";
+export async function validateFrozenHardwareWebPlan({ input, readResource }) {
+  onlyKeys(input, ["requirements", "slots", "recall_id", "unresolved_slots", "plan_rules"], "web search input");
+  if (Object.hasOwn(input, "plan_rules") && input.plan_rules !== currentPlanRules) invalid(`plan_rules must be ${currentPlanRules}`);
   const source = await boundRecall(input, readResource), recall = source.body;
   if (!Array.isArray(input.unresolved_slots)) invalid("unresolved_slots must be an array");
   const unresolved = new Set();
@@ -16,3 +24,14 @@ export async function validateHardwareWebPlan({ input, readResource }) {
   for (const slot of input.slots) if (!(recall.results.find(result => result.slot_id === slot.slot_id)?.candidates?.length) && !unresolved.has(slot.slot_id)) invalid("every zero-candidate slot needs an unresolved query; preserve the requirement");
   return { source };
 }
+// New plans (P2-05.02): English queries for Volc and at most 5 results per query.
+export function validateNewHardwareWebPlan(input) {
+  for (const item of input.unresolved_slots) {
+    if (item.count !== undefined && item.count > volcMaxCount) invalid(`search Count must be an integer from 1 to ${volcMaxCount}`);
+    if (cjk.test(item.query)) invalid("search query must be written in English; keep model numbers and manufacturer names");
+  }
+}
+export async function validateHardwareWebPlan({ input, readResource }) {
+  const result = await validateFrozenHardwareWebPlan({ input, readResource });
+  validateNewHardwareWebPlan(input); return result;
+}

package/skills/abelien-hardware/scripts/web-search.mjs

@@ -6,7 +6,7 @@ import { prismerRequest } from "./prismer.mjs";
 import { queryRequest, validateHardwareWebIntegrity, verifyCheckpointExtension, trustedParseResult } from "./web-integrity.mjs";
 import { chainProtocol } from "./provider-chain-contract.mjs";
 import { searchProviderChain } from "./web-provider-chain.mjs";
-import { validateHardwareWebPlan } from "./web-search-plan.mjs";
+import { validateFrozenHardwareWebPlan, validateNewHardwareWebPlan, currentPlanRules } from "./web-search-plan.mjs";
 const provider = "prismer", protocol = "prismer-context-parse-v1";
 const unresolvedAttempt = attempt => ["in_progress", "unknown", "failed"].includes(attempt?.status);
 export async function verifyHardwareWebRecovery({ input, readResource, readBlob }) {
@@ -16,13 +16,16 @@ export async function verifyHardwareWebRecovery({ input, readResource, readBlob
   await unchanged(source, readResource); await unchanged(saved, readResource); return { ok: true };
 }
 export async function searchHardwareWeb({ input, env = {}, readResource, fetchImpl = fetch, ports = {}, checkpoint, readBlob, writeBlob }) {
-  const { source } = await validateHardwareWebPlan({ input, readResource });
+  const { source } = await validateFrozenHardwareWebPlan({ input, readResource });
   const binding = { recall_id: source.id, recall_digest: digest(source), request_digest: selectionRequestDigest(input), requirements: input.requirements, slots: input.slots };
   const planDigest = digest(input.unresolved_slots), id = `web-evidence-${digest({ recall_id: binding.recall_id, request_digest: binding.request_digest }).slice(0, 24)}`;
   const storedExisting = await readResource(`hardware-web-evidence:${id}`);
   const existing = resolveWebEvidence(storedExisting, readBlob);
   const pack = body => packWebEvidence(body, writeBlob, !existing && env.AB_HARNESS_AUDIT_V1 === "true");
   if (existing && (existing.kind !== "hardware-web-evidence" || existing.body?.recall_id !== binding.recall_id || existing.body.request_digest !== binding.request_digest)) invalid("existing evidence has a different original identity");
+  // A plan frozen in saved evidence keeps the rules it was accepted under; an input without
+  // plan_rules comes from a run pinned to a pre-P2-05.02 definition and keeps its old rules.
+  if (input.plan_rules === currentPlanRules && existing?.body.plan_digest !== planDigest) validateNewHardwareWebPlan(input);
   if (!existing || existing.body.protocol === chainProtocol) return searchProviderChain({ input, source, existing: storedExisting, env, readResource, fetchImpl, ports, checkpoint, readBlob, writeBlob });
   if (existing && (existing.body.provider !== provider || existing.body.protocol !== protocol)) throw failure("HARDWARE_WEB_RECONCILIATION_REQUIRED", "retain the original provider evidence; provider migration cannot reissue its invocation");
   validateHardwareWebIntegrity({ original: input, source, saved: storedExisting, readBlob, allowPartial: true, code: "HARDWARE_WEB_RECONCILIATION_REQUIRED" });

package/skills/abelien-hardware-selection/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: abelien-hardware-selection
-description: 为已澄清的需求分层选择硬件分类，经真实 TOS 召回、固定 Prismer 优先／Volc 降级的来源绑定补选、Agent 语义比较与本地 hardware.select 校验身份、数量和引用。用于硬件选型，不用于需求澄清、独立数据库兼容求解或实物验证。
+description: 为已澄清的需求分层选择硬件分类，经真实 TOS 召回、英文 Volc 搜索加来源直读的来源绑定补选（Prismer 默认关闭）、Agent 语义比较与本地 hardware.select 校验身份、数量和引用。用于硬件选型，不用于需求澄清、独立数据库兼容求解或实物验证。
 license: MIT
 compatibility:
   - claude-code

package/skills/abelien-hardware-selection/domain.json

@@ -1,12 +1,12 @@
 {
   "name": "abelien-hardware-selection",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "本地硬件选型：真实 TOS 召回、Agent 证据判断与受信资源校验；不是数据库兼容性求解器",
   "resources": ["hardware-selection"],
   "requires": ["abelien-harness", "abelien-hardware"],
   "capabilities": {
     "hardware.select": {
-      "description": "回读同需求的真实召回资源，验证 Agent 选择的型号、数量、逐约束引用与兼容评估，保存选型及可选尺寸占用摘要；未知不通过门禁",
+      "description": "回读同需求的真实召回资源，验证 Agent 选择的型号、数量、逐约束引用与兼容评估（电源与接口可由可信电气数据确定性判定，其未知仍阻断；结构／散热／软件只提示并列入 advisories），保存选型、可选尺寸占用摘要与兼容报告",
       "adapter": {
         "type": "module",
         "path": "scripts/select.mjs",

package/skills/abelien-hardware-selection/references/selection-service-contract.md

@@ -6,7 +6,7 @@ load-guide 的各层响应均附 runtimeBoundary 提示当前执行范围；只
 
 ## 请求和来源
 
-请求仅含 requirements、slots、recall_id、selection_proposal。requirements 原样保留 clarify 的 context/reaction/limits；槽位带 slot_id/function/quantity/category_path[3]/hard_constraints 对象。recall_id 必须指向调用 workdir 内真实 hardware-recall，校验器通过受信 readResource 前后读回，比对完整需求/槽位 request_digest。不能提交召回正文替代真实来源。旧召回没有 request_digest 时须重新检索，不得修改原资源。
+请求仅含 requirements、slots、recall_id、selection_proposal。requirements 原样保留 clarify 的 context/reaction/limits；槽位带 slot_id/function/quantity/category_path[3]/hard_constraints 对象，可选 fit_envelope（见下文「结构化尺寸与正式门禁」）。recall_id 必须指向调用 workdir 内真实 hardware-recall，校验器通过受信 readResource 前后读回，比对完整需求/槽位 request_digest。不能提交召回正文替代真实来源。旧召回没有 request_digest 时须重新检索，不得修改原资源。
 
 选型前校验全部需求条目：context 必须带非空 text 和 source=user|system；reaction 与每一项 limits 都必须是含唯一 id、非空 text 和上述 source 的对象，ID 在两组之间也不得重复。每项 limit 的 strength 必须是 hard|preference；null、数值、缺归属或拼错 strength 均明确以 VALIDATION 拒绝，不可在筛选 hard 时静默消失。合法的系统假设／偏好原样保留；未解决证据仍保存在 unknowns 并返回 needs_confirmation。
 
@@ -20,7 +20,7 @@ proposal 包含 status=verified|needs_confirmation、plan_mode=assemble_new|adap
 - quantity 显式给出且等于槽位数量，不默认补 1；每槽位最多一个型号。
 - selection_reason 非空；wiki_evidence 为完整 Wiki 中至少 8 字符的原文引用数组，不是 ID、ETag 或自由改写摘要。
 - constraint_checks 逐项包含 constraint_id、status=verified|unknown|incompatible、reason、evidence:[{component_id,quote}]。ID 覆盖 function、slot:<hard_constraints 的键>、limit:<每项 hard limit.id>。缺关键证据仍 unknown。
-- 多型号须逐 power/interfaces/mechanical/thermal/software 提供 compatibility_checks，包含 dimension/status/reason/evidence；每个维度引用每个所选型号的证据。
+- 多型号须为 power、interfaces 提供 compatibility_checks（dimension/status/reason/evidence，每个所选型号都有原文证据），除非可信电气数据已确定性通过；mechanical、thermal、software 可选填写，只作提示，未填有效引用的列入可选 advisories。见下文“电气兼容与兼容报告”。
 
 constraint_checks 非数组、ID 重复或不属于当前槽位时仍以 VALIDATION 拒绝。error.message 列明 slot_id、expected（当前槽位的 function / slot 键与全局 hard limit ID）、received（完整原顺序，非数组为 null）、unexpected（去重、首次出现顺序）与 duplicate（去重、首次重复顺序），供既有 Web 预检 issues 原样反馈并修正。其他槽位具有某个 hard_constraints 键，不使它成为当前槽位的有效 ID；例如 desk-sensor 的 slot:no-stand 不能用于缺少该键的 weather-display。只缺少某项检查仍走 CONSTRAINT_UNVERIFIED、needs_confirmation，不因诊断改为结构拒绝；Wiki 归属、incompatible 和门禁语义不变。
 
@@ -61,8 +61,35 @@ V2 hardware evidence uses fixed prismer_then_volc ordered primary/fallback recei
 
 limits 可附 envelope；严格形状与来源规则见 [索引尺寸契约](../../abelien-hardware/references/search-index-format.md)。hardware.search 在分类所有索引记录上先筛尺寸再 Top-K，未知和估算保留。hardware.select 读取冻结 recall 并核对 request_digest、正文 SHA-256 后，复用纯判定器重算，忽略模型伪造的尺寸、来源、名称和 dimension_check。incompatible 以 VALIDATION 拒绝所选件，必须选其他存活候选；dimension_check.decision_required=true（用户 hard 上限＋measured/datasheet 尺寸，且轴对齐装法全部失败，仍不足以证明放不下）时加入 DIMENSION_DECISION_REQUIRED 并返回 needs_confirmation，模型引用、确认或机械 verified 不能覆盖。unknown、估算尺寸、system/preference 上限或估算壁厚下的 risk 只随 selected_models.dimension_check 提示，不进入 unknowns，也不单独阻止 verified；尺寸限制仍须经原 constraint_checks 的 Wiki 证据门。
 
-没有 envelope 时旧流程仍可在原 Wiki 证据范围 verified，但 selected_models.dimension_check 始终显式为 unknown（PRODUCT_ENVELOPE_MISSING），不能宣传尺寸检查通过。clear 也只表示单件粗筛；device_tested 仍 false。hardware.finalize 仍只返回 proposed/needs_confirmation 的提案，不创建硬件正式资源。
+槽位可附 `fit_envelope: {envelope, basis: locked|inferred, zone?}`，envelope 与 limits 的 envelope 同一校验，zone 为短标识；字段不合法以 VALIDATION 拒绝。它只对本槽位追加一个容器，原因的 `limit_id` 为 `fit:<slot_id>`，有 zone 时同时带 `zone`。locked 的权限与 user+hard 上限相同（可 incompatible、可 decision_required），inferred 与 system/preference 上限相同（只 risk）。它属于结构输入，不进入 constraint_checks 的 expected ID，由判定器确定性复核；槽位已计入 request_digest，改分区须重新检索。只有 fit_envelope、没有产品 envelope 时也做尺寸检查。
+
+没有 envelope 时旧流程仍可在原 Wiki 证据范围 verified，但 selected_models.dimension_check 始终显式为 unknown（PRODUCT_ENVELOPE_MISSING；槽位有 fit_envelope 时除外），不能宣传尺寸检查通过。clear 也只表示单件粗筛；device_tested 仍 false。hardware.finalize 仍只返回 proposed/needs_confirmation 的提案，不创建硬件正式资源。
 
 每个型号额外携带可信候选 title 派生的 name、dimensions_mm、dimension_basis、dimension_geometry、dimension_source 和 dimension_check；interfaces 只在候选存在时透传。bom_item_id 为 `selection-line-<24hex>`，以 slot_id/component_id 派生的稳定选型行身份，不冒称数据库 BOM 主键，不使用模型提供的 ID。
 
 有 envelope 时输出增加可选 occupancy：advisory=true、method、estimated_volume_mm3、unknown_lines、containers（limit_id/cavity_volume_mm3/ratio）。只统计 selected_models 的实际数量，按 bom_item_id 去重，不再次加入 coverage_ledger 的整机内部覆盖。它是包围体积估算，非装箱证明；unknown 基础的占位尺寸不计入体积，仅保留 unknown_lines；全未知时不输出容器密度。部分未知时体积/比例只含已知或显式估算行，不代表整体密度。浮点溢出/下溢等不可表示的几何量保持 unknown，无法表示的体积或比例省略，不序列化 NaN/Infinity；没有隐含硬阈值。工具函数只在调用方显式提供 occupancy_warning_ratio 策略时给 warning，默认没有告警阈值。接入方须接受这一可选加法，但不得将 occupancy 或 ratio 作为通过/拒绝权威。
+
+## 电气兼容与兼容报告
+
+多型号选型由 `electrical.mjs` 按星形拓扑做确定性电气检查：选中的唯一主控（`compute-control/controller-board|controller-module`）为中心，`power-energy` 件给主控供电，主控电压轨与已选电源给外设供电，外设所需总线由主控提供。没有主控或主控不止一个时拓扑记为 not_star，全部未知。
+
+只有 `electrical.basis` 为 measured / datasheet、且通过 `electrical_source` 源绑定的记录能给出确定结论。数据没记录不等于不需要或没有：缺失一律记 unknown，unknown 永不升级为 pass；星形假设本身不是证明，因此 v1 不产生 fail，不以电气检查硬拒绝（VALIDATION）。
+
+| 结果 | 含义 | 门禁 |
+| --- | --- | --- |
+| pass | 全部相关件可信，且每条规则都有完整数据并通过：电压在输入范围内、电流有记录且不超额、逻辑电平有记录且一致（或由可信电平转换件化解）、总线足够 | power / interfaces 视为已验证，不再要求逐件原文引用 |
+| gap | 可信数据下没有电压轨落在外设或主控的输入范围内（`NO_SUPPLY_RAIL_FOR_INPUT`） | 记 `ELECTRICAL_SUPPLY_GAP`，返回 needs_confirmation；须补电源或稳压件，不拒绝外设 |
+| risk | 电压只部分重叠（`RAIL_PARTIALLY_OUTSIDE_INPUT`）、连接器不同（`CONNECTOR_MISMATCH`）、电压轨超载（`RAIL_CURRENT_EXCEEDED`）、逻辑电平不同且未选电平转换件（`LOGIC_LEVEL_MISMATCH`）、同一 SPI 上外设多于主控 SPI 数（`SPI_CHIP_SELECT_UNVERIFIED`）、主控缺该总线类型或数量不足（`BUS_TYPE_MISSING` / `BUS_COUNT_SHORT`） | 不确定性判定，回到原文引用路径；总线类型缺失或数量不足另记 `ELECTRICAL_BUS_UNCONFIRMED` 并返回 needs_confirmation，引用也不能覆盖 |
+| unknown | 数据缺失、未源绑定或非星形：`UNTRUSTED_OR_MISSING_DATA`、`UNTRUSTED_SOURCE_MAY_SUPPLY`、`NO_DECLARED_INPUT`（可信件 power_inputs 为空）、`CURRENT_UNRECORDED`（电压轨或任一受电方缺 max_current_a）、`CONTROLLER_SUPPLY_OUTSIDE_SELECTION`（未选电源件，主控供电在选型之外）、`LOGIC_LEVEL_UNRECORDED`（任一侧缺 logic_level_v）、`LEVEL_SHIFTER_UNTRUSTED`（电平不符且所选转换件不可信）、`CONTROLLER_BUSES_UNRECORDED`（主控未记录任何 controller 角色总线） | 回到原文引用路径 |
+
+电流按以下保守、可解释的方式检查（v1 没有显式的供电分配）：输入的 `max_current_a` 指该输入端的最大取用电流（含经本件输出转供的负载），输出的 `max_current_a` 指该电压轨的最大供给电流。每个受电方从电压匹配的可信电压轨中选记录电流最大的一条（无电流记录的排最后，同等时按出现顺序）；一条电压轨的负载是分配到它的全部受电方 `max_current_a × quantity` 之和，数量大于 1 的电源件的同一电压轨只按一份供给计。已记录负载之和超过供给即 `RAIL_CURRENT_EXCEEDED`；该电压轨或其任一受电方缺电流记录即 `CURRENT_UNRECORDED`。这种分配可能把本可另行分摊的负载判为风险，只会多要求确认，不会误判通过。
+
+v1 的已知局限：不检查 I2C 地址冲突；SPI 只按“外设数多于主控 SPI 数”提示片选风险，不核对片选引脚数；电平转换件、扩展板与驱动板自身的供电和下游总线不建模（扩展板后面挂的外设会被算到主控头上，所以总线不足只记风险）。
+
+mechanical、thermal、software 只作提示，不进入 unknowns，也不阻止 verified；结构可行性由尺寸粗筛和 CAD 检查负责。任何维度只要模型明确给出 status=incompatible，都记 `COMPATIBILITY_INCOMPATIBLE` 并阻塞。
+
+多型号时输出增加可选根字段 `compatibility_report`：`method`、`dimensions`（每维 gate=deterministic|evidence|unverified|advisory、model_status、model_verified，power / interfaces 另有 electrical 结论）和 `electrical`（拓扑、主控与逐条检查；供电检查另带 `current`：status=within|exceeded|unrecorded、draw_a、rail_load_a、capacity_a）。它是选型依据的说明，不代表实测或制造可行；接入方须显式接收这一可选字段。所选型号原样携带候选的 `electrical` 与 `electrical_source`，不采用模型自填。
+
+多型号时若有提示，输出再增加可选根字段 `advisories`（没有提示时省略）：每个 gate=advisory 且模型未给出有效 verified 引用的维度一条 `{code:"COMPATIBILITY_ADVISORY_UNVERIFIED", dimension, model_status}`；power / interfaces 电气结论为 risk、却凭模型引用以 gate=evidence 通过时一条 `{code:"ELECTRICAL_RISK_OVERRIDDEN_BY_EVIDENCE", dimension, electrical:"risk"}`。advisories 只供展示与复核，不影响 status，也不进入 unknowns；接入方须显式接收这一可选字段。
+
+已保存的选型结果按保存时规则原样只读；旧运行重新执行 hardware.select 时按上述新规则重算，可能由 verified 变为 needs_confirmation，也可能由原先的 VALIDATION 拒绝变为 needs_confirmation。

package/skills/abelien-hardware-selection/scripts/select.mjs

@@ -3,6 +3,7 @@ import { evaluateDimensions, validateRequirementEnvelopes } from "../../abelien-
 import { createHash } from "node:crypto";
 import { mergeHardwareWeb } from "../../abelien-hardware/scripts/web-merge.mjs";
 import { finalizeHardwareSelection } from "../../abelien-hardware/scripts/finalize-selection.mjs";
+import { evaluateElectrical } from "../../abelien-hardware/scripts/electrical.mjs";
 import { canonical, digest, selectionRequestDigest, validateSelectionSlots } from "../../abelien-hardware/scripts/selection-request.mjs";
 const record = value => value && typeof value === "object" && !Array.isArray(value);
 const text = value => typeof value === "string" && value.trim().length > 0;
@@ -57,7 +58,7 @@ export async function selectHardware({ input, readResource, readBlob }) {
     if (!candidate || canonical(candidate.category_path) !== canonical(slot.category_path)
       || !text(candidate.content) || !/^[a-f0-9]{64}$/.test(candidate.wiki?.sha256 ?? "")) invalid("candidate needs complete matching Wiki provenance");
     if (createHash("sha256").update(candidate.content).digest("hex") !== candidate.wiki.sha256) invalid("candidate content does not match frozen Wiki SHA-256");
-    const dimensionCheck = evaluateDimensions(candidate, requirements);
+    const dimensionCheck = evaluateDimensions(candidate, requirements, slot);
     model.dimension_check = dimensionCheck;
     if (dimensionCheck.status === "incompatible") invalid("selected candidate is dimensionally incompatible");
     // Only a user hard limit with trusted sizes asks the user to decide; unknown and other risk stay advisory on dimension_check.
@@ -101,12 +102,36 @@ export async function selectHardware({ input, readResource, readBlob }) {
   if (recall.retrieval_mode !== "category_index" || recall.unknowns?.length) add("RECALL_INCOMPLETE", { details: recall.unknowns ?? [] });
   const compatibility = proposal.compatibility_checks ?? [];
   if (!Array.isArray(compatibility)) invalid("compatibility_checks must be an array");
-  if (models.size > 1) for (const dimension of ["power", "interfaces", "mechanical", "thermal", "software"]) {
-    const checks = compatibility.filter(item => item?.dimension === dimension);
-    if (checks.length !== 1 || checks[0].status !== "verified" || !text(checks[0].reason)
-      || !validQuotes(checks[0].evidence, candidates)
-      || !candidates.every(candidate => checks[0].evidence.some(item => item.component_id === candidate.component_id)))
-      add("COMPATIBILITY_UNVERIFIED", { dimension, assessments: checks });
+  // Power/interfaces: trusted deterministic pass, or quoted model evidence. Mechanical/thermal/software are advisory
+  // (size screening and CAD own mechanical fit): unquoted ones are listed in advisories, not unknowns, so they never block verified.
+  // An explicit model "incompatible" still blocks every dimension.
+  let compatibilityReport;
+  const advisories = [];
+  if (models.size > 1) {
+    const electrical = evaluateElectrical(normalized.selected_models);
+    const gaps = electrical.checks.filter(check => check.status === "gap");
+    if (gaps.length) add("ELECTRICAL_SUPPLY_GAP", { checks: gaps });
+    // Bus shortfalls under the star assumption are not proof (expansion and driver boards are not modelled): confirm, never reject.
+    const buses = electrical.checks.filter(check => check.rule === "bus_availability" && check.status === "risk");
+    if (buses.length) add("ELECTRICAL_BUS_UNCONFIRMED", { checks: buses });
+    const dimensions = {};
+    for (const dimension of ["power", "interfaces", "mechanical", "thermal", "software"]) {
+      const checks = compatibility.filter(item => item?.dimension === dimension);
+      const modelVerified = checks.length === 1 && checks[0].status === "verified" && text(checks[0].reason)
+        && validQuotes(checks[0].evidence, candidates)
+        && candidates.every(candidate => checks[0].evidence.some(item => item.component_id === candidate.component_id));
+      const deterministic = electrical.dimensions[dimension];
+      const gate = ["mechanical", "thermal", "software"].includes(dimension) ? "advisory"
+        : deterministic === "pass" ? "deterministic" : modelVerified ? "evidence" : "unverified";
+      const modelStatus = checks.length === 1 ? String(checks[0].status) : checks.length ? "ambiguous" : "missing";
+      if (gate === "unverified") add("COMPATIBILITY_UNVERIFIED", { dimension, assessments: checks, electrical: deterministic });
+      if (checks.some(item => item?.status === "incompatible")) add("COMPATIBILITY_INCOMPATIBLE", { dimension, assessments: checks });
+      if (gate === "advisory" && !modelVerified) advisories.push({ code: "COMPATIBILITY_ADVISORY_UNVERIFIED", dimension, model_status: modelStatus });
+      if (gate === "evidence" && deterministic === "risk") advisories.push({ code: "ELECTRICAL_RISK_OVERRIDDEN_BY_EVIDENCE", dimension, electrical: "risk" });
+      dimensions[dimension] = { gate, model_status: modelStatus,
+        model_verified: modelVerified, ...(deterministic !== undefined ? { electrical: deterministic } : {}) };
+    }
+    compatibilityReport = { method: "compatibility-gate-v1", dimensions, electrical };
   }
   const coverage = slots.map(slot => ({ slot_id: slot.slot_id, requested_quantity: slot.quantity,
     selected_quantity: models.get(slot.slot_id)?.quantity ?? 0,
@@ -123,6 +148,8 @@ export async function selectHardware({ input, readResource, readBlob }) {
   await checkMergedSource();
   const hash = digest({ input, source_digest: digest(source.body) });
   return { ...normalized, id: `selection-${hash.slice(0, 16)}`, revision: `r-${hash.slice(0, 12)}`,
-    status, coverage_ledger: coverage, remaining_slots: remaining, unknowns };
+    status, coverage_ledger: coverage, remaining_slots: remaining, unknowns,
+    ...(compatibilityReport ? { compatibility_report: compatibilityReport } : {}),
+    ...(advisories.length ? { advisories } : {}) };
 }
 export const run = selectHardware;