abelien-harness 0.8.0 → 0.9.0

package/skills/abelien-workspace/assets/journey-stage-plan.json

@@ -1,7 +1,7 @@
 {
   "schema": "abelien.journey-stage-plan.v1",
-  "plan_version": "2026-10-12.6",
-  "description": "按意图的作品旅程阶段计划。orders 是自动推进的主线；side 阶段由宿主守卫按真实结果触发。每个阶段的 directives 是领域规则（宿主中立），宿主把它们附在自己的执行说明（工具名、字段）之后，不改写、不删减。旅程规则的唯一正文是 references/user-journey.md，本计划是其机读派生：orders 对应 A1 通过之后到交付首版（§2.4、§5），side 对应首版前后由真实结果触发的旁路（§5.3、§6、§7）；两处不一致时以正文为准，改正文后同步本计划并升 plan_version。",
+  "plan_version": "2026-10-14.1",
+  "description": "按意图的作品旅程阶段计划。orders 是自动推进的主线；side 阶段由宿主守卫按真实结果触发。每个阶段的 directives 是领域规则（宿主中立），宿主把它们附在自己的执行说明（工具名、字段）之后，不改写、不删减。每个阶段的 actions 是该阶段允许的动作，取自 action_catalog（宿主中立的动作目录），按意图不同时写在 action_variants；宿主把动作映射为自己的工具，自动阶段只放行这些工具和宿主自己的只读工具，不另维护工具白名单。旅程规则的唯一正文是 references/user-journey.md，本计划是其机读派生：orders 对应 A1 通过之后到交付首版（§2.4、§5），side 对应首版前后由真实结果触发的旁路（§5.3、§6、§7）；两处不一致时以正文为准，改正文后同步本计划并升 plan_version。",
   "artifacts": ["reference_final", "concept_image", "hardware", "appearance_baseline", "cad_candidate", "review"],
   "orders": {
     "create": ["reference", "concept", "hardware", "real_image", "cad", "review"],
@@ -19,6 +19,24 @@
     "review": "review"
   },
   "side": ["hardware_reselect", "hardware_decision", "fallback", "repair", "questions"],
+  "action_catalog": {
+    "reference.research": "收集识别、拆解资料或相似产品的检索证据",
+    "reference.page": "读取已收集页面的正文，挑选逐字引用",
+    "reference.finalize": "提交识别或借用判断，定稿参考证据",
+    "studio.prepare": "保存外观目标，冻结本次创建的来源",
+    "image.generate": "生成概念图",
+    "image.import": "把识别出的真实产品图（没有时用用户上传图）结算为外观基准图",
+    "component.search": "检索组件库",
+    "hardware.guide": "按分类读取硬件选型指引",
+    "hardware.wiki": "读取候选型号的 Wiki 资料",
+    "hardware.resource": "读取已保存的硬件选型资源",
+    "hardware.workflow": "启动、查询、推进或恢复硬件选型工作流 user-journey-hardware",
+    "hardware.web-extract": "在网页证据暂停点，从已保存的网页中逐字抽取候选",
+    "hardware.prepare": "把通过校验的硬件选型登记为创建来源",
+    "cad.build": "构建 CAD 候选，含几何检查与实际渲染",
+    "visual.review": "按契约审查这一版的实际渲染",
+    "question.card": "发布一张问题卡，等待用户回答"
+  },
   "stages": {
     "identify": {
       "goal": "识别用户要的现成产品，并取得规格与拆解资料",
@@ -27,7 +45,8 @@
         "识别不确定时按最可能的候选继续，保留其他候选供用户切换；首版之前默认不向用户提问。",
         "例外：用户的硬要求缺少取值、无法合理默认，且按默认继续会做出错误结果（例如要求放进某个卡槽却没给尺寸）时，可以在首版之前发一张问题卡；整个首版之前至多一张，最多三题、每题最多三个选项；其余未定项一律按默认处理。",
         "完成后展示识别出的原产品图并注明来源（页面与站点），再用一两句话说明识别为哪款产品、依据是什么，以及比例核对结果。"
-      ]
+      ],
+      "actions": ["reference.research", "reference.page", "reference.finalize"]
     },
     "reference": {
       "goal": "检索相似产品，作为尺寸、结构、器件与实现方式的参考",
@@ -36,7 +55,8 @@
         "找不到完整的相似产品时，按声学、供电、交互等子系统分别参考，不硬凑数量；首版之前默认不向用户提问。",
         "相似产品只作参考，不成为可编辑模板，也不自动采用其 BOM。",
         "例外：用户的硬要求缺少取值、无法合理默认，且按默认继续会做出错误结果（例如要求放进某个卡槽却没给尺寸）时，可以在首版之前发一张问题卡；整个首版之前至多一张，最多三题、每题最多三个选项；其余未定项一律按默认处理。"
-      ]
+      ],
+      "actions": ["reference.research", "reference.page", "reference.finalize"]
     },
     "concept": {
       "goal": "生成第一张概念图",
@@ -50,7 +70,8 @@
           "以识别出的原产品图为输入生成修改后的图，只改用户要求修改的部分，保留清单中的特征。",
           "出图后用一两句话说明改了什么、保留了什么，并结束本轮；硬件选型在下一阶段进行。"
         ]
