abelien-harness 0.9.0 → 0.10.0

package/skills/abelien-algorithm/schemas/algorithm-candidates.v1.json

@@ -0,0 +1,192 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://git.abelien.cn/abelien/abelienharness/skills/abelien-algorithm/schemas/algorithm-candidates.v1.json",
+  "title": "abelien.algorithm-candidates.v1",
+  "description": "algorithm.candidates 的输入去掉 research_id（由宿主按本步检索结果填入）。宿主可以把本文件原样用作工具参数定义；字段与 scripts/candidates.mjs 的 CANDIDATE_FIELDS／NEEDS_FIELDS 一致，由测试保证。每个 reaction 要么至少一个候选，要么写进 unresolved。",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "candidates"
+  ],
+  "properties": {
+    "candidates": {
+      "type": "array",
+      "maxItems": 40,
+      "description": "每个 reaction 1–3 个候选；违反硬约束的不提交。",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "reaction_id",
+          "implementation_ref",
+          "implementation_type",
+          "execution_target",
+          "summary"
+        ],
+        "properties": {
+          "reaction_id": {
+            "type": "string",
+            "description": "需求里的 reaction id。"
+          },
+          "implementation_ref": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 80,
+            "description": "实现的简短名称（如 FastLED、Open-Meteo Forecast API、microWakeWord），不带网址、括号说明或用途；说明写进 summary。绑定时原样引用。"
+          },
+          "implementation_version": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "maxLength": 60,
+            "description": "来源写明的确定版本（如 3.9.0、v2.1.0、One Call 3.0 的 3.0）；来源没写就填 null，不填 latest、main。"
+          },
+          "implementation_type": {
+            "enum": [
+              "firmware",
+              "library",
+              "model",
+              "cloud_service"
+            ]
+          },
+          "execution_target": {
+            "enum": [
+              "edge",
+              "cloud",
+              "hybrid"
+            ]
+          },
+          "library_entry_id": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "description": "库内已适配算法的 entry_id；库外候选省略或填 null。"
+          },
+          "summary": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 500,
+            "description": "怎么用它实现这个 reaction。"
+          },
+          "needs": {
+            "type": "object",
+            "additionalProperties": false,
+            "description": "对硬件的需求，按来源原文记录；原文没写的填 null 或留空列表，不猜。",
+            "properties": {
+              "compute": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 500
+              },
+              "memory": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 500
+              },
+              "storage": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 500
+              },
+              "runtime": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 500
+              },
+              "network": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "maxLength": 500
+              },
+              "interfaces": {
+                "type": "array",
+                "maxItems": 20,
+                "items": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 120
+                },
+                "description": "每项一个接口的短名，如 I2C、GPIO、I2S microphone。"
+              },
+              "sensors": {
+                "type": "array",
+                "maxItems": 20,
+                "items": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 120
+                }
+              }
+            }
+          },
+          "quotes": {
+            "type": "array",
+            "maxItems": 6,
+            "description": "逐字取自本次研究读到的正文（可以是为别的 reaction 读到的页面，同一份资料常常支撑几个 reaction）；库外候选至少一条。",
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "page_id",
+                "text"
+              ],
+              "properties": {
+                "page_id": {
+                  "type": "string",
+                  "description": "本次研究的页面 id，如 p3。"
+                },
+                "text": {
+                  "type": "string",
+                  "minLength": 8,
+                  "maxLength": 400
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "unresolved": {
+      "type": "array",
+      "description": "确实找不到候选的 reaction，每个只写一次。",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "reaction_id",
+          "reason"
+        ],
+        "properties": {
+          "reaction_id": {
+            "type": "string"
+          },
+          "reason": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 500
+          }
+        }
+      }
+    },
+    "unknowns": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 500
+      }
+    }
+  }
+}

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

