abelien-harness 0.4.0 → 0.5.0

package/.env.example

@@ -31,6 +31,9 @@ ABELIEN_HARDWARE_REVISE_URL=
 ABELIEN_HARDWARE_SELECT_TOKEN=
 
 # Fixed prismer_then_volc policy; both Keys are trusted host-only.
+# Prismer query, URL-load and Parse are temporarily off (P2-05.02): enabled|disabled, default disabled.
+# When disabled, Volc searches directly and sources are read over public HTTPS (PDF/image unavailable).
+ABELIEN_HARDWARE_WEB_PRISMER=disabled
 # Volc subscription/pay-as-you-go search Keys are distinct from Ark generation Keys.
 PRISMER_API_KEY=
 WEB_SEARCH_API_KEY=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abelien-harness",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "npx-installable multi-agent skill harness: generic kernel + pluggable domain packs",
   "type": "module",
   "engines": {

package/skills/abelien-hardware/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: abelien-hardware
-description: 处理 Abelien 硬件分类、TOS Wiki 实时检索、固定 Prismer 优先／Volc 降级的来源绑定补选、整机复用、型号语义选型和已有方案局部修订。用于需求已澄清后的硬件阶段，不用于需求澄清或外观3D生成。
+description: 处理 Abelien 硬件分类、TOS Wiki 实时检索、英文 Volc 搜索加来源直读的来源绑定补选（Prismer 默认关闭）、整机复用、型号语义选型和已有方案局部修订。用于需求已澄清后的硬件阶段，不用于需求澄清或外观3D生成。
 license: MIT
 compatibility:
   - claude-code
@@ -48,7 +48,7 @@ TOS 读取所需变量是 `TOS_REGION`、`TOS_ENDPOINT`、`TOS_BUCKET`、`TOS_AC
 
 ## Online supplemental candidates
 
-Read [web evidence contract](references/web-evidence-contract.md). Library recall is followed by suitability review. Every zero-candidate or all-unsuitable slot uses `hardware.web-search` to persist fixed Prismer-first/Volc fallback results and independently read source documents, then `hardware.web-merge` consumes that evidence. Keep all user requirements and quantities; catalog absence does not justify dropping rechargeable batteries or wireless charging. Suitable library slots do zero network I/O and are omitted from unresolved_slots; never use empty query/count0 placeholders. All suitable returns []. The trusted host runs the shared [pure search-plan preflight](references/web-evidence-contract.md#trusted-host-search-plan-preflight) before committing the review, so invalid plans remain correctable at the same pause. Extract each physical part separately; missing dimensions, authority and engineering remain unknown, `envelope_only` never means true component CAD. The same formal `hardware.select` consumes `merge-hardware-web.resource.id`; external choices cannot become verified/adopted/delivered. System reuse is optional when it is a good match; concept visuals can be shown first.
+Read [web evidence contract](references/web-evidence-contract.md). Library recall is followed by suitability review. Every zero-candidate or all-unsuitable slot uses `hardware.web-search` to persist English Volc search results (Count ≤ 5) and independently read source documents (Prismer query and reads are off by default, so sources are read directly), then `hardware.web-merge` consumes that evidence. Keep all user requirements and quantities; catalog absence does not justify dropping rechargeable batteries or wireless charging. Suitable library slots do zero network I/O and are omitted from unresolved_slots; never use empty query/count0 placeholders. All suitable returns []. The trusted host runs the shared [pure search-plan preflight](references/web-evidence-contract.md#trusted-host-search-plan-preflight) before committing the review, so invalid plans remain correctable at the same pause. Extract each physical part separately; missing dimensions, authority and engineering remain unknown, `envelope_only` never means true component CAD. The same formal `hardware.select` consumes `merge-hardware-web.resource.id`; external choices cannot become verified/adopted/delivered. System reuse is optional when it is a good match; concept visuals can be shown first.
 
 The trusted host alone supplies PRISMER_API_KEY/WEB_SEARCH_API_KEY. Only a stored definitive primary denial, successful empty query or unsent missing Key permits the fixed fallback; sent unknown/ambiguous or storage failures block it. Safe direct HTML/plaintext follows each original source denial; PDF/image without Parse remains unavailable. Do not choose providers/endpoints or change an unknown invocation. Full schema and original runId-only recovery are in the web evidence contract.
 
@@ -58,3 +58,8 @@ An ordinary failure of an authorized public read is recorded as an unavailable s
 ## 结构化尺寸粗筛
 
 数据库尺寸快照是尺寸编辑源；生成与迁移见 [search-index-format](references/search-index-format.md)。搜索先对全部分类索引做保守筛选再取 Top-K，unknown/estimate 保留。使用候选的 dimension_check 和来源，不从正文猜 dimensions，不把 clear、占用比例、用户确认或 CAD 可用性当作工程验证；all_indexed_candidates_rejected 只指已评估分类。risk 候选排在可装/未知候选之后且不占 Top-K 名额：有满足功能与硬约束的非 risk 候选时选它；只有都不满足才选 risk 件，并在 selection_reason 写明可能放不下的原因。正式选择会重算尺寸，incompatible 必须换候选；只有 decision_required（用户硬尺寸上限＋实测/datasheet 尺寸，且没有轴对齐装法）返回待确认，交用户在换件与放宽尺寸间取舍；unknown 与其他 risk 只随 dimension_check 提示，不阻塞。
+
+## 电气兼容
+
+多型号选型的电源与接口由确定性检查先判（星形拓扑，主控为中心），规则见 [selection-service-contract](../abelien-hardware-selection/references/selection-service-contract.md#电气兼容与兼容报告)。可信数据证明总线缺失或数量不足时必须替换一侧；`ELECTRICAL_SUPPLY_GAP` 表示要补电源或稳压件；结构、散热、软件只作提示。不要从正文猜电压或接口，电气数据只来自候选的 `electrical` 字段。
+

package/skills/abelien-hardware/domain.json

@@ -1,7 +1,7 @@
 {
   "name": "abelien-hardware",
-  "version": "1.2.0",
-  "description": "Hardware library recall, fixed Prismer-first/Volc fallback evidence and envelope candidates; formal selection remains hardware.select",
+  "version": "1.3.0",
+  "description": "Hardware library recall, English Volc query and source evidence (Prismer off by default) with envelope candidates; formal selection remains hardware.select",
   "resources": [
     "hardware-recall",
     "hardware-proposal",
@@ -155,7 +155,7 @@
       "produces": "hardware-selection"
     },
     "hardware.web-search": {
-      "description": "Fixed Prismer-first/Volc fallback, safe source evidence and original-task recovery",
+      "description": "English Volc query and direct source reads (Prismer switchable, off by default), safe source evidence and original-task recovery",
       "adapter": {
         "type": "module",
         "path": "scripts/web-search.mjs",

package/skills/abelien-hardware/references/search-index-format.md

@@ -68,3 +68,13 @@ source 与 output 须是互不嵌套的目录。每个 Wiki record_id 必须命
 
 
 新域包 hardware 1.2.0 / selection 0.5.0 / workspace 1.3.0 使用此加法契约。已有持久结果只读原样；旧 workflow JSON 摘要不固定模块代码，因此不可用旧定义配新包宣称旧行为仍相同。宿主必须固定完整发布包，为尺寸筛选开新运行，不能原地改写旧 CAD 输入或已失败/未知副作用。
+
+## 电气字段（消费方契约）
+
+生成 Wiki 头部可带两行严格内联 JSON：
+
+- `electrical`：`{schema:"abelien.component-electrical.v1", basis, power_inputs, power_outputs, buses}`。`basis` 为 measured / datasheet / estimate / unknown；供电项为 `{id, voltage_v:[min,max], connector?, max_current_a?}`，id 与连接器为小写短横线标识，电压为有序正数；总线项为 `{type, role, count, logic_level_v?}`，type 取 i2c / spi / uart / usb / i2s / can / pwm / gpio / adc，role 为 controller 或 peripheral。不接受多余字段。
+- `electrical_source`：`{component_id, revision, snapshot_id, evidence_ref?}`，`revision` 是 `{component_id, ...electrical}` 规范 JSON 的 SHA-256。
+
+只有两行都在、源绑定一致的记录才进入候选；只有 `electrical` 没有来源时按未知处理，摘要不符则拒绝。组件数据库是电气数据唯一编辑源，生产方（P2-04.03）沿尺寸快照同一条只读导出与构建管道写入，禁止在 Wiki 上手改。占位、默认或无出处的数据只能标 estimate 或 unknown。
+

package/skills/abelien-hardware/references/search-index-release.md

@@ -62,7 +62,9 @@ npm run smoke:hardware-search -- \
 
 ## 激活与失败语义
 
-构建器以源 Manifest SHA-256 作为 `release_id`，分片写入 `indexes/releases/<release_id>/...`。发布器先验证远端 Manifest，再以不可变语义上传并回读全部分片；只有全部 SHA、Schema、分类和记录数通过后，才用条件 PUT 替换 `_catalog.json`。并发发布导致 Catalog ETag 变化时显式失败，不覆盖别人的新版本。
+构建器以源 Manifest SHA-256 作为 `release_id`，分片写入 `indexes/releases/<release_id>/...`。发布器先验证远端 Manifest，再以不可变语义上传并回读全部分片；只有全部 SHA、Schema、分类和记录数通过后，才替换 `_catalog.json`。
+
+存储是阿里云 OSS（S3 兼容签名），这条路径**没有条件 PUT**：`If-None-Match`／`If-Match` 返回 400 NotImplemented，`x-oss-forbid-overwrite` 被忽略、照常覆盖。所以不可变对象靠先读后写：不存在才上传，已存在则比对 SHA，字节不同以 `IMMUTABLE_OBJECT_CONFLICT` 失败，上传后一律回读校验。激活前重读 `_catalog.json`，按内容 SHA-256 与发布开始时读到的版本比对（OSS 对 JSON 对象不回 ETag），变了就以 `CATALOG_ACTIVATION_RACE` 失败，不覆盖别人的新版本。重读到写入之间仍有很短的窗口，写后校验会比对 `release_id`，输掉竞争的一方因此失败，不会误报成功；同一时刻只应有一人发布。结果的 `previous_catalog` 记录被替换的 catalog（sha256、release_id），作为回滚点。
 
 Catalog 激活失败只会留下未引用的不可变分片，不影响旧版本；搜索端始终从唯一 `_catalog.json` 读取一个完整 release。发布命令默认最后执行真实 `hardware.search`，确保 Catalog、分类索引和至少一篇 Wiki 正文能够按生产读取路径访问。`--skip-smoke` 只用于已有独立冒烟门禁的受控 CI，不能把单元测试当成生产连通性证明。
 
@@ -71,6 +73,6 @@ Catalog 激活失败只会留下未引用的不可变分片，不影响旧版本
 
 数据库导出由 Web 仓库显式只读命令产生；Harness 不接收数据库凭据。尺寸发布使用同一命令的 `--component-snapshot /absolute/path/to/component-dimensions.json`，先运行 `--dry-run --output /absolute/path/to/review` 检查生成 Wiki、Manifest、导出和索引。确定发布环境后去掉 dry-run，才会执行远端写入。
 
-这条路径按 content-addressed key 上传生成 Wiki，再上传不可变导出和 Manifest、索引分片，最后条件激活 `_catalog.json`；每个对象冲突即失败，不覆盖旧 Wiki、旧清单或旧快照。生成路径从 built.generated_source 读取，不能把原始 source 目录的 Wiki 当成新的正文。无需 bootstrap-manifest，catalog 使用该 release 自己的版本化 Manifest。故障只留下未引用的不可变文件；本地测试的内存 TOS 只证明执行顺序和摘要，不证明线上发布成功。
+这条路径按 content-addressed key 上传生成 Wiki，再上传不可变导出和 Manifest、索引分片，最后按上节语义激活 `_catalog.json`；每个对象冲突即失败，不覆盖旧 Wiki、旧清单或旧快照。生成路径从 built.generated_source 读取，不能把原始 source 目录的 Wiki 当成新的正文。无需 bootstrap-manifest，catalog 使用该 release 自己的版本化 Manifest。故障只留下未引用的不可变文件；本地测试的内存 TOS 只证明执行顺序和摘要，不证明线上发布成功。
 
 v1 迁移：所有索引记录必须具备 Wiki 内容 SHA-256。旧无 hash 索引重建再发布；旧无尺寸/geometry 记录保持 unknown。dimensions 更新会改变源 revision、snapshot_id、生成 Wiki 内容 hash、Manifest 身份与分片摘要；旧固定产物保持原字节，不原地“补齐”过去的候选。

package/skills/abelien-hardware/references/web-evidence-contract.md

@@ -2,9 +2,9 @@
 
 Read the [architecture](../../../docs/architecture/hardware-online-fallback.md) and [official API inventory](../../../docs/architecture/prismer-api-inventory.md). The trusted current-workdir reader/checkpoint owns all source bodies. A model cannot submit URL/key/provider/command/source content or default envelopes.
 
-hardware.web-search input is exactly {requirements,slots,recall_id,unresolved_slots}. Each unresolved item is {slot_id,reason,query,count?}; every zero-candidate slot must occur and all-unsuitable candidates need a reason. Query is nonempty; Count is a positive integer/default10 without undocumented fixed upper limits. Full selectionRequestDigest preserves original requirements, quantities and constraints. unresolved_slots lists only slots needing search: omit suitable slots entirely, never submit empty query/count0 placeholders; all suitable means []. Empty unresolved list with suitable candidates uses zero network/credentials. The shared validateHardwareWebPlan({input,readResource}) in scripts/web-search-plan.mjs returns {source} after the same original-recall and query/count checks used before search configuration, checkpoints or provider calls. It does not filter or default invalid entries.
+hardware.web-search input is exactly {requirements,slots,recall_id,unresolved_slots}. Each unresolved item is {slot_id,reason,query,count?}; every zero-candidate slot must occur and all-unsuitable candidates need a reason. Query is nonempty; Count is a positive integer. New plans (P2-05.02) must write the query in English (no Chinese/Japanese/Korean characters; keep model numbers and manufacturer names) and Count is 1–5, default 5; validateNewHardwareWebPlan rejects violations with VALIDATION. A plan already frozen in saved evidence keeps the rules it was accepted under (validateFrozenHardwareWebPlan). Full selectionRequestDigest preserves original requirements, quantities and constraints. unresolved_slots lists only slots needing search: omit suitable slots entirely, never submit empty query/count0 placeholders; all suitable means []. Empty unresolved list with suitable candidates uses zero network/credentials. The shared validateHardwareWebPlan({input,readResource}) in scripts/web-search-plan.mjs returns {source} after the original-recall, query/count and new-plan checks used by the preflight helper; search applies the new-plan checks only when the plan is not the one frozen in existing evidence, before configuration, checkpoints or provider calls. It does not filter or default invalid entries.
 
-The trusted fixed policy is prismer_then_volc. Fixed Prismer query POST /api/context/load sends inputType=query, search.topK and explicit return.topK/format=both. URL-load sends inputType=url/format=both; only result.raw supplies source text. cached/cachedAt/meta and complete raw/response/summary/cost/time are retained. HQCC-only is unavailable. PDF/image suffixes from original query URLs use actual Parse {url,mode:fast,output:markdown,wait:true}. Synchronous requestId is nullable; async taskId is persisted before fixed status/result GET. Callback/endpoints are ignored. Source text is API raw/parsed markdown, not original HTTP bytes or a verified realtime/final URL.
+The trusted fixed policy is prismer_then_volc. Prismer is temporarily off (P2-05.02): unless the trusted host sets ABELIEN_HARDWARE_WEB_PRISMER=enabled (default disabled; any other value is HARDWARE_WEB_CONFIG), every prismer attempt (query, context_url, parse) is saved unsent as status=unavailable, reason=prismer_disabled with no receipt, and that marker authorizes the same group's volcengine/query or direct_https/direct_page attempt; PDF/image sources then stay unavailable (parse_unavailable). Volc requests use Count = plan count or 5; Volc receipts saved by 0.4.0 keep their frozen default Count 10 request. When enabled, the fixed Prismer query POST /api/context/load sends inputType=query, search.topK and explicit return.topK/format=both. URL-load sends inputType=url/format=both; only result.raw supplies source text. cached/cachedAt/meta and complete raw/response/summary/cost/time are retained. HQCC-only is unavailable. PDF/image suffixes from original query URLs use actual Parse {url,mode:fast,output:markdown,wait:true}. Synchronous requestId is nullable; async taskId is persisted before fixed status/result GET. Callback/endpoints are ignored. Source text is API raw/parsed markdown, not original HTTP bytes or a verified realtime/final URL.
 
 New hardware-web-evidence has provider=prismer, protocol=prismer-volc-source-v2, schema_version=2, provider_policy=prismer_then_volc; original recall_id/recall_digest/request_digest/requirements/slots; plan_digest/unresolved_slots/query_plans; all searches; all pages; unknowns. Its stable ID depends only on original recall_id/request_digest. Every paid attempt has stable id/status/request/raw/raw_sha256/canonical response_sha256/received_at/http_status/request_id/response. Ordered searches[].attempts use prismer/query then the optional volcengine/query; pages[].attempts use prismer/context_url|parse then optional direct_https/direct_page. Each group retains selected_attempt_id/selected_provider and the exact selected receipt alias. Page primary attempt.kind is context_url or parse; pending Parse includes task_id and observations of each fixed GET. Page has source_url/returned_url (nullable), text/text_sha256/content_sha256/retrieval/cached/cachedAt/meta/loaded_at. Prismer source_bytes_verified/remote_redirects_verified remain false. Direct receipts retain actual wire and safe persisted raw/text digests, final_url/fetched_at, DNS/redirect/IP/TLS trace; redaction modifies only the safe copy and raw_redacted=true makes source_bytes_verified=false. PDF/image denial remains unavailable without a direct Parse substitute.
 

package/skills/abelien-hardware/scripts/electrical.mjs

@@ -0,0 +1,125 @@
+// Deterministic electrical compatibility for a selected set of parts (star topology, v1).
+// Only measured/datasheet records can prove pass, fail or a supply gap; anything else stays unknown. This is not a circuit simulation.
+import { digest } from './selection-request.mjs';
+const object = v => v !== null && typeof v === 'object' && !Array.isArray(v);
+const positive = v => typeof v === 'number' && Number.isFinite(v) && v > 0;
+const text = v => typeof v === 'string' && v.trim().length > 0;
+const hash = v => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+const slug = v => typeof v === 'string' && /^[a-z0-9][a-z0-9-]{0,47}$/.test(v);
+const invalid = message => { throw Object.assign(new Error(message), { code: 'VALIDATION' }); };
+function keys(value, required, optional, label) {
+  if (!object(value) || required.some(key => !Object.hasOwn(value, key)) || Object.keys(value).some(key => ![...required, ...optional].includes(key))) invalid(`${label} has missing or unsupported fields`);
+}
+export const ELECTRICAL_SCHEMA = 'abelien.component-electrical.v1';
+export const BUS_TYPES = ['i2c', 'spi', 'uart', 'usb', 'i2s', 'can', 'pwm', 'gpio', 'adc'];
+// Multi-drop buses only need to exist on the controller; the others are point-to-point and their counts add up.
+const SHARED_BUSES = ['i2c', 'spi', 'can'];
+const TRUSTED = ['measured', 'datasheet'];
+const BASES = ['measured', 'datasheet', 'estimate', 'unknown'];
+const range = v => Array.isArray(v) && v.length === 2 && v.every(positive) && v[0] <= v[1];
+
+function validatePower(rows, label) {
+  if (!Array.isArray(rows)) invalid(`${label} must be an array`);
+  const ids = new Set();
+  for (const row of rows) {
+    keys(row, ['id', 'voltage_v'], ['connector', 'max_current_a'], label);
+    if (!slug(row.id) || ids.has(row.id) || !range(row.voltage_v) || (row.connector !== undefined && !slug(row.connector))
+      || (row.max_current_a !== undefined && !positive(row.max_current_a))) invalid(`${label} entries need unique ids, ordered positive voltage ranges and slug connectors`);
+    ids.add(row.id);
+  }
+}
+// Strict consumer-side contract; the producer is the component database export (P2-04.03).
+export function validateElectricalRecord(value) {
+  keys(value, ['schema', 'basis', 'power_inputs', 'power_outputs', 'buses'], [], 'electrical record');
+  if (value.schema !== ELECTRICAL_SCHEMA || !BASES.includes(value.basis)) invalid('unsupported electrical record schema or basis');
+  validatePower(value.power_inputs, 'electrical power_inputs');
+  validatePower(value.power_outputs, 'electrical power_outputs');
+  if (!Array.isArray(value.buses)) invalid('electrical buses must be an array');
+  for (const bus of value.buses) {
+    keys(bus, ['type', 'role', 'count'], ['logic_level_v'], 'electrical bus');
+    if (!BUS_TYPES.includes(bus.type) || !['controller', 'peripheral'].includes(bus.role) || !Number.isSafeInteger(bus.count) || bus.count < 1
+      || (bus.logic_level_v !== undefined && !positive(bus.logic_level_v))) invalid('electrical bus needs a known type, role, positive count and positive logic level');
+  }
+  return value;
+}
+// Source-bound records only; an unbound or legacy record is reported as unknown, never trusted.
+export function electricalFields(value) {
+  const record = value?.electrical, source = value?.electrical_source, id = value?.component_id ?? value?.record_id;
+  if (record === undefined && source === undefined) return {};
+  if (!object(source) || source.component_id !== id || !hash(source.revision) || !hash(source.snapshot_id)
+    || Object.keys(source).some(key => !['component_id', 'revision', 'snapshot_id', 'evidence_ref'].includes(key))
+    || (source.evidence_ref !== undefined && !text(source.evidence_ref))) return { electrical: null, electrical_source: null };
+  validateElectricalRecord(record);
+  if (source.revision !== digest({ component_id: id, ...record })) invalid('electrical source revision does not match candidate fields');
+  return { electrical: record, electrical_source: { ...source } };
+}
+const overlaps = (a, b) => a[0] <= b[1] && b[0] <= a[1];
+const within = (inner, outer) => inner[0] >= outer[0] && inner[1] <= outer[1];
+const isController = part => part.category_path?.[0] === 'compute-control' && ['controller-board', 'controller-module'].includes(part.category_path?.[1]);
+const isPower = part => part.category_path?.[0] === 'power-energy';
+const isLevelShifter = part => part.category_path?.[0] === 'electrical-interconnect' && part.category_path?.[1] === 'level-shifting';
+const trusted = part => TRUSTED.includes(part.electrical?.basis);
+const ref = part => ({ slot_id: part.slot_id, component_id: part.component_id });
+
+// Supply match against trusted rails only. A missing rail is a supply gap (add a power part), never a reason to reject the consumer.
+function supply(consumer, sources, rule, dimension) {
+  const parts = [consumer, ...sources].map(ref), inputs = consumer.electrical?.power_inputs ?? [];
+  if (!trusted(consumer) || !inputs.length) return { rule, dimension, status: 'unknown', parts, reason: trusted(consumer) ? 'NO_DECLARED_INPUT' : 'UNTRUSTED_OR_MISSING_DATA' };
+  const rails = sources.filter(trusted).flatMap(source => (source.electrical.power_outputs ?? []).map(output => ({ source, output })));
+  const fit = rails.find(({ output }) => inputs.some(input => within(output.voltage_v, input.voltage_v)));
+  if (fit) {
+    const input = inputs.find(row => within(fit.output.voltage_v, row.voltage_v));
+    const connectorRisk = Boolean(input.connector && fit.output.connector && input.connector !== fit.output.connector);
+    return { rule, dimension, status: connectorRisk ? 'risk' : 'pass', parts, reason: connectorRisk ? 'CONNECTOR_MISMATCH' : 'RAIL_WITHIN_INPUT',
+      rail: { component_id: fit.source.component_id, id: fit.output.id, voltage_v: fit.output.voltage_v, connector: fit.output.connector ?? null },
+      input: { id: input.id, voltage_v: input.voltage_v, connector: input.connector ?? null } };
+  }
+  if (sources.some(source => !trusted(source))) return { rule, dimension, status: 'unknown', parts, reason: 'UNTRUSTED_SOURCE_MAY_SUPPLY' };
+  const partial = rails.some(({ output }) => inputs.some(input => overlaps(output.voltage_v, input.voltage_v)));
+  return { rule, dimension, status: partial ? 'risk' : 'gap', parts, reason: partial ? 'RAIL_PARTIALLY_OUTSIDE_INPUT' : 'NO_SUPPLY_RAIL_FOR_INPUT' };
+}
+// fail (incompatible part) > gap (missing part) > pass (all checks pass on trusted data) > risk > unknown.
+const aggregate = (checks, dimension, members) => {
+  const rows = checks.filter(check => check.dimension === dimension);
+  for (const status of ['fail', 'gap']) if (rows.some(check => check.status === status)) return status;
+  if (rows.length && rows.every(check => check.status === 'pass') && members.every(trusted)) return 'pass';
+  return rows.some(check => check.status === 'risk') ? 'risk' : 'unknown';
+};
+// parts: [{slot_id, component_id, category_path, quantity, electrical}] for the whole selection.
+export function evaluateElectrical(parts) {
+  const method = 'electrical-star-v1', controllers = parts.filter(isController);
+  if (controllers.length !== 1) return { method, topology: 'not_star', dimensions: { power: 'unknown', interfaces: 'unknown' }, checks: [],
+    reasons: [{ code: controllers.length ? 'MULTIPLE_CONTROLLERS' : 'NO_CONTROLLER', controllers: controllers.map(ref) }] };
+  const [controller] = controllers, sources = parts.filter(isPower), shifter = parts.some(isLevelShifter);
+  const peripherals = parts.filter(part => part !== controller && !isPower(part) && !isLevelShifter(part));
+  const checks = [];
+  // Rule 1: a selected supply must power the controller. Without one the controller is powered from outside the selection.
+  if (sources.length) checks.push(supply(controller, sources, 'controller_supply', 'power'));
+  // Rule 2: each peripheral needs a controller rail or a selected supply rail inside one of its input ranges.
+  for (const part of peripherals) if (part.electrical?.power_inputs?.length || !trusted(part)) checks.push(supply(part, [controller, ...sources], 'peripheral_supply', 'power'));
+  // Rule 3: bus types the peripherals need must exist on the controller; point-to-point counts must also fit.
+  const need = new Map();
+  for (const part of peripherals) for (const bus of part.electrical?.buses ?? []) if (bus.role === 'peripheral')
+    need.set(bus.type, [...(need.get(bus.type) ?? []), { part, bus, count: bus.count * (part.quantity ?? 1) }]);
+  for (const part of peripherals) if (!trusted(part)) checks.push({ rule: 'bus_availability', dimension: 'interfaces', status: 'unknown', parts: [ref(part), ref(controller)], reason: 'UNTRUSTED_OR_MISSING_DATA' });
+  for (const [type, rows] of need) {
+    const parts2 = [ref(controller), ...rows.map(row => ref(row.part))];
+    if (!trusted(controller) || rows.some(row => !trusted(row.part))) { checks.push({ rule: 'bus_availability', dimension: 'interfaces', status: 'unknown', bus: type, parts: parts2, reason: 'UNTRUSTED_OR_MISSING_DATA' }); continue; }
+    const offered = (controller.electrical.buses ?? []).filter(bus => bus.type === type && bus.role === 'controller');
+    const available = offered.reduce((sum, bus) => sum + bus.count, 0);
+    const required = SHARED_BUSES.includes(type) ? 1 : rows.reduce((sum, row) => sum + row.count, 0);
+    checks.push({ rule: 'bus_availability', dimension: 'interfaces', bus: type, parts: parts2, required, available,
+      status: available >= required ? 'pass' : 'fail', reason: !available ? 'BUS_TYPE_MISSING' : available < required ? 'BUS_COUNT_SHORT' : 'BUS_AVAILABLE' });
+    // Rule 4: a logic-level mismatch is only a risk in v1; cables and level shifters can bridge it.
+    for (const row of rows) {
+      const level = offered.find(bus => bus.logic_level_v !== undefined)?.logic_level_v;
+      if (level === undefined || row.bus.logic_level_v === undefined) continue;
+      const mismatch = Math.abs(level - row.bus.logic_level_v) > 1e-9;
+      checks.push({ rule: 'logic_level', dimension: 'interfaces', bus: type, parts: [ref(controller), ref(row.part)], controller_v: level, peripheral_v: row.bus.logic_level_v,
+        status: mismatch && !shifter ? 'risk' : 'pass', reason: !mismatch ? 'LOGIC_LEVEL_MATCH' : shifter ? 'LEVEL_SHIFTER_SELECTED' : 'LOGIC_LEVEL_MISMATCH' });
+    }
+  }
+  const powerMembers = [controller, ...sources, ...peripherals.filter(part => checks.some(check => check.dimension === 'power' && check.parts.some(row => row.component_id === part.component_id)))];
+  return { method, topology: 'star', controller: ref(controller), checks,
+    dimensions: { power: aggregate(checks, 'power', powerMembers), interfaces: aggregate(checks, 'interfaces', [controller, ...peripherals]) } };
+}

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

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import { assemblyOccupancy, dimensionFields, evaluateDimensions } from "./dimensions.mjs";
+import { electricalFields, evaluateElectrical } from "./electrical.mjs";
 import { selectionRequestDigest } from "./selection-request.mjs";
 
 function error(message, details) {
@@ -80,7 +81,7 @@ export async function finalizeHardwareSelection({ input }) {
       name: String(candidate.title ?? candidate.name ?? candidate.model ?? candidate.component_id),
       // This is a deterministic selection-line identity, NOT an upstream catalog BOM identity.
       bom_item_id: `selection-line-${digest({ slot_id: selected.slot_id, component_id: candidate.component_id }).slice(0, 24)}`,
-      ...dimensionFields(candidate), dimension_check: dimensionCheck,
+      ...dimensionFields(candidate), dimension_check: dimensionCheck, ...electricalFields(candidate),
       ...(candidate.interfaces !== undefined ? { interfaces: candidate.interfaces } : {}),
       slot_id: selected.slot_id, component_id: selected.component_id, quantity: selected.quantity,
       selection_reason: selected.selection_reason, wiki_evidence: selected.wiki_evidence,
@@ -94,6 +95,9 @@ export async function finalizeHardwareSelection({ input }) {
       ...(candidate.source_type === "external_web" ? { source_type: candidate.source_type, source: candidate.source, geometry: candidate.geometry, CAD_available: false, cad_available: false, engineering_verified: false } : {}),
     };
   });
+  // Trusted data proving a part cannot connect means one side must be replaced; a missing supply rail is a gap for select to report.
+  const failed = selectedModels.length > 1 ? evaluateElectrical(selectedModels).checks.filter(check => check.status === "fail") : [];
+  if (failed.length) throw error("selected components are electrically incompatible; replace one side of each failed check", { electrical_checks: failed });
   const stable = {
     requirements: input.requirements ?? {}, slots: input.slots ?? [], source_snapshot: recall.source_snapshot,
     proposal: { ...proposal, selected_models: selectedModels },

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

@@ -2,7 +2,7 @@ import { digest, selectionRequestDigest } from "./selection-request.mjs";
 import { failure, text } from "./web-common.mjs";
 import { sha256, normalizePublicSourceUrl, pageText, publicAddress, publicReadFailureCodes } from "./public-page.mjs";
 import { intactReceipt, successfulReceipt } from "./web-receipt.mjs";
-import { volcQueryRequest } from "./volc-web-search.mjs";
+import { volcQueryRequest, legacyVolcQueryRequest } from "./volc-web-search.mjs";
 import { isIP } from "node:net";
 export const chainProtocol = "prismer-volc-source-v2", chainPolicy = "prismer_then_volc";
 export const receiptFields = ["raw", "raw_sha256", "response", "response_sha256", "request_id", "received_at", "http_status"];
@@ -13,8 +13,11 @@ export const same = (left, right) => digest({ value: left }) === digest({ value:
 export const selectedReceipt = group => group?.attempts?.find(attempt => attempt.id === group.selected_attempt_id) ?? null;
 export const queryResults = attempt => attempt?.provider === "volcengine" ? attempt.response?.Result?.WebResults?.map(result => ({ ...result, url: result?.Url ?? null })) : attempt?.response?.results;
 export const missingKey = attempt => attempt?.status === "unavailable" && attempt.dispatch_state === "not_sent" && attempt.reason === "missing_key" && attempt.error_code === "HARDWARE_WEB_CONFIG" && attempt.raw == null && attempt.response == null && attempt.http_status == null;
+// A Prismer attempt skipped by the trusted host switch is recorded unsent with no receipt;
+// it authorizes the same group's Volc query or direct source read.
+export const prismerDisabled = attempt => attempt?.provider === "prismer" && attempt.status === "unavailable" && attempt.dispatch_state === "not_sent" && attempt.reason === "prismer_disabled" && attempt.error_code == null && attempt.raw == null && attempt.response == null && attempt.http_status == null;
 export const knownDenial = attempt => attempt?.provider === "prismer" && attempt.status === "denied" && attempt.dispatch_state === "sent" && [401, 403, 402, 429].includes(attempt.http_status) && intactReceipt(attempt);
-export const permitsFallback = (attempt, query) => knownDenial(attempt) || missingKey(attempt) || (query && attempt?.status === "completed" && successfulReceipt(attempt) && Array.isArray(queryResults(attempt)) && queryResults(attempt).length === 0);
+export const permitsFallback = (attempt, query) => knownDenial(attempt) || missingKey(attempt) || prismerDisabled(attempt) || (query && attempt?.status === "completed" && successfulReceipt(attempt) && Array.isArray(queryResults(attempt)) && queryResults(attempt).length === 0);
 export function expectedSelection(group, query) {
   const primary = group.attempts?.[0], fallback = group.attempts?.[1];
   if (!primary) return null;
@@ -67,13 +70,14 @@ function validateGroup(group, item, page, partial) {
   const operation = page ? sourceOperation(page.source_url) : null;
   for (const [index, attempt] of attempts.entries()) {
     const provider = index === 0 ? "prismer" : query ? "volcengine" : "direct_https", kind = query ? "query" : index === 0 ? operation.kind : "direct_page";
-    const request = query ? index === 0 ? primaryQuery(item) : volcQueryRequest(item) : index === 0 ? operation.request : { url: page.source_url, method: "GET" };
-    if (attempt.provider !== provider || attempt.kind !== kind || attempt.role !== (index === 0 ? "primary" : "fallback") || attempt.group_id !== group.id || attempt.id !== operationId(group.id, provider, kind, request) || !same(attempt.request, request)) return false;
+    // Volc receipts saved before the Count-5 default keep their frozen Count-10 request shape.
+    const requests = query ? index === 0 ? [primaryQuery(item)] : [volcQueryRequest(item), legacyVolcQueryRequest(item)] : [index === 0 ? operation.request : { url: page.source_url, method: "GET" }];
+    if (attempt.provider !== provider || attempt.kind !== kind || attempt.role !== (index === 0 ? "primary" : "fallback") || attempt.group_id !== group.id || !requests.some(request => attempt.id === operationId(group.id, provider, kind, request) && same(attempt.request, request))) return false;
     if (index === 1 && !permitsFallback(attempts[0], query)) return false;
     if (["in_progress", "unknown", "failed"].includes(attempt.status)) return false;
     if (provider === "direct_https") { if (!validDirect(attempt) || (attempt.dispatch_state === "not_sent" && operation.kind !== "parse") || (attempt.public_read_failure && operation.kind === "parse")) return false; continue; }
     if (Object.hasOwn(attempt, "public_read_failure")) return false;
-    if (missingKey(attempt) || knownDenial(attempt)) continue;
+    if (missingKey(attempt) || knownDenial(attempt) || prismerDisabled(attempt)) continue;
     if (attempt.dispatch_state !== "sent" || !["completed", "pending"].includes(attempt.status) || !successfulReceipt(attempt)) return false;
     if (query && !Array.isArray(queryResults(attempt))) return false;
     if (attempt.status === "pending" && !(kind === "parse" && text(attempt.task_id) && attempt.task_id === attempt.response.taskId)) return false;
@@ -81,7 +85,7 @@ function validateGroup(group, item, page, partial) {
     if (page && (!Array.isArray(attempt.observations) || !attempt.observations.every(value => ["status", "result"].includes(value.kind) && (value.error_code ? ((value.raw === undefined && value.response === undefined) || intactReceipt(value)) : successfulReceipt(value) && value.response.taskId === attempt.task_id)))) return false;
   }
   const expected = expectedSelection(group, query), selected = selectedReceipt(group);
-  if (group.selected_attempt_id == null) return partial && group.status === "in_progress" && (knownDenial(attempts[0]) || missingKey(attempts[0]) || successfulReceipt(attempts[0])) && (!page || page.attempt == null);
+  if (group.selected_attempt_id == null) return partial && group.status === "in_progress" && (knownDenial(attempts[0]) || missingKey(attempts[0]) || prismerDisabled(attempts[0]) || successfulReceipt(attempts[0])) && (!page || page.attempt == null);
   if (!selected || !expected || selected.id !== expected.id) return false;
   return group.selected_provider === selected.provider && (query ? group.status === "completed" && receiptFields.every(key => same(group[key], selected[key])) : same(page.attempt, selected));
 }

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/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 { electricalFields } from "./electrical.mjs";
 import { selectionRequestDigest, validCategoryPath } from "./selection-request.mjs";
 import { createTosConfig, getTosObject, sha256 } from "./tos-object-store.mjs";
 
@@ -82,13 +83,13 @@ 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") {
+      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]);
@@ -270,6 +271,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,

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

@@ -3,7 +3,12 @@ import { sha256 } from "./public-page.mjs";
 import { digest } from "./selection-request.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 } });
+// Plans cap count at 5 (P2-05.02). Evidence saved by <=0.4.0 used the old default of 10;
+// provider-chain-contract still accepts that frozen shape when validating saved receipts.
+export const volcMaxCount = 5;
+const volcBody = (item, count) => ({ Query: item.query, SearchType: "web", Count: count, Filter: { NeedUrl: true, NeedContent: false }, ContentFormats: "markdown", QueryControl: { QueryRewrite: false } });
+export const volcQueryRequest = item => volcBody(item, item.count ?? volcMaxCount);
+export const legacyVolcQueryRequest = item => volcBody(item, item.count ?? 10);
 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");
 }

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

@@ -22,7 +22,10 @@ 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) };
 }

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

@@ -76,8 +76,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 +136,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-search-plan.mjs

@@ -1,8 +1,12 @@
 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 }) {
+// The shape check alone is used for a plan already frozen in saved evidence.
+export async function validateFrozenHardwareWebPlan({ input, readResource }) {
   onlyKeys(input, ["requirements", "slots", "recall_id", "unresolved_slots"], "web search input");
   const source = await boundRecall(input, readResource), recall = source.body;
   if (!Array.isArray(input.unresolved_slots)) invalid("unresolved_slots must be an array");
@@ -16,3 +20,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 } 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,15 @@ 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.
+  if (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