-      }
+      },
+      "actions": ["studio.prepare", "image.generate"]
     },
     "hardware": {
       "goal": "为当前需求选型并登记",
@@ -67,7 +88,8 @@
           "登记后用一两句话说明替代关系与默认值，然后结束本轮；待确认项在首版之后合并成一张问题卡统一询问。",
           "例外：用户的硬要求缺少取值、无法合理默认，且按默认继续会做出错误结果（例如要求放进某个卡槽却没给尺寸）时，可以在首版之前发一张问题卡；整个首版之前至多一张，最多三题、每题最多三个选项；其余未定项一律按默认处理。"
         ]
-      }
+      },
+      "actions": ["component.search", "hardware.guide", "hardware.wiki", "hardware.resource", "hardware.workflow", "hardware.web-extract", "hardware.prepare"]
     },
     "hardware_reselect": {
       "goal": "当前硬件放不下用户的硬尺寸上限或锁定分区时重新选型",
@@ -80,13 +102,15 @@
         "shape": {
           "true": "外形已锁定：槽位的 locked 分区（fit_envelope）同样不得放宽。没有能装下的候选时，先由结构在锁定外形内调整骨架（分区、层高、朝向）并给出新的 fit_envelope 后再选，仍装不下才发问题卡；此时“放宽尺寸”就是改外形，记为外观偏差。"
         }
-      }
+      },
+      "actions": ["question.card", "component.search", "hardware.guide", "hardware.wiki", "hardware.resource", "hardware.workflow", "hardware.web-extract", "hardware.prepare"]
     },
     "hardware_decision": {
       "goal": "硬尺寸上限下没有能装下的候选，交用户取舍",
       "directives": [
         "本轮不重新选型、不修改需求、不出图；只发一张问题卡，让用户在“换件”和“放宽尺寸”之间选择，然后结束本轮。"
-      ]
+      ],
+      "actions": ["question.card"]
     },
     "real_image": {
       "goal": "把外观基准图与当前硬件绑定",
@@ -101,6 +125,10 @@
           "用户明确要求重画时，在用户回合准备新的图片版本，保留原产物。",
           "不要修改需求；待答的问题卡保持原样，不代用户回答。"
         ]
+      },
+      "actions": ["studio.prepare"],
+      "action_variants": {
+        "restore": ["studio.prepare", "image.import"]
       }
     },
     "cad": {
@@ -118,13 +146,15 @@
           "false": "外形未锁定：硬件放得下优先，但外壳只能在 appearance 认可的外观容差内调整尺寸与比例，并记录调整量及依据；超出容差时换件（交回硬件）或把取舍交给用户，不得自行放大外壳。",
           "true": "外形尺寸与比例已锁定：不得放大或缩小外壳；装不下时停止建模，先交回硬件换件，仍不行再调整结构骨架，改外形必须由用户决定。"
         }
-      }
+      },
+      "actions": ["cad.build"]
     },
     "fallback": {
       "goal": "建模没有产出可展示的 CAD 时，由宿主生成标注清楚的简化草模",
       "directives": [
         "宿主按冻结的硬件尺寸生成一份已明确标注的简化草模；本轮不调用模型，不进行视觉审查。"
-      ]
+      ],
+      "actions": ["cad.build"]
     },
     "review": {
       "goal": "审查这一版的实际渲染",
@@ -137,7 +167,8 @@
           "以识别出的真实产品图为基准，按契约审查这一版，审查对象全部取自 CAD 回执，不要猜；然后用一两句话说明与原产品的差异。",
           "不要重新建模、不要重新出图、不要修改需求；待答的问题卡保持原样，不代用户回答。"
         ]
-      }
+      },
+      "actions": ["visual.review"]
     },
     "repair": {
       "goal": "只修正检查发现的问题",
@@ -145,7 +176,8 @@
         "只修改检查报告或几何分诊指出的冲突部位与实例，逐项保留其余实例；需要整体重建时按缺失的硬件与冲突证据完整重建。",
         "尽量保留外观基准图的轮廓、比例、特征位置与材质；不缩放原生元器件。",
         "不要修改需求、重新选型或重新出图；先完成轻量预览，视觉复检在下一阶段进行；待答的问题卡保持原样，不代用户回答。"
-      ]
+      ],
+      "actions": ["cad.build"]
     },
     "questions": {
       "goal": "首版之后合并询问按默认处理的事项",
@@ -155,7 +187,8 @@
         "意图、目标深度或型号识别仍有疑问时，可以作为其中一题，第一个选项写首版采用的判断。",
         "没有待确认项就不发卡，一两句话说明后结束本轮。",
         "不要修改需求、重新选型、建模或出图；用户的答复作为对首版的修订处理。"
-      ]
+      ],
+      "actions": ["question.card"]
     }
   }
 }

