abelien-harness 0.3.0 → 0.5.0

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

@@ -1,4 +1,7 @@
 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) {
   const out = new Error(message);
@@ -23,6 +26,7 @@ export async function finalizeHardwareSelection({ input }) {
   if (!recall || recall.status !== "completed" || !recall.source_snapshot) throw error("completed knowledge_recall is required");
   if (!["proposed", "verified", "needs_confirmation"].includes(proposal.status)) throw error("selection_proposal.status is not recognized");
   if (!["adapt_system", "assemble_new"].includes(proposal.plan_mode)) throw error("selection_proposal.plan_mode is not recognized");
+  if (recall.request_digest && recall.request_digest !== selectionRequestDigest(input)) throw error("recall does not match selection requirements and slots");
   const proposedModels = requireArray(proposal.selected_models, "selected_models");
   const coverageLedger = requireArray(proposal.coverage_ledger, "coverage_ledger");
   const remainingSlots = requireArray(proposal.remaining_slots, "remaining_slots");
@@ -71,7 +75,14 @@ export async function finalizeHardwareSelection({ input }) {
         slot_id: selected.slot_id, component_id: selected.component_id,
       });
     }
+    const dimensionCheck = evaluateDimensions(candidate, input.requirements);
+    if (dimensionCheck.status === "incompatible") throw error("selected component is dimensionally incompatible; choose a surviving candidate", { slot_id: selected.slot_id, component_id: selected.component_id, dimension_check: dimensionCheck });
     return {
+      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, ...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,
       ...(selected.constraint_checks !== undefined ? { constraint_checks: selected.constraint_checks } : {}),
@@ -84,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 },
@@ -97,6 +111,7 @@ export async function finalizeHardwareSelection({ input }) {
     revision: `r-${hash.slice(0, 12)}`,
     plan_mode: proposal.plan_mode,
     selected_models: selectedModels,
+    ...(input.requirements?.limits?.some(row => row?.envelope) ? { occupancy: assemblyOccupancy(selectedModels, input.requirements, input.policy) } : {}),
     coverage_ledger: coverageLedger,
     remaining_slots: remainingSlots,
     unknowns,

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/publish-search-index.mjs

@@ -8,7 +8,7 @@ import { publishHardwareSearchIndex } from "./search-index-release.mjs";
 function parseArgs(argv) {
   const flags = {};
   const booleans = new Set(["--dry-run", "--skip-smoke", "--bootstrap-manifest"]);
-  const valued = new Set(["--source", "--output", "--release-id", "--env-file", "--concurrency"]);
+  const valued = new Set(["--source", "--output", "--release-id", "--env-file", "--concurrency", "--component-snapshot"]);
   for (let i = 0; i < argv.length; i++) {
     const name = argv[i];
     if (booleans.has(name)) flags[name.slice(2)] = true;
@@ -30,6 +30,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
       sourceDir: path.resolve(cwd, flags.source),
       outputDir: flags.output ? path.resolve(cwd, flags.output) : undefined,
       releaseId: flags["release-id"],
+      componentSnapshot: flags["component-snapshot"] ? path.resolve(cwd, flags["component-snapshot"]) : undefined,
       env,
       fetchImpl: deps.fetchImpl || fetch,
       dryRun: Boolean(flags["dry-run"]),

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);
@@ -69,6 +75,7 @@ export function validateLocalRelease(outputDir) {
     if (index.source_manifest_sha256 !== catalog.source_manifest?.sha256) {
       throw releaseError("INDEX_RELEASE_INVALID", `index Manifest digest mismatch: ${descriptor.index_key}`);
     }
+    if (index.records.some(record => !/^[a-f0-9]{64}$/.test(record.sha256 ?? ""))) throw releaseError("INDEX_RELEASE_INVALID", "every Wiki needs a content SHA-256; rebuild legacy indexes");
     documents += index.records.length;
     files.push({ key: descriptor.index_key, file, bytes, sha256: descriptor.sha256 });
   }
@@ -132,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 });
@@ -143,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 });
@@ -151,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 });
@@ -242,12 +251,12 @@ export async function smokePublishedIndex({ env, fetchImpl = fetch, categoryPath
   };
 }
 
