abelien-harness 0.18.0 → 0.19.0

package/package.json

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

package/skills/abelien-algorithm/contract/host-tools.generated.json

@@ -710,7 +710,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -996,7 +996,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -1282,7 +1282,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -1568,7 +1568,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -1854,7 +1854,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -2140,7 +2140,7 @@
                                             ]
                                           },
                                           "source": {
-                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                            "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                             "type": "object",
                                             "oneOf": [
                                               {
@@ -2438,7 +2438,7 @@
                                           ]
                                         },
                                         "source": {
-                                          "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图冻结输入里的 JSON 指针；这两种的值由节点定稿逐一核对（verifyCalcReceipts），抄错就拒收回复。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
+                                          "description": "带值操作数的来源，三选一。result：本步之前某个动作结果里的 JSON 指针；input：本节点任务视图 work 里的 JSON 指针，从 work 的根写起（例如 /fixed_input/tolerances/contact_mm）；这两种的值在动作调用时由任务视图装配器核对（错了以可纠正的码拒），回复时由节点定稿复核（verifyCalcReceipts）。choice：模型的选择或假设，写依据；只要有一个操作数是 choice，结果就标为估算。",
                                           "type": "object",
                                           "oneOf": [
                                             {

package/skills/abelien-algorithm/scripts/research.mjs

@@ -158,7 +158,7 @@ export async function researchAlgorithms({ input, env = {}, fetchImpl, readResou
     const begin = await beginPaid(registry, "query", key, body, { waitMs: LIMITS.searchTimeoutMs + 5000 });
     if (begin.hit) {
       entry = { id: `s${index + 1}`, reaction_id: q.reaction_id, component_id: q.component_id, query: q.query, count: q.count, provider: client.provider, request: body, dispatch_state: "registry",
-        sent_at: null, status: "completed", error_code: null, outcome: "received", request_id: null, receipt_sha256: null, receipt_blob_ref: null, results: [], registry: { ...registryRef, hit: true } };
+        status: "completed", error_code: null, outcome: "received", request_id: null, receipt_sha256: null, receipt_blob_ref: null, results: [], registry: { ...registryRef, hit: true } };
       searches[index] = entry;
       keepReceipt(entry, begin.hit.receipt);
       entry.results = webResults(begin.hit.receipt.response);

package/skills/abelien-appearance/contract/host-tools.generated.json

@@ -286,7 +286,7 @@
           },
           "reading": {
             "title": "abelien.appearance.points-reading.v1",
-            "description": "读图节点（视觉模型）的输出：模型只报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 写 unreadable 并说明原因，不给任何坐标。规则见 references/points.md。",
+            "description": "冻结的读图结果：模型回复 points-reading-reply.v1（图像像素里的面四角与特征外接框）由读图节点定稿用代码按单应变换换算成面内比例后存成本形状，模型不写比例或毫米（模型算术 PT-1/PT-2）。报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 为 unreadable，不带任何坐标。规则见 references/points.md。",
             "type": "object",
             "required": [
               "schema",
@@ -390,7 +390,7 @@
                 "type": "array",
                 "maxItems": 64,
                 "items": {
-                  "description": "模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。unit=normalized 时为该面宽高的比例。",
+                  "description": "模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。值是该面宽高的比例，由代码从模型给的像素外接框与面四角换算。",
                   "type": "object",
                   "required": [
                     "point_id",
@@ -537,7 +537,19 @@
                 "then": {
                   "properties": {
                     "coordinate_frame": {
-                      "type": "object"
+                      "description": "读图换算后的坐标系恒为面内比例：原点在该面左上角，scale_basis none。",
+                      "type": "object",
+                      "properties": {
+                        "unit": {
+                          "const": "normalized"
+                        },
+                        "origin": {
+                          "const": "face_top_left"
+                        },
+                        "scale_basis": {
+                          "const": "none"
+                        }
+                      }
                     },
                     "visible_faces": {
                       "minItems": 1

package/skills/abelien-appearance/references/actions/appearance.points.generated.md

@@ -23,7 +23,7 @@ appearance.points 的输入：本次读的图片与需求快照的引用、需
 | `reaction_ids` | array<Identifier> | 是 | 至多 256 项；不重复 |
 | `slots` | array<Slot> | 否 | 1–128 项 |
 | `slots_ref` | Ref | 否 | 不可变对象引用：id 固定一条谱系，version 固定其中一个版本，digest 是该版本内容的摘要。设计里写的 ref@version 指的就是这个对象；摘要用来区分同版本号下内容不同的对象（例如同一需求修订下重画的图） |
-| `reading` | object | 是 | 读图节点（视觉模型）的输出：模型只报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 写 unreadable 并说明原因，不给任何坐标。规则见 references/points.md |
+| `reading` | object | 是 | 冻结的读图结果：模型回复 points-reading-reply.v1（图像像素里的面四角与特征外接框）由读图节点定稿用代码按单应变换换算成面内比例后存成本形状，模型不写比例或毫米（模型算术 PT-1/PT-2）。报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 为 unreadable，不带任何坐标。规则见 references/points.md |
 | `reading.schema` | string | 是 | 固定 `"appearance.points-reading.v1"` |
 | `reading.image_digest` | Digest | 是 | sha256 小写十六进制（64 位，不带 sha256: 前缀）。对 JSON 值一律取 harness scripts/web/common.mjs 的 digest()，即对 canonical()（键排序、无空白）后的字节求 sha256 |
 | `reading.outcome` | string | 是 | read：读出了结果（可以是 0 个点位）；unreadable：图看不清或不是产品外观图；取值 `"read"` / `"unreadable"` |
@@ -109,7 +109,7 @@ string；sha256 小写十六进制（64 位，不带 sha256: 前缀）。对 JSO
 
 ### ReadingPoint
 
-模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。unit=normalized 时为该面宽高的比例。
+模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。值是该面宽高的比例，由代码从模型给的像素外接框与面四角换算。
 
 | 参数 | 类型 | 必填 | 说明 |
 | --- | --- | --- | --- |

package/skills/abelien-appearance/references/points.md

@@ -10,13 +10,13 @@
 
 ## 第一步：读图节点（模型）
 
-输入：图片、它的引用（含摘要）、需求里每条 reaction 的 id 与文字（任务视图的 `reactions`）；有槽位表时一并给出，帮助理解哪些位置会有零件。输出符合 [points-reading.v1](../schemas/points-reading.v1.json)。
+输入：图片、它的引用（含摘要）、需求里每条 reaction 的 id 与文字（任务视图的 `reactions`）；有槽位表时一并给出，帮助理解哪些位置会有零件。回复符合 [points-reading-reply.v1](../schemas/points-reading-reply.v1.json)：全部用图像像素写；读图节点定稿用代码把它换算成面内比例，冻结为 [points-reading.v1](../schemas/points-reading.v1.json)。
 
 规则：
 
-1. **只报看得见的面。** 先写 `visible_faces`，点位只能落在这些面上；看不到的面不猜，写进 `unknowns`。
+1. **只报看得见的面。** 先写 `faces`：每个看得见的面一条，带它在图里的四个角；点位只能落在这些面上，看不到的面不猜，写进 `unknowns`。只在某个面的轮廓边缘露出的特征（例如正视图里顶面灯环只在顶缘露出一条亮带）属于边那一侧的面：那个面看得见就写在那个面上，看不见就不给点位，写进 `unknowns`。中心离所在面的边不到面宽高 2% 的特征会被拒收。
 2. **每个特征一个点位。** `kind` 取 camera、display、button、port、speaker、microphone、light、sensor、vent、other 之一；`evidence` 用一句话写看到了什么。分不清是网孔还是纹理时降低 `confidence` 并写进 `unknowns`，不要硬判。
-3. **坐标系。** 每个点位落在一个面上，原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、同样以靠 back 的边为上边。`position` 是特征中心，`size` 是特征外接矩形的宽高，看不出大小时为 null。圆形产品（圆柱外壳）的 front、back、left、right 按从该方向看到的轮廓计，top、bottom 是圆面，坐标都取外接矩形，圆面以外的角落不会有点位。默认用 `normalized`（该面宽高的比例）；只有图里有标尺或已知尺寸时才能用 `mm`，并把 `scale_basis` 写成 `known_dimension` 或 `measured`。
+3. **只写像素，不做换算。** 所有坐标都在 `image_px` 这个像素网格里（原点在图片左上角，x 向右、y 向下）。每个面的四个角按从外侧看该面时的左上、右上、右下、左下写；top 面以靠 back 的边为上边，bottom 面从下方看、同样以靠 back 的边为上边。圆形产品（圆柱外壳）的 front、back、left、right 取从该方向看到的轮廓的外接框四角，top、bottom 是圆面。每个特征给图里的外接框 `box_px`，看不出大小时只给中心 `center_px`。面内比例由代码按该面四角的单应变换算出：特征越出所在面不超过面宽高的 2% 时截到面内，更多就拒收（多半是面的四角或所在面写错了）。不写比例、不写毫米——单张图没有可靠的尺度。
 4. **装饰与功能。** 饰圈、纹理、logo 这类后面不需要零件的特征标 `decorative: true`，`reaction_id` 写 null。功能特征能对上需求的，`reaction_id` 只能用输入里给的 id；对不上写 null。
 5. **不填槽位。** 读图输出没有 `slot_id`，槽位由下一步确定性配对。
 6. **看不清就说看不清。** 图里看不到产品外观、太暗、只有包装时，`outcome` 写 `unreadable` 并说明原因，不给任何点位或坐标系。

package/skills/abelien-appearance/schemas/points-reading-reply.v1.json

@@ -0,0 +1,100 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://git.abelien.cn/abelien/abelienharness/skills/abelien-appearance/schemas/points-reading-reply.v1.json",
+  "title": "abelien.appearance.points-reading-reply.v1",
+  "description": "读图节点（视觉模型）的回复：只报看到的东西，全部用图像像素写，不做任何换算。image_px 是下面所有坐标所在的像素网格（宽、高）；faces 是图里看得见的每个面和它的四个角（从外侧看该面的左上、右上、右下、左下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边）；每个特征给外接框 box_px，看不出大小时只给中心 center_px。由代码按每个面四角的单应变换换算成面内比例（appearance.points-reading.v1）并做越界检查（模型算术 PT-1/PT-2）。不填 slot_id。image_digest 原样抄输入图片引用的摘要。看不清时 outcome 写 unreadable 并说明原因，不给任何坐标。",
+  "type": "object",
+  "required": ["schema", "image_digest", "outcome", "faces", "points", "unknowns"],
+  "properties": {
+    "schema": { "const": "appearance.points-reading-reply.v1" },
+    "image_digest": { "$ref": "../../abelien-harness/contracts/schemas/ref.v1.json#/$defs/Digest" },
+    "outcome": { "description": "read：读出了结果（可以是 0 个点位）；unreadable：图看不清或不是产品外观图。", "enum": ["read", "unreadable"] },
+    "unreadable_reason": { "type": "string", "minLength": 1, "maxLength": 500, "pattern": "\\S" },
+    "image_px": {
+      "description": "坐标所在的像素网格：图片的宽和高（像素）。所有角点、外接框、中心都在这个网格里，原点在图片左上角，x 向右、y 向下。",
+      "type": "object",
+      "required": ["width", "height"],
+      "properties": { "width": { "type": "integer", "minimum": 1, "maximum": 100000 }, "height": { "type": "integer", "minimum": 1, "maximum": 100000 } },
+      "additionalProperties": false
+    },
+    "faces": {
+      "description": "图里看得见的面，每面一条；点位只能落在这些面上，看不到的面不写。",
+      "type": "array",
+      "maxItems": 6,
+      "items": { "$ref": "#/$defs/Face" }
+    },
+    "points": { "type": "array", "maxItems": 64, "items": { "$ref": "#/$defs/ReplyPoint" } },
+    "unknowns": {
+      "description": "读图时确定不了的事项，例如某个面不可见、某处是网孔还是纹理分不清。",
+      "type": "array",
+      "maxItems": 32,
+      "items": { "type": "string", "minLength": 1, "maxLength": 500, "pattern": "\\S" }
+    }
+  },
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "outcome": { "const": "read" } }, "required": ["outcome"] },
+      "then": { "required": ["image_px"], "properties": { "faces": { "minItems": 1 }, "unreadable_reason": false } }
+    },
+    {
+      "if": { "properties": { "outcome": { "const": "unreadable" } }, "required": ["outcome"] },
+      "then": { "required": ["unreadable_reason"], "properties": { "image_px": false, "faces": { "maxItems": 0 }, "points": { "maxItems": 0 } } }
+    }
+  ],
+  "$defs": {
+    "Pixel": {
+      "type": "object",
+      "required": ["x", "y"],
+      "properties": { "x": { "type": "number", "minimum": 0 }, "y": { "type": "number", "minimum": 0 } },
+      "additionalProperties": false
+    },
+    "Face": {
+      "type": "object",
+      "required": ["face", "corners_px"],
+      "properties": {
+        "face": { "enum": ["front", "back", "left", "right", "top", "bottom"] },
+        "corners_px": {
+          "description": "该面四个角在图像里的位置（从外侧看该面时的左上、右上、右下、左下）。圆柱外壳的 front/back/left/right 取从该方向看到的轮廓的外接框四角。",
+          "type": "object",
+          "required": ["top_left", "top_right", "bottom_right", "bottom_left"],
+          "properties": {
+            "top_left": { "$ref": "#/$defs/Pixel" },
+            "top_right": { "$ref": "#/$defs/Pixel" },
+            "bottom_right": { "$ref": "#/$defs/Pixel" },
+            "bottom_left": { "$ref": "#/$defs/Pixel" }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "ReplyPoint": {
+      "description": "模型看到的一个特征：所在面、图像像素里的外接框（看不出大小时只给中心），以及类别、置信度、装饰判断和能对上的需求 reaction_id。",
+      "type": "object",
+      "required": ["point_id", "kind", "face", "confidence", "decorative", "reaction_id", "evidence"],
+      "properties": {
+        "point_id": { "$ref": "../../abelien-harness/contracts/schemas/ref.v1.json#/$defs/Identifier" },
+        "kind": { "enum": ["camera", "display", "button", "port", "speaker", "microphone", "light", "sensor", "vent", "other"] },
+        "face": { "enum": ["front", "back", "left", "right", "top", "bottom"] },
+        "box_px": {
+          "description": "特征在图像里的外接框（像素）：left < right，top < bottom。",
+          "type": "object",
+          "required": ["left", "top", "right", "bottom"],
+          "properties": {
+            "left": { "type": "number", "minimum": 0 }, "top": { "type": "number", "minimum": 0 },
+            "right": { "type": "number", "minimum": 0 }, "bottom": { "type": "number", "minimum": 0 }
+          },
+          "additionalProperties": false
+        },
+        "center_px": { "description": "看不出特征大小时只给它的中心（像素）。", "$ref": "#/$defs/Pixel" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+        "decorative": { "description": "模型判断它只是装饰（饰圈、纹理、logo），后面不需要零件。", "type": "boolean" },
+        "reaction_id": { "description": "能对上的需求 reaction 的 id（只能用输入里给的 id）；对不上或装饰写 null。", "oneOf": [{ "type": "null" }, { "$ref": "../../abelien-harness/contracts/schemas/ref.v1.json#/$defs/Identifier" }] },
+        "evidence": { "description": "看到了什么，一句话（例如“正面左下圆形网孔”）。", "type": "string", "minLength": 1, "maxLength": 300, "pattern": "\\S" }
+      },
+      "additionalProperties": false,
+      "oneOf": [{ "required": ["box_px"] }, { "required": ["center_px"] }]
+    }
+  }
+}

package/skills/abelien-appearance/schemas/points-reading.v1.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://git.abelien.cn/abelien/abelienharness/skills/abelien-appearance/schemas/points-reading.v1.json",
   "title": "abelien.appearance.points-reading.v1",
-  "description": "读图节点（视觉模型）的输出：模型只报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 写 unreadable 并说明原因，不给任何坐标。规则见 references/points.md。",
+  "description": "冻结的读图结果：模型回复 points-reading-reply.v1（图像像素里的面四角与特征外接框）由读图节点定稿用代码按单应变换换算成面内比例后存成本形状，模型不写比例或毫米（模型算术 PT-1/PT-2）。报告图上看到的开孔、窗口、按键、接口等特征及其所在面、位置、尺寸、置信度、装饰判断，以及能对上的需求 reaction_id；不填 slot_id——槽位由 appearance.points 按 reaction → 槽位 → 分类确定性配对。image_digest 必须等于本次输入图片引用的摘要。看不清时 outcome 为 unreadable，不带任何坐标。规则见 references/points.md。",
   "type": "object",
   "required": ["schema", "image_digest", "outcome", "visible_faces", "coordinate_frame", "points", "unknowns"],
   "properties": {
@@ -36,7 +36,11 @@
       "if": { "properties": { "outcome": { "const": "read" } }, "required": ["outcome"] },
       "then": {
         "properties": {
-          "coordinate_frame": { "type": "object" },
+          "coordinate_frame": {
+            "description": "读图换算后的坐标系恒为面内比例：原点在该面左上角，scale_basis none。",
+            "type": "object",
+            "properties": { "unit": { "const": "normalized" }, "origin": { "const": "face_top_left" }, "scale_basis": { "const": "none" } }
+          },
           "visible_faces": { "minItems": 1 },
           "unreadable_reason": false
         }
@@ -52,7 +56,7 @@
   ],
   "$defs": {
     "ReadingPoint": {
-      "description": "模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。unit=normalized 时为该面宽高的比例。",
+      "description": "模型看到的一个特征。position 是特征中心，size 是特征外接矩形的宽高（看不出大小时为 null），二者都在所在面的坐标系里：原点在该面左上角（从外侧看），x 向右、y 向下；top 面以靠 back 的边为上边，bottom 面从下方看、也以靠 back 的边为上边。值是该面宽高的比例，由代码从模型给的像素外接框与面四角换算。",
       "type": "object",
       "required": ["point_id", "kind", "face", "position", "size", "confidence", "decorative", "reaction_id", "evidence"],
       "properties": {

package/skills/abelien-appearance/scripts/points.mjs

@@ -29,6 +29,99 @@ export const KIND_CATEGORIES = Object.freeze({
 const EPSILON = 1e-9;
 const invalidAt = (path, message) => failure("VALIDATION", `${path}: ${message}`, { errors: [{ path, message }] });
 
+// ---------- 读图回复（像素）→ 冻结读图（面内比例）：模型只给像素，换算由代码做（模型算术 PT-1/PT-2） ----------
+const CORNERS = Object.freeze(["top_left", "top_right", "bottom_right", "bottom_left"]);
+const UNIT_SQUARE = Object.freeze([[0, 0], [1, 0], [1, 1], [0, 1]]);
+/** 特征允许越出所在面的比例（面宽高的 2%，读图的感知误差）；越出更多就拒收，越出以内截到面内。 */
+export const FACE_OVERHANG = 0.02;
+/** 面四边形的最小面积（占图片面积的比例），再小就当作退化。 */
+export const MIN_FACE_AREA = 1e-4;
+const round6 = value => Math.round(value * 1e6) / 1e6 + 0;
+
+/** 8×8 线性方程组（部分主元高斯消元）；奇异时返回 null。 */
+function solve(a, b) {
+  const n = b.length, m = a.map((row, i) => [...row, b[i]]);
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let row = col + 1; row < n; row++) if (Math.abs(m[row][col]) > Math.abs(m[pivot][col])) pivot = row;
+    if (Math.abs(m[pivot][col]) < 1e-12) return null;
+    [m[col], m[pivot]] = [m[pivot], m[col]];
+    for (let row = 0; row < n; row++) {
+      if (row === col) continue;
+      const f = m[row][col] / m[col][col];
+      for (let k = col; k <= n; k++) m[row][k] -= f * m[col][k];
+    }
+  }
+  return m.map((row, i) => row[n] / row[i]);
+}
+
+/**
+ * 面四角（像素）→ 单位正方形的单应变换。坐标先按像素网格归一化以免病态；四边形必须按左上、右上、右下、左下顺时针排列、
+ * 凸、面积不小于图片的 MIN_FACE_AREA，否则抛 VALIDATION。返回把像素点映到面内比例的函数。
+ */
+function faceMapping(face, image, at) {
+  const src = CORNERS.map(key => [face.corners_px[key].x / image.width, face.corners_px[key].y / image.height]);
+  for (const key of CORNERS) { const { x, y } = face.corners_px[key];
+    if (x > image.width || y > image.height) throw invalidAt(`${at}/corners_px/${key}`, `corner (${x}, ${y}) is outside the ${image.width}×${image.height} pixel grid`); }
+  let area = 0;
+  for (let i = 0; i < 4; i++) {
+    const [p, q, r] = [src[i], src[(i + 1) % 4], src[(i + 2) % 4]];
+    const cross = (q[0] - p[0]) * (r[1] - q[1]) - (q[1] - p[1]) * (r[0] - q[0]);
+    if (cross <= 0) throw invalidAt(`${at}/corners_px`, "the four corners must be top_left, top_right, bottom_right, bottom_left of a convex face, in that clockwise order");
+    area += p[0] * q[1] - q[0] * p[1];
+  }
+  if (area / 2 < MIN_FACE_AREA) throw invalidAt(`${at}/corners_px`, "the face is degenerate (almost no area in the image)");
+  const a = [], b = [];
+  src.forEach(([x, y], i) => { const [u, v] = UNIT_SQUARE[i];
+    a.push([x, y, 1, 0, 0, 0, -u * x, -u * y]); b.push(u);
+    a.push([0, 0, 0, x, y, 1, -v * x, -v * y]); b.push(v); });
+  const h = solve(a, b);
+  if (!h) throw invalidAt(`${at}/corners_px`, "the face corners do not define a projective frame");
+  return ({ x, y }) => {
+    const [px, py] = [x / image.width, y / image.height], w = h[6] * px + h[7] * py + 1;
+    return [(h[0] * px + h[1] * py + h[2]) / w, (h[3] * px + h[4] * py + h[5]) / w];
+  };
+}
+
+/**
+ * 读图节点模型回复（points-reading-reply.v1）→ 冻结读图（points-reading.v1）：每个特征的外接框四角（或中心）按其所在面的单应变换
+ * 映到面内比例，取外接矩形为 position（中心）与 size；越出面 FACE_OVERHANG 以内截到面内，更多则拒收。像素必须在 image_px 网格内。
+ * 看不清（unreadable）原样转成不带坐标的读图，由调用方报 POINTS_UNREADABLE。
+ */
+export function readingFromPixels(reply) {
+  checkSchema("points-reading-reply.v1.json", reply, "points reading reply");
+  const base = { schema: "appearance.points-reading.v1", image_digest: reply.image_digest, outcome: reply.outcome };
+  if (reply.outcome === "unreadable")
+    return { ...base, unreadable_reason: reply.unreadable_reason, visible_faces: [], coordinate_frame: null, points: [], unknowns: [...reply.unknowns] };
+  const image = reply.image_px, maps = new Map();
+  reply.faces.forEach((face, i) => {
+    if (maps.has(face.face)) throw invalidAt(`/faces/${i}/face`, `face ${face.face} is listed twice`);
+    maps.set(face.face, faceMapping(face, image, `/faces/${i}`));
+  });
+  const points = reply.points.map((point, i) => {
+    const at = `/points/${i}`, map = maps.get(point.face);
+    if (!map) throw invalidAt(`${at}/face`, `face ${point.face} is not among faces; do not guess hidden faces`);
+    const pixels = point.box_px ? [{ x: point.box_px.left, y: point.box_px.top }, { x: point.box_px.right, y: point.box_px.top },
+      { x: point.box_px.right, y: point.box_px.bottom }, { x: point.box_px.left, y: point.box_px.bottom }] : [point.center_px];
+    if (point.box_px && (point.box_px.left >= point.box_px.right || point.box_px.top >= point.box_px.bottom))
+      throw invalidAt(`${at}/box_px`, "left must be below right and top below bottom");
+    for (const { x, y } of pixels) if (x > image.width || y > image.height)
+      throw invalidAt(`${at}/${point.box_px ? "box_px" : "center_px"}`, `(${x}, ${y}) is outside the ${image.width}×${image.height} pixel grid`);
+    const mapped = pixels.map(map), xs = mapped.map(p => p[0]), ys = mapped.map(p => p[1]);
+    const beyond = Math.max(-Math.min(...xs), Math.max(...xs) - 1, -Math.min(...ys), Math.max(...ys) - 1);
+    if (beyond > FACE_OVERHANG + EPSILON)
+      throw invalidAt(`${at}/${point.box_px ? "box_px" : "center_px"}`, `the feature lies ${round6(beyond)} of the face width or height beyond face ${point.face} (at most ${FACE_OVERHANG}); check the face corners or the face`);
+    const clamp = value => Math.min(1, Math.max(0, value));
+    const [x0, x1, y0, y1] = [Math.min(...xs), Math.max(...xs), Math.min(...ys), Math.max(...ys)].map(clamp);
+    const size = point.box_px ? { width: round6(x1 - x0), height: round6(y1 - y0) } : null;
+    if (size && (size.width <= 0 || size.height <= 0)) throw invalidAt(`${at}/box_px`, "the feature has no extent inside its face");
+    return { point_id: point.point_id, kind: point.kind, face: point.face, position: { x: round6((x0 + x1) / 2), y: round6((y0 + y1) / 2) }, size,
+      confidence: point.confidence, decorative: point.decorative, reaction_id: point.reaction_id, evidence: point.evidence };
+  });
+  return checkSchema("points-reading.v1.json", { ...base, visible_faces: reply.faces.map(face => face.face),
+    coordinate_frame: { unit: "normalized", origin: "face_top_left", scale_basis: "none" }, points, unknowns: [...reply.unknowns] }, "points reading");
+}
+
 /** 槽位的分类路径是否落在某个点位类别可承接的分类下。 */
 export function slotServesKind(slot, kind) {
   const path = slot.category_path.join("/");
@@ -36,7 +129,7 @@ export function slotServesKind(slot, kind) {
 }
 
 /**
- * 读图输出里 Schema 表达不了的数值与引用约束（与槽位无关）。读图节点提交时就校验，错误的读图不冻结；
+ * 读图输出里 Schema 表达不了的数值与引用约束（与槽位无关），含“中心不落在面的轮廓上”。读图节点提交时就校验，错误的读图不冻结；
  * 配对动作再用同一函数校验一次。读图写了 unreadable 时报 POINTS_UNREADABLE，由调用方走降级分支。
  */
 export function checkReading(reading, input) {
@@ -47,7 +140,6 @@ export function checkReading(reading, input) {
     throw failure("POINTS_UNREADABLE", `the model could not read the image: ${reading.unreadable_reason}`, { reason: reading.unreadable_reason });
   const reactions = new Set(input.reaction_ids);
   const seen = new Set();
-  const normalized = reading.coordinate_frame.unit === "normalized";
   reading.points.forEach((point, i) => {
     const at = `/reading/points/${i}`;
     if (seen.has(point.point_id)) throw invalidAt(`${at}/point_id`, `duplicate point_id ${point.point_id}`);
@@ -55,12 +147,14 @@ export function checkReading(reading, input) {
     if (!reading.visible_faces.includes(point.face)) throw invalidAt(`${at}/face`, `face ${point.face} is not among visible_faces; do not guess hidden faces`);
     if (point.reaction_id !== null && !reactions.has(point.reaction_id)) throw invalidAt(`${at}/reaction_id`, `reaction_id ${point.reaction_id} is not in the requirements`);
     if (point.decorative && point.reaction_id !== null) throw invalidAt(`${at}/reaction_id`, "a decorative point serves no reaction");
-    if (normalized) {
-      const { x, y } = point.position, w = point.size?.width ?? 0, h = point.size?.height ?? 0;
-      if (x > 1 || y > 1) throw invalidAt(`${at}/position`, "normalized coordinates must lie within the face (0..1)");
-      if (x - w / 2 < -EPSILON || x + w / 2 > 1 + EPSILON || y - h / 2 < -EPSILON || y + h / 2 > 1 + EPSILON)
-        throw invalidAt(`${at}/size`, "the feature extends beyond its face");
-    }
+    const { x, y } = point.position, w = point.size?.width ?? 0, h = point.size?.height ?? 0;
+    if (x > 1 || y > 1) throw invalidAt(`${at}/position`, "normalized coordinates must lie within the face (0..1)");
+    if (x - w / 2 < -EPSILON || x + w / 2 > 1 + EPSILON || y - h / 2 < -EPSILON || y + h / 2 > 1 + EPSILON)
+      throw invalidAt(`${at}/size`, "the feature extends beyond its face");
+    // 中心落在面的轮廓上（离边不到 FACE_OVERHANG）的特征跨在两个面之间，是边那一侧的面上的特征在轮廓处露出的一道。
+    // E2 r29 S1：正视图顶缘的一条亮带被读成正面点位，骨架要灯环贴正面、朝正面，装在顶面的灯环两条都做不到。
+    const edge = [["left", x], ["right", 1 - x], ["top", y], ["bottom", 1 - y]].find(([, gap]) => gap < FACE_OVERHANG - EPSILON);
+    if (edge) throw invalidAt(`${at}/position`, `${point.point_id} is centred on the ${edge[0]} edge of face ${point.face} (${round6(edge[1])} of the face from it): a feature seen only at a face's outline belongs to the face beyond that edge; give it on that face when it is visible, otherwise leave the point out and say what you saw in unknowns`);
   });
 }
 

package/skills/abelien-appearance/scripts/schemas.mjs

@@ -6,7 +6,7 @@ import { createValidator } from "../../abelien-harness/contracts/validate.mjs";
 import { failure } from "../../abelien-harness/scripts/web/common.mjs";
 
 export const SCHEMA_DIR = new URL("../schemas/", import.meta.url);
-export const OWN_SCHEMAS = Object.freeze(["points-reading.v1.json", "points-input.v1.json", "points-result.v1.json",
+export const OWN_SCHEMAS = Object.freeze(["points-reading.v1.json", "points-reading-reply.v1.json", "points-input.v1.json", "points-result.v1.json",
   "points-fallback-input.v1.json", "points-fallback-result.v1.json"]);
 
 let cached;

package/skills/abelien-clarify/SKILL.md

@@ -28,9 +28,15 @@ compatibility: 适用于 claude-code、hermes、pi 宿主
 需求只用以下结构；source 区分用户事实与系统假设：
 
 ```ts
-type Envelope =
-  | {shape: "box", max_mm: [number, number, number], min_mm?: [number, number, number], wall_mm?: {minimum: number, estimate?: number}}
-  | {shape: "cylinder", max_diameter_mm: number, max_height_mm: number, min_diameter_mm?: number, min_height_mm?: number, wall_mm?: {minimum: number, estimate?: number}};
+type Dimensions = {           // 尺寸只写原话引文和映射，毫米数由代码换算
+  shape: "box" | "cylinder",
+  bounds: {
+    axes: ("width" | "depth" | "height" | "diameter" | "radius" | "wall")[];  // 盒体 width/depth/height，圆柱 diameter 或 radius、height；wall 单独一项
+    bound: "max" | "min" | "exact" | "estimate";  // 尺寸用 max/min/exact，wall 用 min（保证壁厚）或 estimate（估算壁厚）
+    quote?: {text: string, index?: number, unit?: "um" | "mm" | "cm" | "m" | "in" | "mil"};  // 用户原话逐字摘录
+    choice?: {value: number, unit: "um" | "mm" | "cm" | "m" | "in" | "mil", basis: string};   // 仅 source=system 的估算
+  }[];
+};
 type Intent = {
   kind: "restore" | "create" | "modify";
   source: "user" | "system";
@@ -42,7 +48,7 @@ Requirements = {
   context?: {text: string, source: "user" | "system"};
   intent?: Intent;       // 交回的 result 必须带；只有历史需求可能缺
   reaction: {id: string, text: string, source: "user" | "system"}[];
-  limits: {id: string, text: string, source: "user" | "system", strength: "hard" | "preference", envelope?: Envelope, network?: "offline" | "no_cloud"}[];
+  limits: {id: string, text: string, source: "user" | "system", strength: "hard" | "preference", dimensions?: Dimensions, network?: "offline" | "no_cloud"}[];  // 不写 envelope
 }
 ```
 
@@ -52,7 +58,7 @@ Requirements = {
 
 纯咨询只返回 note；明确修改同时夹带咨询时，result 只承载明确修改，note 回应咨询或说明待核对的能力。“这样可以，颜色改蓝”先交修改，不把前半句当成新版本的确认。“改回去”必须能定位旧内容；否则保留现状并澄清对象。
 
-**2. 整理需求。** context 记录落点、使用者与影响选择的场景；reaction 记录完整的事件或状态与反应，保留对象、方向、持续性和时间；limits 记录明确限制或偏好，数值保留单位。明确的尺寸、运动方式等限制写 limits；可确定为盒体或圆柱的尺寸另附同一 limits 项的 envelope，原 text/id/source/strength 保留，不从正文猜造工程数据。用户原话限制联网时，在同一 limits 项另附 network：完全不能联网（“不能联网”“必须离线”）写 offline，可以连手机或本地网络但不上云、数据不出设备（“不上云”“不用云端服务”）写 network=no_cloud；原话写进 text，没说清是哪一种就按原话登记而不附 network、必要时再问，不从隐私或成本推断。hard 的 network 让后续算法只能在端侧实现，由代码强制。几点、话术和停止规则写进对应 reaction；颜色、灯光等外观配置按用户表达登记到 limits，保留偏好或硬要求的原强度。
+**2. 整理需求。** context 记录落点、使用者与影响选择的场景；reaction 记录完整的事件或状态与反应，保留对象、方向、持续性和时间；limits 记录明确限制或偏好，数值保留单位。明确的尺寸、运动方式等限制写 limits；可确定为盒体或圆柱的尺寸另附同一 limits 项的 dimensions，原 text/id/source/strength 保留，不从正文猜造工程数据。用户原话限制联网时，在同一 limits 项另附 network：完全不能联网（“不能联网”“必须离线”）写 offline，可以连手机或本地网络但不上云、数据不出设备（“不上云”“不用云端服务”）写 network=no_cloud；原话写进 text，没说清是哪一种就按原话登记而不附 network、必要时再问，不从隐私或成本推断。hard 的 network 让后续算法只能在端侧实现，由代码强制。几点、话术和停止规则写进对应 reaction；颜色、灯光等外观配置按用户表达登记到 limits，保留偏好或硬要求的原强度。
 
 展示摘要由当前需求生成：一个放在 [落点] 的东西，在 [事件或状态] 下，做出 [可感知的输出]。摘要不代替完整 reaction；标签只用于分类初筛。
 
@@ -74,7 +80,16 @@ ID 是不透明标识，不能按数组位置重新编号；新 ID 不得与现
 
 能说明拟探索行为的落点、事件／状态和输出，且不存在阻塞这次选择的歧义，就可以交给总控推进。其他行为与未定项继续保留，不生成全局 ready / complete 状态；“可以开始搜索”不代表需求已满足。一个假设会改变用户明确要求、替换保留的底座或突破已有授权时，不能用“可撤销”绕过用户决定：首版之前改走不触碰这些要求的默认方向，把该决定留到首版之后；只有符合“提问时机”例外时才在首版之前提问。
 
-尺寸是推导变量，从落点与行为提出可见、可修改的范围；可提出 source=system 的可见估算，必须说明依据且不得冒充用户确认、实测或图片比例尺。envelope 所有尺寸用毫米有限正数，范围最小值不超过最大值；精确值可令 min=max。只使用匹配 shape 的字段，不混用盒体和圆柱字段。wall_mm.minimum 是明确保证的非负壁厚下界，未提供 wall_mm 时按 0；estimate 不得小于 minimum，只参与风险提示，不硬拒绝。保证下界扣除后最大腔体各轴必须为正；范围较小端或估算壁厚不可行仍保留供风险评审。只有 source=user 且 strength=hard 的最大范围具有硬筛选权限；系统估算和偏好不能硬拒绝。未知形状不填写 envelope，不编造 box。
+尺寸是推导变量，从落点与行为提出可见、可修改的范围；可提出 source=system 的可见估算，必须说明依据且不得冒充用户确认、实测或图片比例尺。
+
+**尺寸只引原话，不算数。** dimensions 的每个边界给出数从哪来、管哪个轴、是上限还是下限，毫米数由代码换算：不写 envelope，不把英寸、厘米换成毫米，不把半径乘成直径，也不写任何算出来的数。
+
+- 用户说的尺寸用 quote：text 是本轮用户消息或卡片答复里的逐字摘录（例如“宽 10 厘米”“直径 4 英寸”“半径 4cm”），代码核对它确实出现在原话里，不在就拒收（`CLARIFY_QUOTE_NOT_IN_MESSAGE`）。摘录里不止一个数时用 index（从 0 起数所有的数）指出取第几个；那个数自己没写单位、单位写在句末共用时（“长 100、宽 80、高 60 毫米”里的 100），unit 填原话里那个单位，数自己写了单位就不填。“10 厘米见方”一条写 width、depth、height 三个轴；“半径”写 radius，代码乘 2。
+- 系统估算用 choice：value 与 unit 照你的选择写，basis 写依据；只能用在 source=system 的限制上（`CLARIFY_CHOICE_ON_USER_LIMIT`），换算结果不带硬筛选权限。
+- 盒体要有 width、depth、height 三个上限（max 或 exact），圆柱要有直径（diameter 或 radius）和 height 的上限；凑不齐就只写 text，不写 dimensions，也不编一个 box。盒体下限三个轴一起给。同一轴同一边界只写一次。
+- wall 的 min 是明确保证的非负壁厚下界，没写时按 0；estimate 只参与风险提示，不硬拒绝。代码换算后检查下限不超过上限、保证壁厚扣除后腔体各轴为正，不成立就拒收（`CLARIFY_ENVELOPE_INVALID`）；范围较小端或估算壁厚不可行仍保留供风险评审。
+- 修改时沿用 current_requirements 里未改动的边界原样照抄（不抄它的 envelope），这些边界不再对照本轮原话；新写或改动的边界都要对照本轮原话。
+- 只有 source=user 且 strength=hard 的最大范围具有硬筛选权限；系统估算和偏好不能硬拒绝。未知形状不填写 dimensions。
 
 没有明确尺寸要求，不主动索要尺寸；“必须塞进这个格子”缺尺寸且无法合理默认时才问，这正是首版之前允许提问的例外情形。品类默认和器件分类用输入中的数据，不在 skill 固化型号、价位或默认值表。工程资料缺失交给总控补充，不让用户提供接口、料号或测试证明。
 
@@ -106,8 +121,9 @@ python3 scripts/check_result.py - --current current-requirements.json
 
 `proposal.json` 是上述 SkillResult；`current-requirements.json` 是当前 Requirements 本身，不是整个草稿。脚本只读输入、向标准输出写诊断，不覆盖文件。返回 `valid / errors / changes / review`；这份报告供修正与复核，**不是 SkillResult，也不是工程 Check**。退出码 0 表示结构合法，1 表示契约错误，2 表示文件或 JSON 读取失败。
 
-- 检查字段、类型、来源、限制强度、ID 唯一性、intent 结构及题目数量；交回的 result 缺 intent 即为错误，当前需求可以是缺 intent 的历史版本；新增／修改系统假设（含 source=system 的 intent）和撤回项须有 note。
+- 检查字段、类型、来源、限制强度、ID 唯一性、intent 结构、dimensions 的轴与上下限映射及题目数量；回复里出现 envelope 即为错误；交回的 result 缺 intent 即为错误，当前需求可以是缺 intent 的历史版本；新增／修改系统假设（含 source=system 的 intent）和撤回项须有 note。
 - 提供当前需求时按稳定 ID 列出前后差异，提醒复核删除、来源和硬要求变化；保留前后值，不自动修复或采用。
+- 脚本不核对引文是否在原话里、不换算单位，这两步由运行层定稿完成。
 - 先修正 errors，再依据原话核对 changes / review。`valid=true` 不证明理解正确、得到授权、没有阻塞问题或可以确认；脚本不会验证原话真假、给问题排序或判断工程可行性。
 
 ## 边界

package/skills/abelien-clarify/references/examples.md

@@ -116,8 +116,19 @@
 
 ## 结构化尺寸与可见估算
 
-用户说“必须放进长 100、宽 80、高 60 毫米的格子”，保留原 limit 的 id/text/source=user/strength=hard，并附 `envelope: {"shape":"box","max_mm":[100,80,60]}`。未保证壁厚时不补一个经验下界；省略 wall_mm 相当于保证下界 0。用户修改高度时延续同一 ID 并保留其他要求。
+用户说“必须放进长 100、宽 80、高 60 毫米的格子”，保留原 limit 的 id/text/source=user/strength=hard，并附
+
+```json
+{"shape":"box","bounds":[
+  {"axes":["width"],"bound":"max","quote":{"text":"长 100、宽 80、高 60 毫米","index":0,"unit":"mm"}},
+  {"axes":["depth"],"bound":"max","quote":{"text":"长 100、宽 80、高 60 毫米","index":1,"unit":"mm"}},
+  {"axes":["height"],"bound":"max","quote":{"text":"长 100、宽 80、高 60 毫米","index":2}}]}
+```
+
+作为 `dimensions`。100 和 80 自己没写单位，unit 填句末共用的“毫米”；60 自己写了单位，不填 unit。代码核对摘录出现在本轮原话里，换算出 `envelope.max_mm` 为 100、80、60，回复里不写 envelope。未保证壁厚时不补一个经验下界；省略 wall 相当于保证下界 0。用户之后只改高度时延续同一 ID，宽、深两条边界原样照抄（不再对照新消息），只有新的高度引文要出现在新消息里。
+
+用户说“直径 4 英寸、高 10 厘米以内”时写 `{"shape":"cylinder","bounds":[{"axes":["diameter"],"bound":"max","quote":{"text":"直径 4 英寸"}},{"axes":["height"],"bound":"max","quote":{"text":"高 10 厘米"}}]}`，代码换算成 101.6 与 100 毫米；说“半径 4cm”时 axes 写 radius，代码乘 2 得到直径 80 毫米。不要自己换算后再写成毫米的引文。
 
 仅从“桌面设备”提出大约 80–120 毫米的探索范围时，应是 source=system 的建议并在 note 写明依据与可修改性；不能让用户确认方案、图片看起来相似或系统默认升级为实测或 user。估算壁厚比容器大只说明估算需要修订，不能用来硬剔除器件。
 
-圆柱外形使用 `{"shape":"cylinder","max_diameter_mm":80,"max_height_mm":120,"wall_mm":{"minimum":0,"estimate":2}}`。保留原话来源，不混入 box.max_mm。完整快照和 ID 差分均须保留 envelope；脚本 valid 只证明字段合法，不证明可装下或得到授权。
+系统估算的圆柱外形写在 source=system 的限制里，每个边界用 choice，例如 `{"axes":["diameter"],"bound":"max","choice":{"value":80,"unit":"mm","basis":"桌面摆件常见直径"}}`，壁厚估算写 `{"axes":["wall"],"bound":"estimate","choice":{"value":2,"unit":"mm","basis":"常见注塑壁厚"}}`。保留原话来源，不混入盒体的轴。完整快照和 ID 差分均须保留 dimensions；脚本 valid 只证明字段合法，不证明引文在原话里、可装下或得到授权。

package/skills/abelien-clarify/references/runtime-contract.md

@@ -1,9 +1,11 @@
 # Runtime 读取 clarify 契约
 
-本包增加只读 `domain.json`，让正式 task-view 读取安装的 `SKILL.md` 和 `schemas/skill-result.v1.json`。`actions:[]` 只使 Schema 参与跨包解析；clarify 不注册工具、不写草稿、不发布卡片。
+本包增加只读 `domain.json`，让正式 task-view 读取安装的 `SKILL.md`、模型回复契约 `schemas/skill-reply.v1.json` 和定稿后的完整快照契约 `schemas/skill-result.v1.json`。`actions:[]` 只使 Schema 参与跨包解析；clarify 不注册工具、不写草稿、不发布卡片。
 
-`scripts/validate-result.mjs` 是 Node runtime 使用的只读校验入口，与现有 Python `scripts/check_result.py` 的 `valid` 和稳定 ID 差异语义一致。JSON Schema 检查形状、来源、意图、选项上限；Envelope 算术复用硬件包的 `validateEnvelope`。系统假设新增/修改及撤回要求 note。校验成功只代表契约成立，不证明自然语言理解、用户授权或工程可行性。
+`scripts/validate-result.mjs` 是 Node runtime 使用的只读校验入口，与现有 Python `scripts/check_result.py` 的 `valid` 和稳定 ID 差异语义一致。JSON Schema 检查形状、来源、意图、选项上限。
 
-`creation.start` 的受信 finalizer 另检查空需求不得启动、问题必须说明当前阻塞；这是作品入口准入，不改变通用 clarify 输出契约。Python 与 Node 的差异报告语言可以不同；[定向回归](../../../test/creation-intake-runtime.test.mjs) 对有效性和 ID 差异逐项比对，覆盖来源、删除、跨组重复 ID、问题数量、毫米范围和壁厚边界。
+尺寸（模型算术 CLR-1）：模型回复的 limits 只写 `dimensions`（用户原话引文或系统估算的选择、轴、上下限），不写 `envelope`。[scripts/dimensions.mjs](../scripts/dimensions.mjs) 的 `completeRequirements` 在定稿时核对新写或改动的引文逐字出现在本轮用户消息或卡片答复里（NFKC 规范化后比对；与当前需求同 ID 原样沿用的边界不再核对），用共用求值核心（`abelien-harness/scripts/calc`）取量、换算单位、半径乘 2，得到与硬件包 `validateEnvelope` 同形的 `envelope`。存下的需求里 envelope 与 dimensions 同在同缺，`validateRequirements` 每次按 dimensions 重新换算并要求与 envelope 完全一致。拒收码是 `CLARIFY_DIMENSION_CODES`，包在 `TASK_REPLY_INVALID` 的 `details.issues[].code` 里：`CLARIFY_ENVELOPE_FROM_MODEL`、`CLARIFY_QUOTE_NOT_IN_MESSAGE`、`CLARIFY_QUOTE_NO_LENGTH`、`CLARIFY_QUOTE_UNIT`、`CLARIFY_CHOICE_ON_USER_LIMIT`、`CLARIFY_DIMENSIONS_MAPPING`、`CLARIFY_ENVELOPE_INVALID`、`CLARIFY_ENVELOPE_MISMATCH`。Python 脚本只查结构，不查引文出处、不换算。系统假设新增/修改及撤回要求 note。校验成功只代表契约成立，不证明自然语言理解、用户授权或工程可行性。
+
+`creation.start` 的受信 finalizer 另检查空需求不得启动、问题必须说明当前阻塞；这是作品入口准入，不改变通用 clarify 输出契约。Python 与 Node 的差异报告语言可以不同；[定向回归](../../../test/creation-intake-runtime.test.mjs) 对有效性和 ID 差异逐项比对，覆盖来源、删除、跨组重复 ID、问题数量和尺寸映射；引文出处与换算的回归在 [clarify-dimensions.test.mjs](../../../test/clarify-dimensions.test.mjs)。
 
 详情见 [workspace 的入口与答复绑定](../../abelien-workspace/references/creation-intake.md)。安装时保留声明的 harness 与 hardware 依赖；生产 Node 路径不需要启动 Python。