abelien-harness 0.20.1 → 0.22.0

package/skills/abelien-harness/runtime/task-view/retention.mjs

@@ -0,0 +1,39 @@
+// Frozen node data is exact. Only declared, durably stored tool results may become read-back references.
+// This contract is runtime-owned; text in refs, replies or summaries never changes its permissions.
+import { runtimeError } from '../errors.mjs';
+import { STEP_TOOL_RESULT } from '../model-actions.mjs';
+
+export const CONTEXT_RETENTION_SCHEMA = 'abelien.node-context-retention.v1';
+export const CONTEXT_RETENTION_REQUIRED = Object.freeze([
+  'schema', 'reply_to', 'flow', 'target_revision_ref', 'attempt', 'goal', 'instruction', 'refs', 'skills',
+  'actions', 'output', 'work', 'reply_without_model', 'correction', 'attempts', 'budget',
+]);
+export function defaultContextRetention() {
+  return { schema: CONTEXT_RETENTION_SCHEMA, required: [...CONTEXT_RETENTION_REQUIRED],
+    history: { reasoning: 'summarize', assistant_text: 'exact', tool_results: { default: 'exact', by_action: {} } } };
+}
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const keys = (value, expected) => object(value) && Object.keys(value).length === expected.length && expected.every(key => Object.hasOwn(value, key));
+/** Validate after action bindings freeze, and again when assembling an old frozen node. Never consult current package declarations. */
+export function nodeContextRetention(node, { code = 'FLOW_INVALID' } = {}) {
+  const declared = node.task?.context_retention;
+  if (declared === undefined) return defaultContextRetention();
+  const fail = detail => { throw runtimeError(code, `model ${node.id} context_retention: ${detail}`, { node: node.id }); };
+  if (!keys(declared, ['schema', 'required', 'history']) || declared.schema !== CONTEXT_RETENTION_SCHEMA) fail('unsupported contract or fields');
+  if (!Array.isArray(declared.required) || declared.required.length !== CONTEXT_RETENTION_REQUIRED.length
+    || new Set(declared.required).size !== declared.required.length || !CONTEXT_RETENTION_REQUIRED.every(key => declared.required.includes(key))) fail('all task-view data fields must remain exact');
+  const h = declared.history;
+  if (!keys(h, ['reasoning', 'assistant_text', 'tool_results']) || h.reasoning !== 'summarize' || h.assistant_text !== 'exact') fail('reasoning must be summarize and assistant_text exact');
+  const results = h.tool_results;
+  if (!keys(results, ['default', 'by_action']) || results.default !== 'exact' || !object(results.by_action)) fail('tool results default must be exact with an action policy object');
+  const by_action = {};
+  for (const [id, policy] of Object.entries(results.by_action).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!['exact', 'reference'].includes(policy)) fail(`unsupported tool result policy for ${id}`);
+    if (!Array.isArray(node.task?.actions) || !node.task.actions.includes(id) || !node.model_action_bindings?.[id]) fail(`action ${id} is not declared and frozen`);
+    if (policy === 'reference' && !node.model_action_bindings?.[STEP_TOOL_RESULT]) fail(`action ${id} reference requires frozen ${STEP_TOOL_RESULT}`);
+    Object.defineProperty(by_action, id, { value: policy, enumerable: true, writable: true, configurable: true });
+  }
+  const value = defaultContextRetention();
+  value.history.tool_results.by_action = by_action;
+  return value;
+}

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.20.1";
+const FALLBACK_VERSION = "0.22.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/domain.json

@@ -4,6 +4,7 @@
   "kind": "agent",
   "description": "结构域包（Agent 受众）：骨架子流程的确定性动作（冻结布局请求、布局校验、换件条件）与 CAD 子流程 user-journey-cad：硬件前置模块按冻结选型修订与骨架生成硬件几何（模型只拿 ID）、装配源码并检查“只拿 ID”、结果检查与失败归因（只返工出错模块）。布局提案与自定义件模块由模型完成；CAD 预检与构建是宿主 Studio 工具（cad.precheck、cad.build），执行 CAD 的 Structure Worker 在宿主包",
   "requires": [
+    "abelien-appearance",
     "abelien-clarify",
     "abelien-hardware",
     "abelien-harness",

package/skills/abelien-structure/flows/user-journey-cad.json

@@ -1,8 +1,11 @@
 {
-  "input_schema": {"package": "abelien-structure", "schema": "schemas/cad-flow-input.v1.json"},
+  "input_schema": {
+    "package": "abelien-structure",
+    "schema": "schemas/cad-flow-input.v1.json"
+  },
   "schema": "abelien.runtime-flow.v2",
   "flow_id": "user-journey-cad",
-  "version": "7",
+  "version": "8",
   "description": "CAD v2 子流程：宿主先按 component_id 解析组件 CAD（目录库采购件），再冻结硬件前置几何与视觉目标，模型只写自定义件。产物数据边调度装配、预检、构建与检查；corrects 有界返工只重写归因模块。换视觉、需求或外形锁定时重写自定义件，换件只重写服务于变化硬件的模块。输入见 cad-flow-input.v1.json。",
   "inputs": [
     "prelude",
@@ -171,6 +174,35 @@
           "module": "scripts/cad.mjs",
           "view": "cadModulesView",
           "finalize": "cadModulesFinalize"
+        },
+        "context_retention": {
+          "schema": "abelien.node-context-retention.v1",
+          "required": [
+            "schema",
+            "reply_to",
+            "flow",
+            "target_revision_ref",
+            "attempt",
+            "goal",
+            "instruction",
+            "refs",
+            "skills",
+            "actions",
+            "output",
+            "work",
+            "reply_without_model",
+            "correction",
+            "attempts",
+            "budget"
+          ],
+          "history": {
+            "reasoning": "summarize",
+            "assistant_text": "exact",
+            "tool_results": {
+              "default": "exact",
+              "by_action": {}
+            }
+          }
         }
       }
     },