@@ -0,0 +1,119 @@
+// algorithm.candidates（P2-03 算法并行车道）：核验 Agent 读完 implementation 研究后为每个 reaction 提出的候选实现，
+// 保存为 status=proposed 的 algorithm-research。这一步不依赖硬件，可在硬件选型进行中完成；与硬件的兼容核对留给
+// algorithm.finalize 的 bind 操作。引用必须逐字出现在本次研究存下的正文里（规范化空白与全半角后比较）；同一份实现资料
+// 常常同时支撑几个 reaction，所以可以引用本次研究读到的任一页。只出现在检索摘要里的引用标为 search_snippet，可用于发现，
+// 不能当作证据。一次提交里每个候选的问题一起报出，免得 Agent 一轮只改一处。
+import { text, record, digest, failure } from "../../abelien-harness/scripts/web/common.mjs";
+import { SCHEMA, IMPLEMENTATION_TYPES, EXECUTION_TARGETS, LIMITS, invalid, words, normalize, validateResearch } from "./evidence.mjs";
+
+/** Field sets of schemas/algorithm-candidates.v1.json; a test keeps the two in step. */
+export const CANDIDATE_FIELDS = Object.freeze(["reaction_id", "implementation_ref", "implementation_version", "implementation_type", "execution_target", "library_entry_id", "summary", "needs", "quotes"]);
+export const NEEDS_FIELDS = Object.freeze(["compute", "memory", "storage", "runtime", "network", "interfaces", "sensors"]);
+export const CANDIDATE_LIMITS = Object.freeze({ refChars: 80, versionChars: 60, interfaceChars: 120, issues: 8 });
+const FLOATING = /^(latest|main|master|head|unknown|unversioned|stable|\*)$/i;
+const LINK = /https?:\/\/|www\./i;
+
+/** A stable name the binding and the PRD can repeat as is; where it came from and what it does belong in quotes and summary. */
+function implementationRef(value, label) {
+  if (!text(value) || [...value.trim()].length > CANDIDATE_LIMITS.refChars || LINK.test(value) || /[\r\n]/.test(value))
+    invalid(`${label} must be a short name (1–${CANDIDATE_LIMITS.refChars} chars, no URL or explanation; put details in summary)`);
+  return value.trim();
+}
+
+/** The version the source itself states, or null when it states none; a floating label is not a version. */
+function implementationVersion(value, label) {
+  if (value === undefined || value === null) return null;
+  if (!text(value) || [...value.trim()].length > CANDIDATE_LIMITS.versionChars || LINK.test(value) || FLOATING.test(value.trim()))
+    invalid(`${label} must be the definite version the source states (≤${CANDIDATE_LIMITS.versionChars} chars, not latest/main), or null`);
+  return value.trim();
+}
+
+function onlyKeys(value, keys, label) { if (!record(value) || Object.keys(value).some(key => !keys.includes(key))) invalid(`${label} has unsupported fields`); }
+
+/** What the implementation needs from hardware, in the source's own words; unknown stays null, never guessed. */
+function readNeeds(needs, label) {
+  onlyKeys(needs, NEEDS_FIELDS, label);
+  const out = {};
+  for (const key of ["compute", "memory", "storage", "runtime", "network"]) {
+    const value = needs[key];
+    if (value !== undefined && value !== null && (!text(value) || [...value].length > LIMITS.summaryChars)) invalid(`${label}.${key} must be null or 1–${LIMITS.summaryChars} chars`);
+    out[key] = value === undefined || value === null ? null : value.trim();
+  }
+  for (const key of ["interfaces", "sensors"]) {
+    const value = needs[key] ?? [];
+    if (!Array.isArray(value) || value.length > 20 || value.some(item => !text(item) || [...item].length > CANDIDATE_LIMITS.interfaceChars)) invalid(`${label}.${key} must list up to 20 strings of 1–${CANDIDATE_LIMITS.interfaceChars} chars`);
+    out[key] = value.map(item => item.trim());
+  }
+  return out;
+}
+
+export async function proposeAlgorithmCandidates({ input, readResource, readBlob }) {
+  onlyKeys(input, ["research_id", "candidates", "unresolved", "unknowns"], "input");
+  if (typeof readResource !== "function" || typeof readBlob !== "function") throw Object.assign(new Error("resource and content readers are required"), { code: "ALGORITHM_HOST" });
+  if (!text(input.research_id) || !input.research_id.startsWith("algorithm-research:")) invalid("research_id must be an algorithm-research resource ID");
+  const resource = await readResource(input.research_id);
+  if (!resource || resource.kind !== "algorithm-research") invalid("research_id does not name saved algorithm research");
+  const research = validateResearch(resource.body);
+  if (research.status !== "collected" || research.purpose !== "implementation") invalid("candidates are proposed from collected implementation research");
+  const reactionIds = new Set(research.reactions.map(item => item.id));
+  const libraryIds = new Set((research.library ?? []).map(item => item.entry_id));
+  const pages = new Map(research.pages.filter(page => page.status === "read").map(page => [page.id, page]));
+  const texts = new Map();
+  const pageText = pageId => {
+    if (!texts.has(pageId)) texts.set(pageId, normalize(String(readBlob(pages.get(pageId).text_blob_ref)?.text ?? "")));
+    return texts.get(pageId);
+  };
+  const candidates = Array.isArray(input.candidates) ? input.candidates : invalid("candidates must be an array");
+  if (candidates.length > LIMITS.candidates) invalid(`candidates must list up to ${LIMITS.candidates} entries`);
+  const covered = new Set(), issues = [];
+  // Each candidate reports its first problem; all of them come back together in one VALIDATION.
+  const collect = (fn, at) => {
+    try { return fn(); } catch (error) { if (error?.code !== "VALIDATION") throw error; issues.push(error.message.startsWith(at) ? error.message : `${at}: ${error.message}`); return null; }
+  };
+  const accepted = candidates.map((candidate, index) => collect(() => {
+    const at = `candidates[${index}]`;
+    onlyKeys(candidate, CANDIDATE_FIELDS, at);
+    if (!reactionIds.has(candidate.reaction_id)) invalid(`${at}.reaction_id must name a researched reaction`);
+    if (!IMPLEMENTATION_TYPES.includes(candidate.implementation_type)) invalid(`${at}.implementation_type must be one of ${IMPLEMENTATION_TYPES.join(", ")}`);
+    if (!EXECUTION_TARGETS.includes(candidate.execution_target)) invalid(`${at}.execution_target must be one of ${EXECUTION_TARGETS.join(", ")}`);
+    if (candidate.library_entry_id !== undefined && candidate.library_entry_id !== null && !libraryIds.has(candidate.library_entry_id)) invalid(`${at}.library_entry_id must name an in-library algorithm given to the research`);
+    const quotes = Array.isArray(candidate.quotes) ? candidate.quotes : [];
+    // An in-library algorithm may stand on the library entry alone; anything else needs source quotes.
+    if ((!quotes.length && !candidate.library_entry_id) || quotes.length > LIMITS.quotes) invalid(`${at}.quotes must list 1–${LIMITS.quotes} source quotes unless library_entry_id is given`);
+    const checked = quotes.map((quote, q) => {
+      const where = `${at}.quotes[${q}]`;
+      onlyKeys(quote, ["page_id", "text"], where);
+      const page = pages.get(quote.page_id);
+      if (!page) invalid(`${where}.page_id must name a read page of this research`);
+      const said = words(quote.text, `${where}.text`, LIMITS.quoteChars);
+      if ([...normalize(said)].length < LIMITS.quoteMinChars) invalid(`${where}.text must be at least ${LIMITS.quoteMinChars} characters`);
+      if (!pageText(quote.page_id).includes(normalize(said))) invalid(`${where}.text must appear verbatim in page ${quote.page_id}`);
+      return { page_id: page.id, url: page.final_url ?? page.url, text: said, text_source: page.text_source };
+    });
+    const out = { reaction_id: candidate.reaction_id, implementation_ref: implementationRef(candidate.implementation_ref, `${at}.implementation_ref`),
+      implementation_version: implementationVersion(candidate.implementation_version, `${at}.implementation_version`),
+      implementation_type: candidate.implementation_type, execution_target: candidate.execution_target, library_entry_id: candidate.library_entry_id ?? null,
+      summary: words(candidate.summary, `${at}.summary`, LIMITS.summaryChars), needs: readNeeds(candidate.needs ?? {}, `${at}.needs`), quotes: checked,
+      evidence: checked.some(quote => quote.text_source === "page") ? "page" : candidate.library_entry_id ? "library" : "search_snippet" };
+    covered.add(candidate.reaction_id);
+    return out;
+  }, `candidates[${index}]`));
+  const unresolved = Array.isArray(input.unresolved) ? input.unresolved : [];
+  const unresolvedIds = new Set();
+  const gaps = unresolved.map((item, index) => collect(() => {
+    onlyKeys(item, ["reaction_id", "reason"], `unresolved[${index}]`);
+    if (!reactionIds.has(item.reaction_id) || covered.has(item.reaction_id) || unresolvedIds.has(item.reaction_id)) invalid(`unresolved[${index}].reaction_id must name a researched reaction without candidates, once`);
+    unresolvedIds.add(item.reaction_id);
+    return { reaction_id: item.reaction_id, reason: words(item.reason, `unresolved[${index}].reason`, LIMITS.summaryChars) };
+  }, `unresolved[${index}]`));
+  // A reaction whose only candidate was rejected above is reported there, not again here.
+  const rejected = new Set(candidates.filter((_, index) => accepted[index] === null).map(candidate => candidate?.reaction_id));
+  for (const id of reactionIds) if (!covered.has(id) && !unresolvedIds.has(id) && !rejected.has(id)) issues.push(`reaction ${id} needs at least one candidate or an unresolved reason`);
+  if (issues.length) throw failure("VALIDATION", [...issues.slice(0, CANDIDATE_LIMITS.issues), ...(issues.length > CANDIDATE_LIMITS.issues ? [`and ${issues.length - CANDIDATE_LIMITS.issues} more`] : [])].join("; "));
+  const unknowns = Array.isArray(input.unknowns) ? input.unknowns.map((item, index) => words(item, `unknowns[${index}]`, LIMITS.summaryChars)) : [];
+  const stable = { collected_id: resource.id, candidates: accepted, unresolved: gaps, unknowns };
+  const id = `alg-prop-${digest(stable).slice(0, 16)}`;
+  return validateResearch({ id, schema: SCHEMA, status: "proposed", request_digest: research.request_digest, purpose: research.purpose, collected_id: resource.id,
+    context: research.context, reactions: research.reactions, limits: research.limits, library: research.library, hardware: null,
+    searches: [], pages: research.pages, candidates: accepted, unresolved: gaps, unknowns: [...research.unknowns, ...unknowns] });
+}

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

