abelien-harness 0.17.0 → 0.18.0

package/skills/abelien-hardware/schemas/hardware-selection.v2.json

@@ -23,8 +23,8 @@
       "pattern": "^sha256:[a-f0-9]{64}$"
     },
     "Basis": {
-      "description": "事实依据：manufacturer 厂商资料（关联具体型号行、页面或图纸位置）；measured 实测（关联测量记录、被测对象与方法）；estimate 估算；engineering_design 工程设计决定（预留、壁厚、假设尺寸，不能回写成厂商规格）；unknown 来源或可信度不明。",
-      "enum": ["manufacturer", "measured", "estimate", "engineering_design", "unknown"]
+      "description": "事实来源类型：manufacturer 厂商资料；measured 测量记录；estimate 估算；engineering_design 工程设计；recorded 库内或既有资料记录。unknown 仅兼容历史记录，新资料按完整度列明缺项。",
+      "enum": ["manufacturer", "measured", "estimate", "engineering_design", "recorded", "unknown"]
     },
     "Unit": {
       "description": "受控单位。px 用来如实记录没有尺度依据的读图结果，不能当毫米用；none 用于无量纲值或结构化记录。",
@@ -77,11 +77,17 @@
           "then": { "properties": { "locator": { "type": "object" } } }
         },
         {
-          "if": { "properties": { "unit": { "enum": ["mm", "deg"] } }, "required": ["unit"] },
+          "if": { "properties": { "unit": { "enum": ["mm", "deg"] }, "property": {"not": {"const": "partial_outline_size"}} }, "required": ["unit"] },
           "then": {
             "required": ["frame"],
             "properties": { "value": { "oneOf": [{ "type": "number" }, { "type": "array", "items": { "type": "number" }, "minItems": 1, "maxItems": 3 }] } }
           }
+        },
+        {
+          "if": {"properties": {"property": {"const": "partial_outline_size"}}, "required": ["property"]},
+          "then": {"required": ["frame"], "properties": {"unit": {"const": "mm"},
+            "subject": {"enum": ["device_outline", "module_outline"]},
+            "value": {"$ref": "../../abelien-harness/contracts/schemas/cross-domain.v1.json#/$defs/PartialPositiveTriple"}}}
         }
       ]
     },

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