-export async function publishHardwareSearchIndex({ sourceDir, outputDir, releaseId, env, fetchImpl = fetch, dryRun = false, smoke = true, concurrency, bootstrapManifest = false } = {}) {
+export async function publishHardwareSearchIndex({ sourceDir, outputDir, releaseId, componentSnapshot, env, fetchImpl = fetch, dryRun = false, smoke = true, concurrency, bootstrapManifest = false } = {}) {
   if (!sourceDir) throw releaseError("USAGE", "sourceDir is required");
   const temporary = !outputDir;
   const output = outputDir ? path.resolve(outputDir) : fs.mkdtempSync(path.join(os.tmpdir(), "abelien-hardware-index-"));
   try {
-    const built = buildSearchIndex({ sourceDir, outputDir: output, releaseId });
+    const built = buildSearchIndex({ sourceDir, outputDir: output, releaseId, componentSnapshot });
     const local = validateLocalRelease(output);
     if (dryRun) return {
       status: "validated",
@@ -262,6 +271,18 @@ export async function publishHardwareSearchIndex({ sourceDir, outputDir, release
     };
 
     const config = createTosConfig(env);
+    if (built.generated_source) {
+      const manifestBytes = fs.readFileSync(path.join(built.generated_source, "_manifest.json"));
+      const entries = JSON.parse(manifestBytes);
+      const limit = Number(concurrency || env?.TOS_PUBLISH_CONCURRENCY || 6);
+      await mapConcurrent(entries, Number.isFinite(limit) ? limit : 6, async entry => {
+        const bytes = fs.readFileSync(safeFile(built.generated_source, entry.path));
+        if (sha256(bytes) !== entry.sha256) throw releaseError("SOURCE_WIKI_MISMATCH", "generated Wiki changed after build");
+        await putImmutable(config, `${config.prefix}${entry.path}`, bytes, fetchImpl);
+      });
+      await putImmutable(config, `${config.prefix}${local.catalog.component_snapshot.object_key}`, fs.readFileSync(path.join(built.generated_source, "_component-dimensions.json")), fetchImpl);
+      await putImmutable(config, `${config.prefix}${local.catalog.source_manifest.object_key}`, manifestBytes, fetchImpl);
+    }
     let manifest = await requireMatchingManifest(config, local.catalog, fetchImpl, { optional: true });
     if (!manifest && !bootstrapManifest) {
       throw releaseError("SOURCE_MANIFEST_MISSING", "TOS Wiki Manifest is missing; rerun with --bootstrap-manifest to verify every remote Wiki object before creating it", {
@@ -277,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 });
@@ -295,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,4 +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";
 
@@ -81,11 +83,17 @@ 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", "electrical", "electrical_source",
   ];
   const meta = {};
   for (const key of wanted) {
     const line = frontMatter.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
-    if (line) meta[key] = scalar(line[1]);
+    if (line) {
+      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]);
+    }
   }
   meta.selection_profile = {
     suitable_for: nestedInline(frontMatter, "selection_profile", "suitable_for") ?? [],
@@ -199,6 +207,8 @@ function parseCategoryIndex(object, descriptor, key) {
     }
     if (recordIds.has(record.record_id)) throw error("WIKI_SEARCH_INDEX_INVALID", "category index contains duplicate record_id", { key, record_id: record.record_id });
     recordIds.add(record.record_id);
+    if (!/^[a-f0-9]{64}$/.test(record.sha256 ?? "")) throw error("WIKI_SEARCH_INDEX_INVALID", "category index requires every Wiki content SHA-256; rebuild legacy indexes", { key, record_id: record.record_id });
+    dimensionFields(record);
     record.path = safeRelativeObjectKey(record.path, "Wiki path");
   }
   return index;
@@ -218,6 +228,7 @@ async function mapConcurrent(items, concurrency, mapper) {
 }
 
 function validateInput(input) {
+  validateRequirementEnvelopes(input?.requirements);
   if (!input || typeof input !== "object" || Array.isArray(input)) throw error("VALIDATION", "hardware search input must be an object");
   if (!Array.isArray(input.slots) || input.slots.length === 0) throw error("VALIDATION", "hardware search requires non-empty slots");
   for (const slot of input.slots) {
@@ -258,6 +269,10 @@ function candidateFromDocument(document, config, ranking, includeContent, indexS
     manufacturer: meta.manufacturer == null ? "Unspecified" : String(meta.manufacturer),
     model: meta.model == null ? meta.model : String(meta.model),
     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,
     hardware_form: meta.hardware_form,
@@ -279,7 +294,7 @@ function candidateFromDocument(document, config, ranking, includeContent, indexS
   };
 }
 
-function createWikiLoader(config, fetchImpl) {
+function createWikiLoader(config, fetchImpl, { legacy = false } = {}) {
   const cache = new Map();
   return entry => {
     if (!cache.has(entry.path)) {
@@ -290,9 +305,10 @@ function createWikiLoader(config, fetchImpl) {
             path: entry.path, indexed_record_id: entry.record_id, wiki_record_id: parsed.meta.record_id,
           });
         }
-        if (entry.sha256 && sha256(parsed.content) !== entry.sha256) {
+        if (!/^[a-f0-9]{64}$/.test(entry.sha256 ?? "") || sha256(parsed.content) !== entry.sha256) {
           throw error("WIKI_SEARCH_INDEX_MISMATCH", "Wiki content SHA-256 does not match its search index", { path: entry.path });
         }
+        if (!legacy && !sameDimensionMetadata(parsed.meta, entry)) throw error("WIKI_SEARCH_INDEX_MISMATCH", "Wiki dimension metadata does not match its search index", { path: entry.path });
         return { ...parsed, etag: object.etag, lastModified: object.lastModified, entry };
       }));
     }
@@ -300,7 +316,7 @@ function createWikiLoader(config, fetchImpl) {
   };
 }
 
-async function searchWithCategoryIndexes({ input, env, config, catalogObject, fetchImpl, topK, includeContent }) {
+async function searchWithCategoryIndexes({ input, env, config, catalogObject, fetchImpl, topK, maxFetch, includeContent }) {
   const catalogKey = `${config.prefix}_catalog.json`;
   const { categories } = parseCatalog(catalogObject, catalogKey);
   const indexCache = new Map();
@@ -314,7 +330,7 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     if (!indexCache.has(descriptor.index_key)) {
       indexCache.set(descriptor.index_key, getObject(config, `${config.prefix}${descriptor.index_key}`, fetchImpl).then(object => {
         const index = parseCategoryIndex(object, descriptor, `${config.prefix}${descriptor.index_key}`);
-        shardSnapshots.push(`${descriptor.index_key}:${object.etag}`);
+        shardSnapshots.push(`${descriptor.index_key}:${object.etag}:${object.raw_sha256}`);
         return index;
       }));
     }
@@ -333,23 +349,26 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     }
     const index = await loadIndex(descriptor);
     const semanticQuery = semanticQueryFor(input, slot);
-    const rankedIndex = index.records.map(entry => ({
-      entry,
+    const screen = screenDimensions(index.records, input.requirements);
+    const rankedIndex = screen.survivors.map(({ record: entry, check }) => ({
+      entry, check,
       ranking: scoreIndexEntry(entry, semanticQuery, input.policy?.prefer_system_candidates !== false),
     })).sort((a, b) => b.ranking.score - a.ranking.score || String(a.entry.model).localeCompare(String(b.entry.model)));
-    const shortlist = rankedIndex.slice(0, topK);
+    const shortlist = shortlistByDimensionTier(rankedIndex, topK, maxFetch, item => item.check.status);
     const loaded = await mapConcurrent(shortlist, concurrency, async item => ({
       document: await wikiLoader(item.entry), indexRanking: item.ranking,
     }));
-    const candidates = loaded.map(({ document, indexRanking }) => {
+    const candidates = orderByDimensionTier(loaded.map(({ document, indexRanking }) => {
       const ranking = scoreDocument(document, semanticQuery, input.policy?.prefer_system_candidates !== false);
-      return candidateFromDocument(document, config, ranking, includeContent, indexRanking.score);
-    }).sort((a, b) => b.semantic_score - a.semantic_score || b.index_score - a.index_score || String(a.model).localeCompare(String(b.model)));
+      const candidate = candidateFromDocument(document, config, ranking, includeContent, indexRanking.score);
+      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements) };
+    }).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({
       slot_id: slot.slot_id,
       category_path: slot.category_path,
       retrieval_mode: "category_index",
+      dimension_screen: screen.summary,
       available_documents: index.records.length,
       indexed_candidates: index.records.length,
       fetched_documents: shortlist.length,
@@ -361,19 +380,19 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     results,
     unmatchedSlots,
     unknowns: [],
-    sourceSnapshot: `tos:${config.bucket}:${config.prefix}:catalog:${catalogObject.etag}:indexes:${shardsDigest}`,
+    sourceSnapshot: `tos:${config.bucket}:${config.prefix}:catalog:${catalogObject.etag}:indexes:${shardsDigest}:content:${catalogObject.raw_sha256}`,
     retrievalMode: "category_index",
   };
 }
 
-async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, includeContent }) {
+async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, maxFetch, includeContent }) {
   const manifestKey = `${config.prefix}_manifest.json`;
   const manifestObject = await getObject(config, manifestKey, fetchImpl);
   const manifest = parseJsonObject(manifestObject, "WIKI_MANIFEST_INVALID", "TOS hardware Wiki manifest is not valid JSON", manifestKey);
   if (!Array.isArray(manifest)) throw error("WIKI_MANIFEST_INVALID", "TOS hardware Wiki manifest must be an array", { key: manifestKey });
   const scanLimit = Number.isInteger(input.policy?.scan_limit_per_slot) && input.policy.scan_limit_per_slot > 0
     ? input.policy.scan_limit_per_slot : null;
-  const wikiLoader = createWikiLoader(config, fetchImpl);
+  const wikiLoader = createWikiLoader(config, fetchImpl, { legacy: true });
   const results = [];
   const unmatchedSlots = [];
   const unknowns = [{ code: "SEARCH_INDEX_FALLBACK", message: "category search catalog missing; legacy Manifest full scan was explicitly enabled" }];
@@ -385,10 +404,11 @@ async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, i
     }
     const loaded = await mapConcurrent(entries, envPositiveInteger(env, "TOS_SEARCH_CONCURRENCY", 8), wikiLoader);
     const semanticQuery = semanticQueryFor(input, slot);
-    const candidates = loaded.map(document => {
+    const candidates = shortlistByDimensionTier(loaded.map(document => {
       const ranking = scoreDocument(document, semanticQuery, input.policy?.prefer_system_candidates !== false);
-      return candidateFromDocument(document, config, ranking, includeContent, ranking.score);
-    }).sort((a, b) => b.semantic_score - a.semantic_score || String(a.model).localeCompare(String(b.model))).slice(0, topK);
+      const candidate = candidateFromDocument(document, config, ranking, includeContent, ranking.score);
+      return { ...candidate, dimension_check: evaluateDimensions(candidate, input.requirements) };
+    }).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({
       slot_id: slot.slot_id, category_path: slot.category_path, retrieval_mode: "legacy_manifest_full_scan",
@@ -423,9 +443,9 @@ export async function searchHardware({ input, env, fetchImpl = fetch }) {
     });
   }
   const searched = catalogObject
-    ? await searchWithCategoryIndexes({ input, env, config, catalogObject, fetchImpl, topK, includeContent })
-    : await searchWithLegacyManifest({ input, env, config, fetchImpl, topK, includeContent });
-  const id = `search-${sha256(JSON.stringify({ query: input.query ?? "", slots: input.slots, sourceSnapshot: searched.sourceSnapshot })).slice(0, 16)}`;
+    ? await searchWithCategoryIndexes({ input, env, config, catalogObject, fetchImpl, topK, maxFetch: maxFullWikiFetch, includeContent })
+    : await searchWithLegacyManifest({ input, env, config, fetchImpl, topK, maxFetch: maxFullWikiFetch, includeContent });
+  const id = `search-${sha256(JSON.stringify({ query: input.query ?? "", request_digest: selectionRequestDigest(input), slots: input.slots, sourceSnapshot: searched.sourceSnapshot })).slice(0, 16)}`;
   return {
     id,
     status: "completed",

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

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

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