package/skills/abelien-structure/references/skeleton.md

@@ -6,6 +6,7 @@
 
 - 选型修订就绪后开始；点位产物 ready 或 degraded 都可以，读图失败不阻塞骨架。
 - 输入：冻结的选型修订（槽位、BOM 行、选中零件的真实尺寸）、点位产物、当前图片引用、外壳（盒形或圆柱形外包络、统一壁厚、外形是否锁定、未锁定时的外观容差）和本次检查容差；有拆机、官方结构或同类整机资料时一并给出。
+- create/modify 还通过共享的 `work.images` 提供同版概念原图与内部空间视图，辅助部件连接、朝向、遮挡和空间判断；内部图标明 `generated_inference`，不替代组件真实尺寸或正式布局检查。CAD 从既有 appearance baseline 的 `spatial_views` 接收同一集合；不新增一套 CAD 输入协议。
 - 外壳尺寸由布局请求按来源生成（过渡口径，appearance 还不产出外观容差）：`shell.basis` 为 `reference_product` 时只给轴向映射（盒形 x、y、z，圆柱 diameter、height 取参考尺寸的 width、depth、height），外壳固定、不带容差；为 `user_hard_limit` 时给 `limit_id`（`shell_sources` 里那条用户硬尺寸，盒形包络另给 `axes` 取包络的哪一维），包络（各轴上下限、壁厚下限）是上下限，各轴尺寸是提案方的选择，越界阻断、不带容差，上下限相等的轴写 `null` 由请求填值；只有图片可依时才用 `appearance_target`，给出各轴尺寸，外形未锁定时另给外观容差（带依据的估算），用它判定的外形检查注明“容差为估算”并记进未知项。每个数要么是选择，写 `{value, choice}`（数加依据），要么是派生，写 `Formula`（至少一个操作数用 `input` 指针取任务视图冻结输入（指针从任务视图 `work` 的根写起，例如 `/fixed_input/shell_sources/user_hard_limit/0/envelope/max_height_mm`）或用 `result` 取本步工具结果，例如取硬尺寸上限、锚定尺寸乘以量出的比例）；只有 choice 操作数的 `Formula` 按选择写。出处记在请求的 `shell_source`。其余要算的数先用 `calc.evaluate`，不心算。
 - 不做按品类的骨架模板：同类整机资料只借分区方式、上下顺序和必备件，每个作品按自己的外观目标、需求和已选硬件推导，不照抄坐标。
 - 图鉴参考记录以 `source: "catalog"` 给出，带 `catalog_ref`（记录的发布版、摘要和借用的分区／基准面）。借的分区在骨架里用 `architecture_ref_id` 指回它；记录里的高度比例只作合理性对照（例如同类机电池都在底部、本方案放到了顶部），基准面高度仍按已选件的真实尺寸加间隙推导。

package/skills/abelien-structure/scripts/cad.mjs

@@ -5,6 +5,7 @@
 // 返工不在这里推进：失败经流程的 corrects 回到建模节点，任务视图钩子（cadModulesView）按归因只列出错模块及依赖它的模块，
 // 其余模块按摘要原样沿用（cadModulesFinalize 补全回复并记下沿用来源）。布局规划不在 CAD 里重复：骨架已经过 structure.layout-check。
 import { createHash } from "node:crypto";
+import { spatialImages } from "../../abelien-appearance/scripts/spatial-images.mjs";
 import { digest, canonical } from "../../abelien-harness/contracts/index.mjs";
 import { failure } from "../../abelien-harness/scripts/web/common.mjs";
 import { sliceCodePoints, storableText } from "../../abelien-harness/scripts/web/safe-text.mjs";