@@ -6,6 +6,15 @@ const nonnegative = 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 tuple = v => Array.isArray(v) && v.length === 3 && v.every(positive);
+const partialTuple = v => Array.isArray(v) && v.length === 3 && v.some(positive) && v.every(axis => axis === null || positive(axis));
+const DATA_FIELDS = ['x_mm', 'y_mm', 'z_mm', 'source_ref'];
+const SNAPSHOT_V2 = 'abelien.component-dimensions.v2';
+/** Availability only: axes and a reference, with an explicit denominator; no confidence state. */
+export function dimensionCompleteness(value, sourceRef) {
+  const present = [0, 1, 2].map(axis => Array.isArray(value) && value.length <= 3 && positive(value[axis])).concat(text(sourceRef));
+  const missing = DATA_FIELDS.filter((_, index) => !present[index]);
+  return { complete: missing.length === 0, filled: present.filter(Boolean).length, total: DATA_FIELDS.length, missing };
+}
 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`);
@@ -47,31 +56,35 @@ export function validateRequirementEnvelopes(requirements) {
   for (const row of requirements?.limits ?? []) if (row?.envelope !== undefined) validateEnvelope(row.envelope);
 }
 const BASE_FIELDS = ['component_id', 'dimensions_mm', 'dimension_basis', 'dimension_geometry'];
-function dimensionRecord(value) {
+function dimensionRecord(value, v2 = Object.hasOwn(value, 'data_completeness')) {
   const record = Object.fromEntries(BASE_FIELDS.map(key => [key, value[key]]));
   if (value.evidence_ref !== undefined) record.evidence_ref = value.evidence_ref;
+  if (v2) record.data_completeness = value.data_completeness;
   return record;
 }
-function validRecord(value) {
-  return object(value) && text(value.component_id) && (value.dimensions_mm === null || tuple(value.dimensions_mm))
-    && ['measured', 'datasheet', 'estimate', 'unknown'].includes(value.dimension_basis)
-    && ['solid_box', 'bounding_box', 'unknown'].includes(value.dimension_geometry)
+function validRecord(value, v2 = false) {
+  return object(value) && text(value.component_id) && (value.dimensions_mm === null || (v2 ? partialTuple(value.dimensions_mm) : tuple(value.dimensions_mm)))
+    && (v2 ? ['measured', 'datasheet', 'estimate', 'catalog'] : ['measured', 'datasheet', 'estimate', 'unknown']).includes(value.dimension_basis)
+    && (v2 ? ['solid_box', 'bounding_box', null] : ['solid_box', 'bounding_box', 'unknown']).includes(value.dimension_geometry)
     && (value.evidence_ref === undefined || text(value.evidence_ref))
-    && (value.dimensions_mm !== null || (value.dimension_basis === 'unknown' && value.dimension_geometry === 'unknown'));
+    && (v2 ? canonical(value.data_completeness) === canonical(dimensionCompleteness(value.dimensions_mm, value.evidence_ref))
+      && (tuple(value.dimensions_mm) || value.dimension_basis === 'catalog' && value.dimension_geometry === null)
+      : value.dimensions_mm !== null || (value.dimension_basis === 'unknown' && value.dimension_geometry === 'unknown'));
 }
 // Same revision the component database export writes, for a record that did not come from a snapshot file.
 export function dimensionRevision(value) {
   const record = dimensionRecord(value);
-  if (!validRecord(record)) invalid('component dimension record is invalid');
+  if (!validRecord(record, Object.hasOwn(record, 'data_completeness'))) invalid('component dimension record is invalid');
   return digest(record);
 }
 export function validateComponentSnapshot(snapshot) {
   keys(snapshot, ['schema', 'snapshot_id', 'records'], [], 'component snapshot');
-  if (snapshot.schema !== 'abelien.component-dimensions.v1' || !Array.isArray(snapshot.records) || !hash(snapshot.snapshot_id)) invalid('unsupported component dimension snapshot');
+  const v2 = snapshot.schema === SNAPSHOT_V2;
+  if (!v2 && snapshot.schema !== 'abelien.component-dimensions.v1' || !Array.isArray(snapshot.records) || !hash(snapshot.snapshot_id)) invalid('unsupported component dimension snapshot');
   let previous;
   for (const row of snapshot.records) {
-    keys(row, [...BASE_FIELDS, 'revision'], ['evidence_ref'], 'component snapshot record');
-    if (!validRecord(row) || !hash(row.revision) || row.revision !== digest(dimensionRecord(row))) invalid('component dimension record or revision is invalid');
+    keys(row, [...BASE_FIELDS, 'revision', ...(v2 ? ['data_completeness'] : [])], ['evidence_ref'], 'component snapshot record');
+    if (!validRecord(row, v2) || !hash(row.revision) || row.revision !== digest(dimensionRecord(row, v2))) invalid('component dimension record or revision is invalid');
     if (previous !== undefined && previous >= row.component_id) invalid('component records must be unique and sorted by component_id');
     previous = row.component_id;
   }
@@ -82,23 +95,29 @@ export function validateComponentSnapshot(snapshot) {
 export function dimensionFields(value) {
   const source = value?.dimension_source;
   const id = value?.component_id ?? value?.record_id;
-  const validSize = tuple(value?.dimensions_mm);
-  const fields = { dimensions_mm: validSize ? [...value.dimensions_mm] : null, dimension_basis: 'unknown', dimension_geometry: 'unknown', dimension_source: null };
+  const validSize = tuple(value?.dimensions_mm) || partialTuple(value?.dimensions_mm);
+  const fields = { dimensions_mm: validSize ? [...value.dimensions_mm] : null, dimension_basis: 'catalog', dimension_geometry: validSize && tuple(value.dimensions_mm) ? 'bounding_box' : null, dimension_source: null,
+    data_completeness: dimensionCompleteness(validSize ? value.dimensions_mm : null, source?.evidence_ref) };
   if (!object(source) || source.component_id !== id || !hash(source.revision) || !hash(source.snapshot_id)) return fields;
+  const v2 = source.record_schema === SNAPSHOT_V2;
   const record = { component_id: id, dimensions_mm: fields.dimensions_mm, dimension_basis: value.dimension_basis,
-    dimension_geometry: value.dimension_geometry ?? 'unknown', ...(source.evidence_ref !== undefined ? { evidence_ref: source.evidence_ref } : {}) };
+    dimension_geometry: v2 ? value.dimension_geometry : value.dimension_geometry ?? 'unknown', ...(source.evidence_ref !== undefined ? { evidence_ref: source.evidence_ref } : {}),
+    ...(v2 ? { data_completeness: value.data_completeness } : {}) };
   // Missing geometry is a legacy gap, not permission to apply solid-box predicates.
   if (value.dimension_geometry === undefined) { fields.dimension_source = { ...source }; return fields; }
-  if (!validRecord(record) || source.revision !== digest(record)) invalid('dimension source revision does not match candidate fields');
-  return { dimensions_mm: record.dimensions_mm, dimension_basis: record.dimension_basis, dimension_geometry: record.dimension_geometry, dimension_source: { ...source } };
+  if (!validRecord(record, v2) || source.revision !== digest(record)) invalid('dimension source revision does not match candidate fields');
+  return { dimensions_mm: record.dimensions_mm, dimension_basis: record.dimension_basis, dimension_geometry: record.dimension_geometry, dimension_source: { ...source },
+    data_completeness: dimensionCompleteness(record.dimensions_mm, record.evidence_ref) };
 }
 export function fieldsFromSnapshotRecord(record, snapshotId) {
   return { dimensions_mm: record.dimensions_mm, dimension_basis: record.dimension_basis, dimension_geometry: record.dimension_geometry,
-    dimension_source: { component_id: record.component_id, revision: record.revision, snapshot_id: snapshotId, ...(record.evidence_ref !== undefined ? { evidence_ref: record.evidence_ref } : {}) } };
+    dimension_source: { component_id: record.component_id, revision: record.revision, snapshot_id: snapshotId, ...(Object.hasOwn(record, 'data_completeness') ? { record_schema: SNAPSHOT_V2 } : {}), ...(record.evidence_ref !== undefined ? { evidence_ref: record.evidence_ref } : {}) },
+    data_completeness: dimensionCompleteness(record.dimensions_mm, record.evidence_ref) };
 }
 // Compare raw dimension-bearing fields too: normalizing unknowns must not hide index/Wiki drift.
 export function sameDimensionMetadata(a, b) {
-  const pick = value => ({ dimensions_mm: value.dimensions_mm ?? null, dimension_basis: value.dimension_basis ?? 'unknown', dimension_geometry: value.dimension_geometry ?? 'unknown', dimension_source: value.dimension_source ?? null });
+  const pick = value => ({ dimensions_mm: value.dimensions_mm ?? null, dimension_basis: value.dimension_basis ?? 'catalog', dimension_geometry: value.dimension_geometry ?? null, dimension_source: value.dimension_source ?? null,
+    data_completeness: value.data_completeness ?? dimensionCompleteness(value.dimensions_mm, value.dimension_source?.evidence_ref) });
   return canonical(pick(a)) === canonical(pick(b));
 }
 function cavity(envelope, wall) {
@@ -131,7 +150,8 @@ export function evaluateDimensions(candidate, requirements, slot) {
     .map(row => ({ id: row.id, envelope: row.envelope, hardLimit: row.source === 'user' && row.strength === 'hard' })),
   ...(fit ? [{ id: `fit:${slot.slot_id}`, envelope: fit.envelope, hardLimit: false, decides: fit.basis === 'locked', basis: fit.basis, ...(fit.zone ? { zone: fit.zone } : {}) }] : [])];
   if (!limits.length) return unknown('PRODUCT_ENVELOPE_MISSING');
-  if (!fields.dimensions_mm || fields.dimension_basis === 'unknown' || fields.dimension_geometry === 'unknown') return unknown('COMPONENT_DIMENSIONS_UNKNOWN');
+  if (!tuple(fields.dimensions_mm)) return { status: 'incomplete', decision_required: false,
+    completeness: fields.data_completeness, reasons: [{ code: 'COMPONENT_DIMENSIONS_INCOMPLETE', missing: fields.data_completeness.missing.filter(field => field !== 'source_ref') }], method };
   const dims = fields.dimensions_mm;
   if (!positive(dims.reduce((a, b) => a * b, 1)) || !positive(Math.hypot(...dims))
     || limits.some(row => { const c = cavity(row.envelope, row.envelope.wall_mm?.minimum ?? 0); return !positive(c.volume) || !positive(c.chord); }))
@@ -194,7 +214,7 @@ export function assemblyOccupancy(models, requirements, policy = {}) {
     if (seen.has(model.bom_item_id)) continue;
     if (model.bom_item_id) seen.add(model.bom_item_id);
     const fields = dimensionFields(model);
-    if (!fields.dimensions_mm || fields.dimension_basis === 'unknown' || !Number.isSafeInteger(model.quantity) || model.quantity < 1) { unknown_lines++; continue; }
+    if (!tuple(fields.dimensions_mm) || !Number.isSafeInteger(model.quantity) || model.quantity < 1) { unknown_lines++; continue; }
     const volume = fields.dimensions_mm.reduce((a, b) => a * b, model.quantity);
     if (!positive(volume) || !Number.isFinite(estimated_volume_mm3 + volume)) { unknown_lines++; continue; }
     estimated_volume_mm3 += volume;

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

@@ -87,7 +87,7 @@ 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",
+    "dimensions_mm", "dimension_basis", "dimension_geometry", "dimension_source", "data_completeness", "interfaces", "electrical", "electrical_source",
   ];
   const meta = {};
   for (const key of wanted) {
@@ -95,7 +95,7 @@ export function parseHardwareWiki(content) {
     // An empty value (including YAML block style) is treated as absent, as before these keys were read.
     const line = frontMatter.match(new RegExp(`^${key}:[ \\t]*(.*)$`, "m"));
     if (line && line[1].trim()) {
-      if (["dimension_source", "dimensions_mm", "electrical", "electrical_source"].includes(key)) {
+      if (["dimension_source", "dimensions_mm", "data_completeness", "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]);

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

@@ -3,7 +3,7 @@
 // candidate set; the other slots carry their lines unchanged. Dimensions and electrical are recomputed for the whole
 // set with the same deterministic evaluators hardware.select uses, plus board-side pin-to-pin interfaces. Checks never
 // decide the gate. from_selection bridges a stored v1 selection (hardware.select) into the same model.
-import { assemblyOccupancy, evaluateDimensions } from "./dimensions.mjs";
+import { assemblyOccupancy, dimensionCompleteness, evaluateDimensions } from "./dimensions.mjs";
 import { evaluateElectrical } from "./electrical.mjs";
 import { selectionLineId } from "./finalize-selection.mjs";
 import {
@@ -17,7 +17,7 @@ import { sliceCodePoints } from "../../abelien-harness/scripts/web/safe-text.mjs
 
 // Fact bases mapped onto the component-record bases the shared evaluators understand. Engineering decisions and
 // estimates never gain datasheet authority.
-const RECORD_BASIS = { manufacturer: "datasheet", measured: "measured", estimate: "estimate", engineering_design: "estimate", unknown: "unknown" };
+const RECORD_BASIS = { manufacturer: "datasheet", measured: "measured", estimate: "estimate", engineering_design: "estimate", recorded: "unknown", unknown: "unknown" };
 const ELECTRICAL_STATUS = { pass: "pass", fail: "conflict", gap: "conflict", risk: "unknown", unknown: "unknown" };
 const RANK = { pass: 0, unchecked: 1, unknown: 2, conflict: 3 };
 const NO_SNAPSHOT = "0".repeat(64);
@@ -55,15 +55,20 @@ function sizeRecord(componentId, fact) {
   return { ...fields, dimension_source: { component_id: componentId, revision: digest(fields), snapshot_id: fact.source_ref?.digest ?? NO_SNAPSHOT } };
 }
 function dimensionItem(slot, candidate, requirements, requirementsRef) {
-  const base = { item_id: refId("dimensions:", slot.slot_id), subjects: [slot.slot_id] };
+  const picked = candidate ? pickOutline(candidate) : {};
+  const partial = candidate?.facts.find(fact => fact.property === "partial_outline_size" && fact.unit === "mm" && OUTLINE_SUBJECTS.includes(fact.subject));
+  const data_completeness = dimensionCompleteness(picked.fact?.value ?? partial?.value,
+    picked.fact?.source_ref?.id ?? partial?.source_ref?.id ?? picked.refs?.[0]?.id);
+  const base = { item_id: refId("dimensions:", slot.slot_id), subjects: [slot.slot_id], detail: {data_completeness} };
   if (!candidate) return { ...base, status: "unchecked", method: "none", evidence_refs: [], reason: "SLOT_UNFILLED" };
   if (!requirements.limits.some(row => row?.envelope) && !slot.fit_envelope) return { ...base, status: "unchecked", method: "none", evidence_refs: [], reason: "NO_ENVELOPE_LIMIT" };
-  const picked = pickOutline(candidate);
-  if (!picked.fact) return { ...base, status: "unknown", method: "computed", evidence_refs: picked.refs, reason: picked.reason };
+  if (!picked.fact) return { ...base, status: "unchecked", method: "none", evidence_refs: [], reason: picked.reason };
   const check = evaluateDimensions(sizeRecord(candidate.component_id ?? candidate.candidate_id, picked.fact), requirements, slot);
   const [status, reason] = check.status === "incompatible" ? ["conflict", "DIMENSION_INCOMPATIBLE"] : check.status === "risk" ? ["unknown", "DIMENSION_RISK"]
-    : check.status === "clear" ? trustedFact(picked.fact) ? ["pass", "DIMENSION_CLEAR"] : ["unknown", "ESTIMATED_SIZE_ONLY"] : ["unknown", check.reasons[0]?.code ?? "DIMENSION_UNKNOWN"];
-  return { ...base, status, method: "computed", evidence_refs: uniqueRefs([picked.fact.source_ref, requirementsRef]), reason, detail: { fact_id: picked.fact.fact_id, dimension_check: check } };
+    : check.status === "clear" ? ["pass", "DIMENSION_CLEAR"] : ["unchecked", check.reasons[0]?.code ?? "DIMENSION_INCOMPLETE"];
+  return { ...base, status, method: status === "unchecked" ? "none" : "computed",
+    evidence_refs: status === "unchecked" ? [] : uniqueRefs([picked.fact.source_ref, requirementsRef]), reason,
+    detail: { data_completeness, fact_id: picked.fact.fact_id, dimension_check: check } };
 }
 
 // Board-side required_interfaces against each target slot's interfaces: pass or conflict only when both facts are trusted.

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

@@ -13,7 +13,7 @@ import {
 
 const UNSPECIFIED_MANUFACTURER = "Unspecified";
 // Component database bases map onto fact bases; datasheet values are the manufacturer's.
-const FACT_BASIS = { datasheet: "manufacturer", measured: "measured", estimate: "estimate", unknown: "unknown" };
+const FACT_BASIS = { datasheet: "manufacturer", measured: "measured", estimate: "estimate", catalog: "recorded", unknown: "recorded" };
 const LOCAL_FRAME = { coordinate_system: "component_local", datum: "unspecified", orientation: "unspecified", tolerance_mm: null };
 const candidateId = (slotId, kind, key) => `cand-${digest({ slot_id: slotId, item_kind: kind, key }).slice(0, 24)}`;
 const normalized = value => value.toLowerCase().replace(/[\s_]+/g, "");
@@ -28,16 +28,17 @@ function recordFacts(part, component, addEvidence) {
   let dims;
   try { dims = dimensionFields(part); } catch (error) { integrity(`candidate ${component} dimension source does not match its fields`, { cause: error.message }); }
   if (dims.dimensions_mm) {
+    const property = dims.dimensions_mm.every(value => typeof value === "number") ? "outline_size" : "partial_outline_size";
     if (dims.dimension_source) {
       const ref = { id: refId("dimension-record:", component), version: `r-${dims.dimension_source.revision.slice(0, 12)}`, digest: dims.dimension_source.revision };
       addEvidence({ ref, kind: "dimension_record", content: null, content_sha256: null, locator: { snapshot_id: dims.dimension_source.snapshot_id } });
-      facts.push({ fact_id: "outline_size", property: "outline_size", subject: "device_outline", value: dims.dimensions_mm, unit: "mm",
+      facts.push({ fact_id: property, property, subject: "device_outline", value: dims.dimensions_mm, unit: "mm",
         basis: FACT_BASIS[dims.dimension_basis], source_ref: ref,
         locator: { snapshot_id: dims.dimension_source.snapshot_id, field: "dimensions_mm", ...(dims.dimension_source.evidence_ref ? { evidence_ref: dims.dimension_source.evidence_ref } : {}) },
         conditions: {}, frame: LOCAL_FRAME, method: "component_dimension_record",
         ...(["solid_box", "bounding_box"].includes(dims.dimension_geometry) ? { shape: dims.dimension_geometry } : {}) });
-    } else facts.push({ fact_id: "outline_size", property: "outline_size", subject: "device_outline", value: dims.dimensions_mm, unit: "mm",
-      basis: "unknown", source_ref: null, locator: { field: "dimensions_mm", binding: "legacy_unbound" }, conditions: {}, frame: LOCAL_FRAME });
+    } else facts.push({ fact_id: property, property, subject: "device_outline", value: dims.dimensions_mm, unit: "mm",
+      basis: "recorded", source_ref: null, locator: { field: "dimensions_mm", binding: "legacy_unbound" }, conditions: {}, frame: LOCAL_FRAME });
   }
   // Electrical: the component-electrical record as one structured fact, only when it is source-bound.
   let electrical;
@@ -51,7 +52,7 @@ function recordFacts(part, component, addEvidence) {
   }
   // Interfaces written in a library record have no source binding yet: kept for display, never trusted.
   if (validInterfaceList(part.interfaces)) facts.push({ fact_id: "interfaces", property: "interfaces", subject: "connector", value: part.interfaces.map(({ type, package: pkg }) => ({ type, package: pkg })),
-    unit: "none", basis: "unknown", source_ref: null, locator: { field: "interfaces", binding: "legacy_unbound" }, conditions: {} });
+    unit: "none", basis: "recorded", source_ref: null, locator: { field: "interfaces", binding: "legacy_unbound" }, conditions: {} });
   return facts;
 }
 
@@ -76,7 +77,7 @@ function freezeLibrary(candidate, slot, claim, addEvidence, readBlob, texts) {
   const facts = recordFacts(candidate, component, addEvidence);
   // Web envelopes are source quotes of unknown authority: kept for display, never used for fitting.
   if (web && record(candidate.geometry)) facts.push({ fact_id: "source_envelope", property: "source_envelope", subject: "other", value: candidate.geometry,
-    unit: "none", basis: "unknown", source_ref: source.ref, locator: { page_id: candidate.source?.page_id ?? "unknown" }, conditions: {} });
+    unit: "none", basis: "recorded", source_ref: source.ref, locator: { page_id: candidate.source?.page_id ?? "unknown" }, conditions: {} });
   // Identity: an exact ordering code needs a verbatim quote from the frozen text; otherwise the model text is only a series.
   const manufacturer = String(candidate.manufacturer ?? "");
   let model = String(candidate.model), status = !text(manufacturer) || manufacturer === UNSPECIFIED_MANUFACTURER ? "unknown"
@@ -86,7 +87,7 @@ function freezeLibrary(candidate, slot, claim, addEvidence, readBlob, texts) {
       invalid(`identity claim for ${component} needs a verbatim quote from its frozen text that contains an ordering code of model ${JSON.stringify(model)}`);
     if (status !== "unknown") { status = "exact_model_confirmed"; model = claim.ordering_code; }
     facts.push({ fact_id: "ordering_code", property: "ordering_code", subject: "device", value: claim.ordering_code, unit: "none",
-      basis: web ? "unknown" : "manufacturer", source_ref: source.ref, locator: { quote: claim.quote }, conditions: {}, method: "verbatim_quote" });
+      basis: web ? "recorded" : "manufacturer", source_ref: source.ref, locator: { quote: claim.quote }, conditions: {}, method: "verbatim_quote" });
   }
   const issues = web ? ["web source authority and engineering data are unverified; geometry is an envelope from source quotes"] : [];
   return { candidate: { candidate_id: candidateId(slot.slot_id, "purchased", component), slot_id: slot.slot_id, item_kind: "purchased",

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

@@ -3,8 +3,9 @@
 // interfaces and facing axes: structure takes them as the part's own data, so anything else stays null or absent and
 // structure records unknown. Sizes keep their basis, so estimates still only demote.
 import { OUTLINE_SUBJECTS, digest, factOf, identityOf, invalid, refId, trustedFact, verifySelectionRevision } from "./selection-model.mjs";
+import { dimensionCompleteness } from "./dimensions.mjs";
 
-const SIZE_BASIS = { manufacturer: "datasheet", measured: "measured", estimate: "estimate", engineering_design: "estimate", unknown: "unknown" };
+const SIZE_BASIS = { manufacturer: "datasheet", measured: "measured", estimate: "estimate", engineering_design: "estimate", recorded: "catalog", unknown: "catalog" };
 
 /** The frozen part object behind a candidate: its identity plus its facts, versioned by the identity's own version. */
 export function componentRefOf(candidate) {
@@ -16,8 +17,12 @@ export function componentRefOf(candidate) {
 function size(candidate) {
   const outline = (candidate.facts ?? []).filter(fact => fact.property === "outline_size" && OUTLINE_SUBJECTS.includes(fact.subject) && fact.unit === "mm");
   const fact = outline.find(trustedFact) ?? outline[0];
-  const basis = fact ? SIZE_BASIS[fact.basis] : "unknown";
-  return { dimensions_mm: basis === "unknown" ? null : [...fact.value], dimension_basis: basis };
+  const basis = fact ? SIZE_BASIS[fact.basis] : "catalog";
+  const value = fact ? [...fact.value] : null;
+  const partial = !fact && candidate.facts.find(item => item.property === "partial_outline_size" && item.unit === "mm" && OUTLINE_SUBJECTS.includes(item.subject));
+  return { dimensions_mm: value, dimension_basis: basis,
+    ...(partial ? {partial_dimensions_mm: [...partial.value]} : {}),
+    data_completeness: dimensionCompleteness(value ?? partial?.value, fact?.source_ref?.id ?? partial?.source_ref?.id) };
 }
 const trustedValue = (candidate, property) => { const fact = factOf(candidate, property); return fact && trustedFact(fact) ? fact.value : null; };
 

package/skills/abelien-harness/contracts/schemas/cross-domain.v1.json

@@ -4,6 +4,18 @@
   "title": "abelien.contracts.cross-domain.v1",
   "description": "第 10 组：跨域产物（流程策略 §5、§10，硬件证据模型 §3）。钥匙是需求的 reaction_id，往下每层多一个字段，不另起键：槽位带 reaction_ids，BOM 行带 slot_id，点位带 binding{reaction_id, slot_id}，骨架给每个物理实例一个 occurrence。数值次序（min ≤ max、壁厚留出空腔）等跨字段算术仍由各域的确定性检查负责。",
   "$defs": {
+    "DataCompleteness": {
+      "description": "资料可用项覆盖率；只统计完整与缺项，不评价来源可信度。",
+      "type": "object",
+      "required": ["complete", "filled", "total", "missing"],
+      "properties": {
+        "complete": { "type": "boolean" },
+        "filled": { "type": "integer", "minimum": 0 },
+        "total": { "type": "integer", "minimum": 1 },
+        "missing": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true }
+      },
+      "additionalProperties": false
+    },
     "ShortIdentifier": {
       "description": "分区名等短标识（与现有 fit_envelope.zone 规则相同）。",
       "type": "string",
@@ -15,6 +27,12 @@
       "minItems": 3,
       "maxItems": 3
     },
+    "PartialPositiveTriple": {
+      "type": "array",
+      "items": {"oneOf": [{"type": "number", "exclusiveMinimum": 0}, {"type": "null"}]},
+      "minItems": 3,
+      "maxItems": 3
+    },
     "Triple": {
       "type": "array",
       "items": { "type": "number" },

package/skills/abelien-harness/scripts/ab.mjs

@@ -25,7 +25,7 @@ export { interpolate, findWorkflow, loadWorkflow, workflowDefinitionDigest, pars
 // doctor must report the shipped package version, never a frozen constant (0.2.3 drifted across
 // six releases). The npm tree always ships package.json at the skill root; standalone skill copies
 // fall back to FALLBACK_VERSION, which scripts/release-check.mjs pins to package.json.
-const FALLBACK_VERSION = "0.17.0";
+const FALLBACK_VERSION = "0.18.0";
 export let VERSION = FALLBACK_VERSION;
 try {
   VERSION = String(JSON.parse(fs.readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version || FALLBACK_VERSION);

package/skills/abelien-structure/SKILL.md

@@ -62,3 +62,5 @@ CAD 只经宿主的受管工具执行：`cad.assets` 取组件 CAD，`cad.preche
 | [结构合理性规则](references/structure-reasonableness.md) | 判断结构合不合理、写自检表，或 remix 直接建模时 |
 | [交接契约](references/handoff.md) | 首次参与或基线变化，需要知道输入、反馈与结果的语义时 |
 | [动作参数与错误手册](references/actions.generated.md) | 调用任何动作前核对参数与错误码时 |
+
+尺寸资料按 data_completeness 显示完整度；库内已有三轴直接参与布局，不因来源标签 unknown 丢弃。catalog 是资料来源类型，实际缺轴时才要求 reserved_mm。规则见 [尺寸完整度契约](../abelien-hardware/references/selection-service-contract.md)。