package/skills/abelien-workspace/domain.json

@@ -1,13 +1,13 @@
 {
   "name": "abelien-workspace",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "作品旅程、PRD 与业务契约；user-journey 由 Agent 驱动，draft 供真实硬件阶段使用；不声明假 PRD、确认、报价或支付能力",
   "resources": [
     "draft"
   ],
   "capabilities": {
     "workspace.journey-next": {
-      "description": "按意图（create / restore / modify / remix）的阶段计划给出下一阶段与该阶段的领域规则；纯计算，不联网、不写资源。宿主先跑完自己的守卫，再把 directives 附在自己的执行说明之后",
+      "description": "按意图（create / restore / modify / remix）的阶段计划给出下一阶段与该阶段的领域规则；纯计算，不联网、不写资源。宿主先跑完自己的守卫，再把 directives 附在自己的执行说明之后；actions 是该阶段允许的宿主中立动作，宿主据此放行自己的工具",
       "adapter": {
         "type": "module",
         "path": "scripts/journey-next.mjs",
@@ -23,6 +23,7 @@
         ],
         "arrays": [
           "directives",
+          "actions",
           "order",
           "completed"
         ]

package/skills/abelien-workspace/references/hardware-journey-orchestration.md

@@ -5,14 +5,14 @@
 ## 新建与修订分流
 
 - 没有已验证硬件方案、要形成正式初选：运行 `user-journey-hardware`。Agent 先做需求到三级槽位分类，再调用同级 `abelien-hardware-selection` 的 `hardware.select`；只有返回的 `hardware-selection` 通过门禁后才算完成正式硬件阶段。
-- 只需要研究 TOS 候选、暂不形成正式初选：运行 `user-journey-hardware-candidates`。Agent 先调用 `hardware.search` 从 TOS 分类索引读取 Top-K 最新候选 Wiki，再比较 `adapt_system` 或 `assemble_new` 并由 `hardware.finalize` 保存 `hardware-proposal`；这个提案不能通过正式硬件门，也不能直接开始算法阶段。
+- 只需要研究 OSS 候选、暂不形成正式初选：运行 `user-journey-hardware-candidates`。Agent 先调用 `hardware.search` 从 OSS 分类索引读取 Top-K 最新候选 Wiki，再比较 `adapt_system` 或 `assemble_new` 并由 `hardware.finalize` 保存 `hardware-proposal`；这个提案不能通过正式硬件门，也不能直接开始算法阶段。
 - 同一次任务还要完成算法选型：运行 `user-journey-hardware-algorithm`。硬件阶段门通过后，当前 run 自动进入算法研究和 `algorithm.finalize`，无需由前端另起第二个 workflow。
 - 已有已验证方案，用户明确修改其中一项：运行 `user-journey-hardware-revise`。输入只包含当前 draft ID、基线选型 ID/版本和最新变更请求；不要把整段对话塞入硬件服务。
 - 用户改变了产品目标或大量功能，而不是局部部件：形成新的需求版本，再运行新建流程，不把它伪装成局部修订。
 
 修订 workflow 先保存提案，再执行状态门，最后才更新 draft 指针。`needs_confirmation`、版本冲突、兼容未知或未授权连带变化都会在激活前停止。用户补充信息或批准连带项后，以同一有效基线和新的变更请求启动下一次修订 run；每次尝试都有独立资源和审计记录，这就是 v1 下的显式迭代，不是隐藏循环。
 
-TOS Wiki 读取由 `abelien-hardware` 的本地 module adapter 实现，通用内核只提供受目录约束的 module adapter 装载机制和 `search_hardware` 快捷命令。TOS 候选流程使用本地 `hardware.finalize` 保存提案；正式入口使用本地 hardware.select，回读同需求的召回并校验逐项证据；候选提案不能跳过该门。TOS 和服务凭据只能来自运行时环境，不得写入 Skill、workflow、结果资源或前端包。
+OSS Wiki 读取由 `abelien-hardware` 的本地 module adapter 实现，通用内核只提供受目录约束的 module adapter 装载机制和 `search_hardware` 快捷命令。OSS 候选流程使用本地 `hardware.finalize` 保存提案；正式入口使用本地 hardware.select，回读同需求的召回并校验逐项证据；候选提案不能跳过该门。OSS 和服务凭据只能来自运行时环境，不得写入 Skill、workflow、结果资源或前端包。
 
 ## 完整智能体
 

package/skills/abelien-workspace/references/harness-binding.md

@@ -55,9 +55,9 @@ stdout 的 `ok:true` 表示命令取得了回执。workflow 调用还必须检
 
 | 用户旅程所需能力 | 当前 Harness 对应与限制 |
 | --- | --- |
-| 按意图的下一阶段与阶段规则 | `workspace.journey-next`（本包 `domain.json` 唯一的 capability，`ab capability run workspace.journey-next --input '{"intent":"restore","artifacts":{"reference_final":true}}'`）：读取[阶段计划](../assets/journey-stage-plan.json)，返回下一阶段、`goal`、`directives`、`order`、`completed`、`locks` 与 `plan_version`。纯计算，不联网、不写资源、不读宿主状态；不判断 A1–C，也不代替宿主的结算、计费、预算、保底与幂等守卫。`stage` 只接受本意图的主线阶段与 `side` 旁路阶段，`artifacts`／`locks` 不用时省略、不传 null。阶段计划派生自[完整旅程](user-journey.md)，规则以旅程正文为准 |
+| 按意图的下一阶段与阶段规则 | `workspace.journey-next`（本包 `domain.json` 唯一的 capability，`ab capability run workspace.journey-next --input '{"intent":"restore","artifacts":{"reference_final":true}}'`）：读取[阶段计划](../assets/journey-stage-plan.json)，返回下一阶段、`goal`、`directives`、`actions`（该阶段允许的宿主中立动作，宿主据此放行自己的工具）、`order`、`completed`、`locks` 与 `plan_version`。纯计算，不联网、不写资源、不读宿主状态；不判断 A1–C，也不代替宿主的结算、计费、预算、保底与幂等守卫。`stage` 只接受本意图的主线阶段与 `side` 旁路阶段，`artifacts`／`locks` 不用时省略、不传 null。阶段计划派生自[完整旅程](user-journey.md)，规则以旅程正文为准 |
 | clarify 需求整理 | 同级 `abelien-clarify`：以当前操作和同版上下文换取 `result / questions / note`，不是 CLI capability，不写资源；结构可用其 `scripts/check_result.py` 校验。共用表达规则在同级 guide 的 references，由 guide 读一次注入。已移除旧 workspace.brief，不提供假澄清 |
-| 硬件候选检索与提案 | `user-journey-hardware-candidates` → `abelien-hardware`：`hardware.search`（TOS 检索）→ agent 比较整机与零部件候选 → `hardware.finalize`（保存 `hardware-proposal`）。提案不创建正式 `hardware-selection` 门，也不能直接开始算法阶段 |
+| 硬件候选检索与提案 | `user-journey-hardware-candidates` → `abelien-hardware`：`hardware.search`（OSS 检索）→ agent 比较整机与零部件候选 → `hardware.finalize`（保存 `hardware-proposal`）。提案不创建正式 `hardware-selection` 门，也不能直接开始算法阶段 |
 | 正式硬件选型 | `user-journey-hardware` / `user-journey-hardware-algorithm` → `abelien-hardware-selection` → `hardware.select`；本地模块回读真实召回并校验 Agent 判断，返回 hardware-selection；证据不足不可用候选提案代替 |
 | 算法与行为实现 | `user-journey-hardware-algorithm`（正式硬件过门后同 run 继续）或独立 `user-journey-algorithm` → `abelien-algorithm`：agent 按官方资料优先联网研究，`algorithm.finalize` 本地保存。两者的 `reactions` 输入取 clarify Requirements 的 `reaction[]` 原样传入 |
 | 外观／ID editing 与视觉审查 | 同级 `abelien-appearance`：维护轮廓、比例、CMF、部位与参考匹配目标，实际查看 structure 的本版渲染。没有注册 `appearance.*` 产品 capability；宿主须具备真实图片读取／编辑能力，不能把旧外观 mock 当成现行实现 |
@@ -126,7 +126,7 @@ node "$AB" --workdir "$WD" receipt get --wait <waitId> --digest <resultDigest>
 
 ## 硬件阶段实际驱动
 
-需求满足 A1 后，先读取同级 `abelien-hardware-selection/SKILL.md` 和工作流定义 `abelien-workspace/workflows/user-journey-hardware.json`。当前使用本地 hardware.select，无需 HTTP URL；先 TOS 搜索、再 Agent 逐约束引用、最后同源校验，详见选型域 selection-service-contract。下面的尖括号与 JSON 占位须替换为本次真实值。
+需求满足 A1 后，先读取同级 `abelien-hardware-selection/SKILL.md` 和工作流定义 `abelien-workspace/workflows/user-journey-hardware.json`。当前使用本地 hardware.select，无需 HTTP URL；先 OSS 搜索、再 Agent 逐约束引用、最后同源校验，详见选型域 selection-service-contract。下面的尖括号与 JSON 占位须替换为本次真实值。
 
 ```bash
 node "$AB" --workdir "$WD" workflow run user-journey-hardware --input '{"requirements": <clarify 交回的完整 Requirements>}'

package/skills/abelien-workspace/references/user-journey.md

@@ -216,15 +216,15 @@ AI 补充的是展示编排，须与用户已定义的行为一致并保留系
 
 ## 5. A2：尽早交给用户一个可以改的起点
 
-**机读阶段计划**：A1 通过之后到交付首版这一段，按意图（create／restore／modify／remix）的阶段顺序与各阶段的领域规则，另有机读形式[阶段计划](../assets/journey-stage-plan.json)，由 `workspace.journey-next` 解释（调用见 [能力映射](harness-binding.md#当前能力映射)）。§2.4 的识别与参考、本节的硬件初选和首版，对应计划的主线 `orders`；由真实结果触发的硬件重选与取舍、保底草模、修复和首版后合并提问，对应计划的旁路 `side`（§5.3、§6、§7）。本文是旅程规则的唯一正文，阶段计划是它的派生：两者不一致时以本文为准，先改本文，再同步阶段计划并升 `plan_version`。
+**机读阶段计划**：A1 通过之后到交付首版这一段，按意图（create／restore／modify／remix）的阶段顺序与各阶段的领域规则，另有机读形式[阶段计划](../assets/journey-stage-plan.json)，由 `workspace.journey-next` 解释（调用见 [能力映射](harness-binding.md#当前能力映射)）。§2.4 的识别与参考、本节的硬件初选和首版，对应计划的主线 `orders`；由真实结果触发的硬件重选与取舍、保底草模、修复和首版后合并提问，对应计划的旁路 `side`（§5.3、§6、§7）。本文是旅程规则的唯一正文，阶段计划是它的派生：两者不一致时以本文为准，先改本文，再同步阶段计划并升 `plan_version`。各阶段允许的动作（`actions`，宿主据此放行工具）只在阶段计划中声明，须与本文对该阶段的要求一致。
 
 ### 5.1 得到有来源的硬件初选
 
-首张概念图不等待硬件初选；硬件阶段接收 clarify 的完整 Requirements（context / reaction / limits，保留 source 与 strength），按功能分类为各槽位组合组件；同类整机的配置只作参考，不先套整机（还原现成产品或基于现成产品修改时，才评估整机改造）。数量、硬约束与完整行为一起参与选择，不能只拿摘要或品类标签选型，分类槽位也不等于选定型号。TOS `hardware.search` 可作为候选召回，`hardware.finalize` 只保存 `hardware-proposal`；正式初选唯一走 `abelien-hardware-selection` 的 `hardware.select`，返回正式 `hardware-selection` 后才进入硬件门和算法阶段。
+首张概念图不等待硬件初选；硬件阶段接收 clarify 的完整 Requirements（context / reaction / limits，保留 source 与 strength），按功能分类为各槽位组合组件；同类整机的配置只作参考，不先套整机（还原现成产品或基于现成产品修改时，才评估整机改造）。数量、硬约束与完整行为一起参与选择，不能只拿摘要或品类标签选型，分类槽位也不等于选定型号。OSS `hardware.search` 可作为候选召回，`hardware.finalize` 只保存 `hardware-proposal`；正式初选唯一走 `abelien-hardware-selection` 的 `hardware.select`，返回正式 `hardware-selection` 后才进入硬件门和算法阶段。
 
 返回结果要能说明：选了什么、来自哪里、覆盖哪些行为、还缺什么、哪些只是候选。整机已覆盖的能力不重复采购；只采用某个外壳或结构资产，也不自动采用来源整机的整份 BOM。
 
-没有真实候选、来源不可读、正式选型服务失败或必要覆盖不足时，保留候选／提案并说明缺口，不能编出一份正式初版硬件，也不能把 TOS 提案标成 verified。工程证据由领域能力补充；确需改变用户要求时才请用户取舍。
+没有真实候选、来源不可读、正式选型服务失败或必要覆盖不足时，保留候选／提案并说明缺口，不能编出一份正式初版硬件，也不能把 OSS 提案标成 verified。工程证据由领域能力补充；确需改变用户要求时才请用户取舍。
 
 ### 5.2 硬件初版出来，PRD 和 BOM 就可以先出
 
@@ -547,11 +547,11 @@ BOM 记录实际采用的组合，已有整机覆盖的功能不重复计件。
 
 ## 附录 B：当前 Harness 与旧 MVP 的适用边界
 
-以下为 2026-09-30 合并后的执行边界：正式硬件选型、TOS 候选提案、算法、外观与结构能力并存，但真实产品端到端验收和生产部署状态仍需单独核对。
+以下为 2026-09-30 合并后的执行边界：正式硬件选型、OSS 候选提案、算法、外观与结构能力并存，但真实产品端到端验收和生产部署状态仍需单独核对。
 
 | 部分 | 本地可核对的事实 | 不能由此推导的结论 |
 | --- | --- | --- |
-| 硬件初选 | `user-journey-hardware` → `abelien-hardware-selection` → `hardware.search` → Agent 证据判断 → 本地 `hardware.select` 是正式入口；`user-journey-hardware-candidates` → TOS `hardware.search` / `hardware.finalize` 仅保存候选提案 | 当前环境一定连通；全组合检查通过；已成为产品确认版本 |
+| 硬件初选 | `user-journey-hardware` → `abelien-hardware-selection` → `hardware.search` → Agent 证据判断 → 本地 `hardware.select` 是正式入口；`user-journey-hardware-candidates` → OSS `hardware.search` / `hardware.finalize` 仅保存候选提案 | 当前环境一定连通；全组合检查通过；已成为产品确认版本 |
 | 硬件局部修订 | 本 MR 不包含修订能力和 workflow；以后须核对实际安装声明 | 修订入口已存在或服务已可用 |
 | 算法选型 | 本 MR 不包含算法域与组合 workflow；产品旅程保留其目标职责 | 算法入口已接入、实现已部署或在设备实测 |
 | 3D 生成 | 有独立生成入口与 provider 适配；旧 workspace 生成 mock 已移除 | 已接通产品结构编辑、版本采用和装配验证闭环 |

package/skills/abelien-workspace/scripts/journey-next.mjs

@@ -1,6 +1,7 @@
 // workspace.journey-next（P2-13.05）：按意图的阶段计划给出下一阶段及其领域规则。
 // 纯函数：不联网、不写资源、不读宿主状态。宿主把自己保存的产物映射为 artifacts，先跑完自己的守卫
-// （结算、计费、保底、预算、工具集、幂等），再调用本能力；拿到的 directives 原样附在宿主自己的执行说明之后。
+// （结算、计费、保底、预算、幂等），再调用本能力；拿到的 directives 原样附在宿主自己的执行说明之后，
+// actions（action_catalog 中的宿主中立动作）由宿主映射为自己的工具，是该阶段唯一的放行依据。
 import { readFileSync } from "node:fs";
 
 const deepFreeze = value => {
@@ -22,6 +23,12 @@ export function stageDirectives(stage, intent, locks) {
   return base;
 }
 
+/** Actions one stage may take (ids from action_catalog): the intent's action variant if present, else the stage's actions. */
+export function stageActions(stage, intent) {
+  const entry = PLAN.stages[stage];
+  return [...(entry.action_variants?.[intent] ?? entry.actions)];
+}
+
 export function journeyNext({ input }) {
   if (!record(input) || Object.keys(input).some(key => !["intent", "artifacts", "locks", "stage"].includes(key))) invalid("input accepts intent, artifacts, locks and stage only");
   if (!INTENTS.includes(input.intent)) invalid(`intent must be one of ${INTENTS.join(", ")}`);
@@ -45,6 +52,7 @@ export function journeyNext({ input }) {
   const stage = input.stage ?? (firstOpen === -1 ? null : order[firstOpen]);
   return {
     plan_version: PLAN.plan_version, intent: input.intent, stage, goal: stage ? PLAN.stages[stage].goal : null,
-    directives: stage ? stageDirectives(stage, input.intent, locks) : [], order: [...order], completed, locks,
+    directives: stage ? stageDirectives(stage, input.intent, locks) : [], actions: stage ? stageActions(stage, input.intent) : [],
+    order: [...order], completed, locks,
   };
 }

package/skills/abelien-workspace/workflows/user-journey.json

@@ -316,7 +316,7 @@
     ],
     "capabilityRoutes": {
       "clarify": "读取 ../../abelien-clarify/SKILL.md，整理需求；不是 CLI capability。",
-      "hardwareInitial": "user-journey-hardware → abelien-hardware-selection → hardware.search TOS → Agent 证据判断 → 本地 hardware.select；唯一正式初选入口；TOS hardware.search 只提供候选，不能静默替代正式服务",
+      "hardwareInitial": "user-journey-hardware → abelien-hardware-selection → hardware.search OSS → Agent 证据判断 → 本地 hardware.select；唯一正式初选入口；OSS hardware.search 只提供候选，不能静默替代正式服务",
       "hardwareAndAlgorithm": "user-journey-hardware-algorithm；只在完整 reactions 及必要输入具备时使用",
       "hardwareRevision": "user-journey-hardware-revise；服务需真实可用",
       "algorithm": "user-journey-algorithm；输入已验证硬件与完整 reactions",

package/skills/abelien-hardware/scripts/tos-object-store.mjs

@@ -1,202 +0,0 @@
-import crypto from "node:crypto";
-
-const EMPTY = Buffer.alloc(0);
-
-function tosError(code, message, details) {
-  const error = new Error(message);
-  error.code = code;
-  if (details !== undefined) error.details = details;
-  return error;
-}
-
-export function sha256(value) {
-  return crypto.createHash("sha256").update(value).digest("hex");
-}
-
-function hmac(key, value, encoding) {
-  return crypto.createHmac("sha256", key).update(value).digest(encoding);
-}
-
-function first(env, primary, alias) {
-  return env[primary] || env[alias] || "";
-}
-
-export function normalizeTosEnv(env = {}) {
-  return {
-    ...env,
-    TOS_REGION: first(env, "TOS_REGION", "CAD_STORAGE_REGION"),
-    TOS_ENDPOINT: first(env, "TOS_ENDPOINT", "CAD_STORAGE_ENDPOINT"),
-    TOS_BUCKET: first(env, "TOS_BUCKET", "CAD_STORAGE_BUCKET"),
-    TOS_ACCESS_KEY_ID: first(env, "TOS_ACCESS_KEY_ID", "CAD_STORAGE_ACCESS_KEY"),
-    TOS_SECRET_ACCESS_KEY: first(env, "TOS_SECRET_ACCESS_KEY", "CAD_STORAGE_SECRET_KEY"),
-    TOS_ADDRESSING_STYLE: first(env, "TOS_ADDRESSING_STYLE", "CAD_STORAGE_ADDRESSING_STYLE") || "virtual",
-  };
-}
-
-function normalizePrefix(value) {
-  const cleaned = String(value || "hardware_profile_wiki/").replace(/^\/+|\/+$/g, "");
-  if (!cleaned || cleaned.split("/").some(part => part === "." || part === "..")) {
-    throw tosError("VALIDATION", "invalid TOS Wiki prefix");
-  }
-  return `${cleaned}/`;
-}
-
-function positiveIntegerEnv(env, name, fallback) {
-  if (env[name] === undefined || env[name] === "") return fallback;
-  const value = Number(env[name]);
-  if (!Number.isInteger(value) || value <= 0) throw tosError("VALIDATION", `${name} must be a positive integer`, { name });
-  return value;
-}
-
-export function createTosConfig(inputEnv = {}) {
-  const env = normalizeTosEnv(inputEnv);
-  const required = ["TOS_REGION", "TOS_ENDPOINT", "TOS_BUCKET", "TOS_ACCESS_KEY_ID", "TOS_SECRET_ACCESS_KEY"];
-  const missing = required.filter(name => !env[name]);
-  if (missing.length) throw tosError("ENV_MISSING", `env var not set: ${missing[0]}`, { name: missing[0], missing });
-  let endpoint;
-  try { endpoint = new URL(env.TOS_ENDPOINT); }
-  catch { throw tosError("VALIDATION", "TOS_ENDPOINT must be an absolute URL"); }
-  if (!['http:', 'https:'].includes(endpoint.protocol)) throw tosError("VALIDATION", "TOS_ENDPOINT must use http or https");
-  if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash) {
-    throw tosError("VALIDATION", "TOS_ENDPOINT must not contain credentials, query or fragment");
-  }
-  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{1,62}$/.test(env.TOS_BUCKET)) throw tosError("VALIDATION", "invalid TOS_BUCKET");
-  if (!['virtual', 'path'].includes(env.TOS_ADDRESSING_STYLE)) throw tosError("VALIDATION", "TOS_ADDRESSING_STYLE must be virtual or path");
-  return {
-    region: env.TOS_REGION,
-    endpoint,
-    bucket: env.TOS_BUCKET,
-    accessKeyId: env.TOS_ACCESS_KEY_ID,
-    secretAccessKey: env.TOS_SECRET_ACCESS_KEY,
-    sessionToken: env.TOS_SESSION_TOKEN || "",
-    addressingStyle: env.TOS_ADDRESSING_STYLE,
-    prefix: normalizePrefix(env.TOS_WIKI_PREFIX),
-    // 网络读取的两道边界。此前 module adapter 路径既无超时也无体积上限：一个不响应的
-    // 对象存储会把召回挂到进程结束，一个超大对象会被整段读进内存（召回本身还并发 8 路）。
-    // 默认值取"够宽但有限"——Wiki 与分类分片都是小对象，写读都要走这两道闸。
-    timeoutMs: positiveIntegerEnv(env, "TOS_REQUEST_TIMEOUT_MS", 30000),
-    maxObjectBytes: positiveIntegerEnv(env, "TOS_MAX_OBJECT_BYTES", 16 * 1024 * 1024),
-  };
-}
-
-// 先按声明的 content-length 拦一道（能在读之前拒），再在读的过程中边读边数——
-// arrayBuffer() 是先整段进内存再回看长度，对"超大对象"这个失败形态等于没拦。
-async function readObjectBytes(response, maxBytes, key, method) {
-  const declared = Number(response.headers?.get?.("content-length"));
-  if (Number.isFinite(declared) && declared > maxBytes) {
-    throw tosError("TOS_OBJECT_TOO_LARGE", `TOS object exceeds TOS_MAX_OBJECT_BYTES (${maxBytes})`, { key, method, maxBytes, contentLength: declared });
-  }
-  if (response.body && typeof response.body.getReader === "function") {
-    const reader = response.body.getReader();
-    const chunks = [];
-    let total = 0;
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > maxBytes) {
-        await reader.cancel().catch(() => {});
-        throw tosError("TOS_OBJECT_TOO_LARGE", `TOS object exceeds TOS_MAX_OBJECT_BYTES (${maxBytes})`, { key, method, maxBytes });
-      }
-      chunks.push(Buffer.from(value));
-    }
-    return Buffer.concat(chunks);
-  }
-  const bytes = typeof response.arrayBuffer === "function"
-    ? Buffer.from(await response.arrayBuffer())
-    : Buffer.from(await response.text(), "utf8");
-  if (bytes.length > maxBytes) {
-    throw tosError("TOS_OBJECT_TOO_LARGE", `TOS object exceeds TOS_MAX_OBJECT_BYTES (${maxBytes})`, { key, method, maxBytes, contentLength: bytes.length });
-  }
-  return bytes;
-}
-
-function encodePath(value) {
-  return String(value).split("/").map(part => encodeURIComponent(part).replace(/[!'()*]/g, char => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
-}
-
-function objectLocation(config, key) {
-  const cleanKey = String(key).replace(/^\/+/, "");
-  if (!cleanKey || cleanKey.split("/").some(part => part === "." || part === "..")) throw tosError("VALIDATION", "invalid TOS object key", { key });
-  const parts = [config.endpoint.pathname.replace(/^\/+|\/+$/g, "")].filter(Boolean);
-  let host = config.endpoint.host;
-  if (config.addressingStyle === "path") parts.push(config.bucket);
-  else host = `${config.bucket}.${host}`;
-  parts.push(cleanKey);
-  const uri = `/${encodePath(parts.join("/"))}`;
-  return { host, uri, url: `${config.endpoint.protocol}//${host}${uri}` };
-}
-
-export function signTosObjectRequest(config, key, { method = "GET", body = EMPTY, headers = {}, now = new Date() } = {}) {
-  const payload = Buffer.isBuffer(body) ? body : Buffer.from(body ?? "");
-  const location = objectLocation(config, key);
-  const timestamp = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
-  const date = timestamp.slice(0, 8);
-  const signed = {
-    host: location.host,
-    "x-amz-content-sha256": sha256(payload),
-    "x-amz-date": timestamp,
-  };
-  for (const [name, value] of Object.entries(headers)) signed[name.toLowerCase()] = String(value).trim();
-  if (config.sessionToken) signed["x-amz-security-token"] = config.sessionToken;
-  const names = Object.keys(signed).sort();
-  const canonicalHeaders = names.map(name => `${name}:${signed[name]}\n`).join("");
-  const signedHeaders = names.join(";");
-  const canonicalRequest = [method.toUpperCase(), location.uri, "", canonicalHeaders, signedHeaders, sha256(payload)].join("\n");
-  const scope = `${date}/${config.region}/s3/aws4_request`;
-  const stringToSign = ["AWS4-HMAC-SHA256", timestamp, scope, sha256(canonicalRequest)].join("\n");
-  const dateKey = hmac(`AWS4${config.secretAccessKey}`, date);
-  const regionKey = hmac(dateKey, config.region);
-  const serviceKey = hmac(regionKey, "s3");
-  const signingKey = hmac(serviceKey, "aws4_request");
-  const signature = hmac(signingKey, stringToSign, "hex");
-  signed.authorization = `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-  return { url: location.url, method: method.toUpperCase(), headers: signed, body: payload };
-}
-
-export async function requestTosObject(config, key, { method = "GET", body = EMPTY, headers = {}, optional = false, fetchImpl = fetch } = {}) {
-  const request = signTosObjectRequest(config, key, { method, body, headers });
-  let response;
-  try {
-    response = await fetchImpl(request.url, {
-      method: request.method,
-      headers: request.headers,
-      // 超时覆盖到响应体读完（undici 把 signal 一路带到 body 流）：否则一个连上就不发完的
-      // 对端同样能挂死召回。既有桩 fetch 忽略 signal，行为不变。
-      signal: AbortSignal.timeout(config.timeoutMs),
-      ...(request.method === "GET" || request.method === "HEAD" ? {} : { body: request.body }),
-    });
-  } catch (cause) {
-    if (cause?.name === "TimeoutError" || cause?.code === "ABORT_ERR") {
-      throw tosError("TOS_REQUEST_TIMEOUT", `TOS request timed out after ${config.timeoutMs}ms`, { key, method: request.method, timeout_ms: config.timeoutMs });
-    }
-    throw tosError("TOS_REQUEST_FAILED", `TOS request failed: ${cause.message}`, { key, method: request.method });
-  }
-  if (!response.ok) {
-    if (optional && response.status === 404) return null;
-    throw tosError("TOS_HTTP_STATUS", `TOS returned HTTP ${response.status}`, { key, method: request.method, status: response.status });
-  }
-  const bytes = request.method === "HEAD"
-    ? EMPTY
-    : await readObjectBytes(response, config.maxObjectBytes, key, request.method);
-  return {
-    key,
-    bytes,
-    etag: response.headers?.get?.("etag")?.replace(/^"|"$/g, "") || sha256(bytes),
-    lastModified: response.headers?.get?.("last-modified") || null,
-    contentLength: Number(response.headers?.get?.("content-length")) || null,
-    metadataSha256: response.headers?.get?.("x-amz-meta-sha256") || response.headers?.get?.("x-tos-meta-sha256") || null,
-  };
-}
-
-export function getTosObject(config, key, options = {}) {
-  return requestTosObject(config, key, { ...options, method: "GET" });
-}
-
-export function putTosObject(config, key, body, options = {}) {
-  return requestTosObject(config, key, { ...options, method: "PUT", body });
-}
-
-export function headTosObject(config, key, options = {}) {
-  return requestTosObject(config, key, { ...options, method: "HEAD" });
-}