@@ -1120,16 +1121,16 @@ function productTargets(input, prelude) {
  */
 export function cadModulesView(ctx) {
   checkSchema("cad-flow-input.v1.json", ctx.run.input, "user-journey-cad input");
-  const image = ctx.run.input.appearance_baseline.data.image;
+  const pictures = spatialImages({ appearance_views: ctx.run.input.appearance_baseline.data.spatial_views ? { data: ctx.run.input.appearance_baseline.data.spatial_views } : null }, ctx.run.input.appearance_baseline.data.image);
   const prelude = ctx.refs.prelude.data;
   const targets = { ...productTargets(ctx.run.input, prelude), shape_lock: shapeLockOf(ctx.run.input) };
   const previous = latest(ctx.history("modules"), item => item.state === "succeeded" && item.seq < ctx.current.seq);
-  if (!previous) return { work: { image, ...targets, mode: "initial", write: "all", attribution: null, changed_hardware: null, frozen: [], previous: [], dependencies: [] } };
+  if (!previous) return { work: { ...pictures, ...targets, mode: "initial", write: "all", attribution: null, changed_hardware: null, frozen: [], previous: [], dependencies: [] } };
   const set = previous.output;
   const summary = module => ({ module_id: module.module_id, purpose: module.purpose, parts: module.parts, serves: module.serves, depends_on: module.depends_on, digest: module.digest });
   // 新的明确实例声明可删掉旧件；旧模块保留历史，不强迫模型为已删除实例再写一个占位件。
   if (!same(unique(set.modules.flatMap(module => module.parts)).sort(), targets.custom_occurrence_ids))
-    return { work: { image, ...targets, mode: "initial", write: "all", attribution: null, changed_hardware: null,
+    return { work: { ...pictures, ...targets, mode: "initial", write: "all", attribution: null, changed_hardware: null,
       changed_target: ["appearance_baseline"], frozen: [], previous: set.modules.map(module => ({ ...summary(module), source: module.source })), dependencies: [] } };
   const before = set.prelude_digest === prelude.prelude_digest ? prelude
     : latest(ctx.history("prelude"), item => item.output?.prelude_digest === set.prelude_digest)?.output ?? null;
@@ -1148,7 +1149,7 @@ export function cadModulesView(ctx) {
   const mode = attribution ? "rework" : changed === null || changed.length ? "revise" : write.length ? "revise" : "reuse";
   return {
     work: {
-      image, ...targets, mode, write, attribution, changed_hardware: changed, changed_target: changedTarget,
+      ...pictures, ...targets, mode, write, attribution, changed_hardware: changed, changed_target: changedTarget,
       frozen: set.modules.filter(module => !pending.has(module.module_id)).map(summary),
       previous: set.modules.filter(module => pending.has(module.module_id)).map(module => ({ ...summary(module), source: module.source })),
       dependencies: set.modules.filter(module => needed.has(module.module_id)).map(module => ({ module_id: module.module_id, source: module.source })),

package/skills/abelien-workspace/actions/image.generate.json

@@ -1,9 +1,9 @@
 {
   "action_id": "image.generate",
-  "contract_version": 1,
+  "contract_version": 2,
   "description": "生成概念图：等待已结算回执并冻结外观参考；可能收费，未知或在途的调用只按原身份恢复",
   "audience": "agent",
-  "input_schema": "schemas/host-tools.v1.json#/$defs/NoInput",
+  "input_schema": "schemas/image-task.v1.json",
   "output_schema": "schemas/host-tools.v1.json#/$defs/HostToolResult",
   "permissions": [
     "image.generate",

package/skills/abelien-workspace/actions/step.tool-result.json

@@ -1,7 +1,7 @@
 {
   "action_id": "step.tool-result",
   "contract_version": 1,
-  "description": "按 result_id 回读本模型步骤此前的一条工具结果（同一执行实例、同一任务视图版本），按字符分页（start/length，sha256 为全文摘要）；用于取回被压缩成摘要（compacted）的结果，不回 already_read，回读的字节再次计入本步骤的读取预算",
+  "description": "按 result_id 回读本模型步骤此前的原工具结果（同一执行实例、同一任务视图）。无 pointer 时保留原全文字符分页与 sha256 校验；pointer 模式须同时提供原全文 sha256 和选中值 value_sha256，回读原值 canonical JSON 的 UTF-16 分页，不重跑原工具。读取字节再次计入本步骤预算，不回 already_read。",
   "audience": "agent",
   "input_schema": "schemas/host-tools.v1.json#/$defs/StepToolResult",
   "output_schema": "schemas/host-tools.v1.json#/$defs/StepToolResultPage",