@@ -0,0 +1,69 @@
+// algorithm-research v1 的字段定义与校验（P2-03 算法并行车道）。研究分两种：implementation 只凭需求检索实现
+// （与硬件选型并行），hardware 在硬件登记后检索已选型号的厂商资料。页面正文由 Harness 自己读取并按 sha256 存证，
+// algorithm.finalize 的 bind 操作只认这里存下的正文，不认 Agent 自述。
+import { createPublicReader } from "../../abelien-harness/scripts/web/public-read.mjs";
+import { createVolcSearch } from "../../abelien-harness/scripts/web/volc.mjs";
+import { redact } from "../../abelien-harness/scripts/web/redact.mjs";
+import { failure, text, record } from "../../abelien-harness/scripts/web/common.mjs";
+
+export const SCHEMA = "abelien.algorithm-research.v1";
+export const PURPOSES = Object.freeze(["implementation", "hardware"]);
+export const STATUSES = Object.freeze(["in_progress", "collected", "proposed"]);
+export const IMPLEMENTATION_TYPES = Object.freeze(["firmware", "library", "model", "cloud_service"]);
+export const EXECUTION_TARGETS = Object.freeze(["edge", "cloud", "hybrid"]);
+/** Version of the collected shape, part of every request digest: a shape change collects afresh under a new id. */
+export const RESEARCH_SHAPE = 1;
+export const LIMITS = Object.freeze({ queries: 8, count: 5, pages: 12, library: 50, reactions: 20, textChars: 2000, queryChars: 200,
+  candidates: 40, quotes: 6, quoteChars: 400, quoteMinChars: 8, summaryChars: 500,
+  pageBytes: 8 * 1024 * 1024, excerptChars: 1200, pageTimeoutMs: 25000, pageConnectTimeoutMs: 8000, pageRoundMs: 90000, searchTimeoutMs: 30000, concurrency: 4 });
+
+export const CODES = Object.freeze({ transport: "ALGORITHM_WEB_TRANSPORT", dns: "ALGORITHM_WEB_DNS", access: "ALGORITHM_WEB_URL", redirect: "ALGORITHM_WEB_PAGE",
+  timeout: "ALGORITHM_WEB_TIMEOUT", url: "ALGORITHM_WEB_URL", config: "ALGORITHM_WEB_CONFIG", readTimeout: "ALGORITHM_PUBLIC_READ_TIMEOUT",
+  capability: "ALGORITHM_WEB_CAPABILITY", provider: "ALGORITHM_WEB_PROVIDER", auth: "ALGORITHM_WEB_AUTH", rateLimit: "ALGORITHM_WEB_RATE_LIMIT", response: "ALGORITHM_WEB_RESPONSE" });
+
+export const reader = createPublicReader({ codes: CODES, userAgent: "Abelien-Algorithm-Evidence/1", accept: "text/html,text/plain,text/markdown,application/xhtml+xml", decodeCharset: true });
+export const volc = createVolcSearch({ codes: CODES, ownsError: error => Boolean(error?.code?.startsWith("ALGORITHM_WEB_")),
+  redact: (raw, env = {}) => redact(raw, [env.WEB_SEARCH_API_KEY].filter(text)), timeoutMessage: "algorithm network request timed out" });
+
+export const invalid = message => { throw failure("VALIDATION", message); };
+export const words = (value, label, max = LIMITS.textChars) => {
+  if (!text(value) || [...value].length > max) invalid(`${label} must be 1–${max} chars`);
+  return value.trim();
+};
+// NFKC folds full-width forms before whitespace collapses, as reference.finalize does for its quotes.
+export const normalize = value => value.normalize("NFKC").replace(/\s+/g, " ").trim();
+
+/**
+ * The research reads clarify's requirements as they are: reaction[] {id, text} and limits[] with strength; only the
+ * fields the research needs are kept, so the request digest does not move with unrelated requirement edits.
+ */
+export function readRequirements(requirements) {
+  if (!record(requirements)) invalid("requirements must be clarify's Requirements object");
+  const reactions = Array.isArray(requirements.reaction) ? requirements.reaction : [];
+  if (!reactions.length || reactions.length > LIMITS.reactions) invalid(`requirements.reaction must list 1–${LIMITS.reactions} reactions`);
+  const ids = new Set();
+  const out = reactions.map((reaction, index) => {
+    if (!record(reaction) || !text(reaction.id) || ids.has(reaction.id)) invalid(`requirements.reaction[${index}] needs a unique id`);
+    ids.add(reaction.id);
+    return { id: reaction.id, text: words(reaction.text, `requirements.reaction[${index}].text`) };
+  });
+  const limits = Array.isArray(requirements.limits) ? requirements.limits : [];
+  const context = record(requirements.context) ? requirements.context.text ?? null : typeof requirements.context === "string" ? requirements.context : null;
+  return { context: text(context) ? context.trim() : null, reactions: out,
+    limits: limits.filter(record).map(limit => ({ id: limit.id ?? null, text: limit.text ?? null, strength: limit.strength ?? null })) };
+}
+
+export function validateResearch(body) {
+  if (!record(body) || body.schema !== SCHEMA || !STATUSES.includes(body.status) || !text(body.id) || !PURPOSES.includes(body.purpose)) invalid("algorithm research has an invalid schema, id, status or purpose");
+  for (const key of ["reactions", "searches", "pages", "unknowns"]) if (!Array.isArray(body[key])) invalid(`algorithm research ${key} must be an array`);
+  for (const [index, page] of body.pages.entries()) {
+    const at = `pages[${index}]`;
+    if (!record(page) || page.id !== `p${index + 1}` || !text(page.url) || !["read", "unavailable"].includes(page.status)) invalid(`${at} has an invalid id, url or status`);
+    if (page.status === "read" && !(/^sha256:[0-9a-f]{64}$/.test(page.text_blob_ref ?? "") && /^[0-9a-f]{64}$/.test(page.text_sha256 ?? "") && ["page", "search_snippet"].includes(page.text_source)))
+      invalid(`${at} is read but lacks its saved text, hash or text_source`);
+  }
+  if (body.status === "proposed") {
+    if (!text(body.collected_id) || !Array.isArray(body.candidates) || !Array.isArray(body.unresolved)) invalid("proposed research needs collected_id, candidates and unresolved");
+  }
+  return body;
+}

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

@@ -27,22 +27,75 @@ function array(value, name) {
   return value;
 }
 
-export async function finalizeAlgorithmSelection({ input, readResource, readEvidence }) {
-  const research = input?.research;
-  if (!text(input?.hardware_selection_id) || !text(input?.hardware_selection_revision)) throw error("hardware selection id and revision are required");
+/** Field sets of schemas/algorithm-bindings.v1.json (what the Agent submits as `research` for operation=bind); a test keeps them in step. */
+export const PRIMARY_SOURCE_TYPES = Object.freeze(["hardware_vendor", "implementation_official", "huggingface", "cloud_vendor"]);
+export const COMPATIBILITY_KEYS = Object.freeze(["io", "runtime", "dependencies", "network", "license", "resources"]);
+export const CHECK_STATUSES = Object.freeze(["pass", "conflict", "unknown"]);
+export const BIND_FIELDS = Object.freeze({
+  research: ["bindings", "sources", "unknowns", "blocking_unknowns", "unavailable_sources"],
+  binding: ["reaction_id", "implementation_ref", "implementation_version", "implementation_type", "execution_target", "hardware_component_ids", "source_ids", "compatibility", "constraint_checks"],
+  check: ["status", "summary", "source_ids"],
+  constraint: ["constraint_id", "status", "summary", "source_ids"],
+  source: ["id", "research_id", "page_id", "source_type", "title", "publisher", "version", "excerpt", "hardware_component_ids", "implementation_ref"],
+});
+const RECEIPT_FIELDS = ["url", "accessed_at", "content_sha256", "evidence_ref"];
+
+/**
+ * operation=bind（P2-03 算法并行车道）：候选来自 algorithm.candidates 保存的 proposed 研究。来源只写 research_id 与
+ * page_id，回执字段（url、accessed_at、content_sha256、evidence_ref）由 Harness 从自己存下的研究正文填写，提交里的同名字段
+ * 一律丢弃（检索摘要不算）；宿主注入的 readEvidence 仍然优先用于核对。每条绑定须选该 reaction 已提议的候选之一。
+ * 硬件基线可以尚未 verified：此时照常核对，但结果固定为 needs_confirmation，并写明原因。
+ */
+async function prepareBind(input, { readResource, readBlob, readEvidence }) {
+  if (!text(input.proposed_id) || !input.proposed_id.startsWith("algorithm-research:")) throw error("bind needs proposed_id of saved algorithm candidates");
+  if (typeof readBlob !== "function") throw error("bind needs the store content reader");
+  const proposed = await readResource(input.proposed_id);
+  if (!proposed || proposed.kind !== "algorithm-research" || proposed.body?.status !== "proposed" || !text(proposed.body.collected_id)) throw error("proposed_id does not name proposed algorithm candidates");
+  const allowed = async id => {
+    if (id === proposed.body.collected_id) return true;
+    const resource = await readResource(id);
+    return resource?.kind === "algorithm-research" && resource.body?.status === "collected" && resource.body.purpose === "hardware"
+      && resource.body.hardware?.selection_id === input.hardware_selection_id && resource.body.hardware?.revision === input.hardware_selection_revision;
+  };
+  const storeEvidence = async ref => {
+    const match = /^(algorithm-research:[A-Za-z0-9][A-Za-z0-9_-]{0,127})#(p\d{1,3})$/.exec(ref ?? "");
+    if (!match || !await allowed(match[1])) return null;
+    const page = (await readResource(match[1]))?.body?.pages?.find(item => item?.id === match[2]);
+    if (!page || page.status !== "read" || page.text_source !== "page" || !text(page.fetched_at)) return null;
+    return { url: page.final_url ?? page.url, content_sha256: page.text_sha256, fetched_at: page.fetched_at, content: String(readBlob(page.text_blob_ref)?.text ?? "") };
+  };
+  /** The source as submitted, minus any receipt fields, plus the receipt of the saved page it names (none when it names no read page). */
+  const withReceipt = async source => {
+    if (!record(source)) return source;
+    const rest = Object.fromEntries(Object.entries(source).filter(([key]) => !RECEIPT_FIELDS.includes(key)));
+    const ref = text(source.research_id) && text(source.page_id) ? `${source.research_id}#${source.page_id}` : null;
+    const page = ref ? await storeEvidence(ref) : null;
+    return page ? { ...rest, url: page.url, accessed_at: page.fetched_at, content_sha256: page.content_sha256, evidence_ref: ref } : rest;
+  };
+  return { readEvidence: readEvidence ?? storeEvidence, allowUnverified: true, proposed, withReceipt };
+}
+
+export async function finalizeAlgorithmSelection({ input, readResource, readEvidence, readBlob }) {
+  if (input?.operation !== undefined && !["select", "bind"].includes(input.operation)) throw error("operation must be select or bind");
   if (typeof readResource !== "function") throw error("store-backed hardware baseline reader is required");
+  const bind = input?.operation === "bind" ? await prepareBind(input, { readResource, readBlob, readEvidence }) : null;
+  if (bind) readEvidence = bind.readEvidence;
+  const research = bind && record(input?.research) && !Array.isArray(input.research.candidates)
+    ? { ...input.research, candidates: bind.proposed.body.candidates } : input?.research;
+  if (!text(input?.hardware_selection_id) || !text(input?.hardware_selection_revision)) throw error("hardware selection id and revision are required");
   const baseline = await readResource(input.hardware_selection_id);
-  if (!baseline || baseline.kind !== "hardware-selection" || baseline.body?.status !== "verified") throw error("hardware baseline must be an existing verified hardware-selection resource");
+  if (!baseline || baseline.kind !== "hardware-selection" || (baseline.body?.status !== "verified" && !bind?.allowUnverified)) throw error("hardware baseline must be an existing verified hardware-selection resource");
   if (baseline.body.revision !== input.hardware_selection_revision) throw error("hardware selection revision is stale");
   const models = baseline.body.selected_models;
   if (!Array.isArray(models) || !models.length || models.some(item => !text(item?.component_id) || !text(item?.manufacturer) || !text(item?.model))) throw error("hardware baseline needs exact component IDs, manufacturers and models");
   if (!record(research)) throw error("research is required");
   const bindings = array(research.bindings, "bindings");
   const candidates = array(research.candidates, "candidates");
-  const sources = array(research.sources, "sources");
+  const sources = bind ? await Promise.all(array(research.sources, "sources").map(bind.withReceipt)) : array(research.sources, "sources");
   const unavailableSources = array(research.unavailable_sources, "unavailable_sources");
   const unknowns = array(research.unknowns, "unknowns");
   const blockingUnknowns = [...array(research.blocking_unknowns, "blocking_unknowns")];
+  if (bind && baseline.body.status !== "verified") blockingUnknowns.push(`hardware baseline is ${baseline.body.status ?? "unverified"}; the binding stays to be confirmed`);
   const issues = [];
   const check = (condition, path, message) => { if (!condition) issues.push({ path, message }); };
   const hardwareIds = new Set(models.map(item => item.component_id));
@@ -69,7 +122,7 @@ export async function finalizeAlgorithmSelection({ input, readResource, readEvid
     if (text(limit?.id)) constraints.add(limit.id);
   }
   const sourceMap = new Map();
-  const primaryTypes = new Set(["hardware_vendor", "implementation_official", "huggingface", "cloud_vendor"]);
+  const primaryTypes = new Set(PRIMARY_SOURCE_TYPES);
   let retrievalVerified = sources.length > 0;
   for (const [index, source] of sources.entries()) {
     const at = `sources[${index}]`;
@@ -94,6 +147,8 @@ export async function finalizeAlgorithmSelection({ input, readResource, readEvid
     if (!record(binding)) continue;
     seen.add(binding.reaction_id);
     check(text(binding.implementation_ref) && pinned(binding.implementation_version), at, "implementation needs a stable reference and pinned version");
+    if (bind) check(values(bind.proposed.body.candidates).some(item => item?.reaction_id === binding.reaction_id && item.implementation_ref === binding.implementation_ref),
+      at, "binding must pick one of the proposed candidates of its reaction (same implementation_ref)");
     check(["firmware", "library", "model", "cloud_service"].includes(binding.implementation_type), at, "implementation_type is invalid");
     check(["edge", "cloud", "hybrid"].includes(binding.execution_target), at, "execution_target is invalid");
     const ids = values(binding.hardware_component_ids);
@@ -102,7 +157,7 @@ export async function finalizeAlgorithmSelection({ input, readResource, readEvid
     const cited = values(binding.source_ids).map(id => sourceMap.get(id)).filter(Boolean);
     for (const id of ids) check(cited.some(source => source.source_type === "hardware_vendor" && values(source.hardware_component_ids).includes(id)), at, `missing exact-device manufacturer evidence: ${id}`);
     check(cited.some(source => ["implementation_official", "huggingface", "cloud_vendor"].includes(source.source_type) && source.implementation_ref === binding.implementation_ref && source.version === binding.implementation_version), at, "missing matching implementation-version evidence");
-    for (const key of ["io", "runtime", "dependencies", "network", "license", "resources"]) {
+    for (const key of COMPATIBILITY_KEYS) {
       const evidence = binding.compatibility?.[key];
       check(evidence?.status === "pass" && text(evidence.summary) && sourceRefs(evidence.source_ids), `${at}.compatibility.${key}`, "compatibility requires a passing evidence-backed assessment");
     }
@@ -127,6 +182,7 @@ export async function finalizeAlgorithmSelection({ input, readResource, readEvid
     hardware_selection_revision: input.hardware_selection_revision,
     hardware_selection_digest: baseline.meta?.digest ?? `sha256:${digest(baseline.body)}`,
     requirements: input.requirements ?? {}, reactions, research, quality_issues: issues,
+    ...(bind ? { operation: "bind", proposed_id: input.proposed_id } : {}),
   };
   const hash = digest(stable);
   return {
@@ -135,6 +191,7 @@ export async function finalizeAlgorithmSelection({ input, readResource, readEvid
     hardware_selection_id: input.hardware_selection_id,
     hardware_selection_revision: input.hardware_selection_revision,
     hardware_selection_digest: stable.hardware_selection_digest,
+    ...(bind ? { operation: "bind", proposed_id: input.proposed_id } : {}),
     source_snapshot: `research:${hash.slice(0, 16)}`,
     revision: `r-${hash.slice(0, 12)}`,
     bindings, candidates, sources,

package/skills/abelien-algorithm/scripts/lane-state.mjs

@@ -0,0 +1,27 @@
+// algorithm.lane-state（P2-03 算法并行车道）：只读。宿主在每个自动阶段开跑前调用，按本草稿工作目录里已存的资源回答
+// 「当前需求有没有已提议的候选」「这些候选有没有绑定到当前硬件」。需求是否相同按 algorithm.research 的同一规范化规则
+// 判断（落点、reaction、limits），宿主不必复制这条规则；结果映射成 workspace.lanes-next 的 artifacts。
+import { text, record, digest } from "../../abelien-harness/scripts/web/common.mjs";
+import { readRequirements, invalid } from "./evidence.mjs";
+
+const sameRequirements = (body, wanted) => digest({ context: body.context ?? null, reactions: body.reactions ?? [], limits: body.limits ?? [] }) === digest(wanted);
+const newest = list => [...list].sort((a, b) => String(b.meta?.updatedAt ?? "").localeCompare(String(a.meta?.updatedAt ?? "")))[0] ?? null;
+
+export async function algorithmLaneState({ input, listResources }) {
+  if (!record(input) || Object.keys(input).some(key => !["requirements", "hardware_selection_id", "hardware_selection_revision"].includes(key))) invalid("input accepts requirements, hardware_selection_id and hardware_selection_revision only");
+  if (typeof listResources !== "function") throw Object.assign(new Error("store listing is required"), { code: "ALGORITHM_HOST" });
+  const hasHardware = input.hardware_selection_id !== undefined && input.hardware_selection_id !== null;
+  if (hasHardware && (!text(input.hardware_selection_id) || !input.hardware_selection_id.startsWith("hardware-selection:") || !text(input.hardware_selection_revision)))
+    invalid("hardware_selection_id must be a hardware-selection resource ID with its revision");
+  const normalized = readRequirements(input.requirements);
+  const wanted = { context: normalized.context, reactions: normalized.reactions, limits: normalized.limits };
+  const proposed = newest(listResources("algorithm-research").filter(item => item.body?.status === "proposed" && sameRequirements(item.body, wanted)));
+  const selection = proposed && hasHardware ? newest(listResources("algorithm-selection").filter(item => item.body?.operation === "bind" && item.body.proposed_id === proposed.id
+    && item.body.hardware_selection_id === input.hardware_selection_id && item.body.hardware_selection_revision === input.hardware_selection_revision)) : null;
+  return {
+    requirements_digest: digest(wanted),
+    proposed_id: proposed?.id ?? null,
+    selection_id: selection?.id ?? null,
+    selection_status: selection?.body.status ?? null,
+  };
+}