abelien-harness 0.9.0 → 0.11.0

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,
+  };
+}

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

@@ -0,0 +1,203 @@
+// algorithm.research（P2-03 算法并行车道）：按 Agent 的检索计划执行确定性的收集——Volc 检索与公开页面安全直读——
+// 全部落为证据，不做选择。两种用途：implementation 只凭需求检索实现资料，可与硬件选型同时开始；hardware 在硬件
+// 登记后检索已选型号的厂商资料，查询必须指向选型资源里的 component_id。
+// 付费检索逐条「先存 sent 再发送」，与 reference.research 同一规则：重跑复用已完成的检索，停在 sent 而没有结果的
+// 检索要求对账，绝不自动重发；同一请求完成后重复运行直接返回已有结果。
+import { Buffer } from "node:buffer";
+import { text, record, digest, sha256, failure } from "../../abelien-harness/scripts/web/common.mjs";
+import { decodeBody } from "../../abelien-harness/scripts/web/public-read.mjs";
+import { SCHEMA, PURPOSES, RESEARCH_SHAPE, LIMITS, reader, volc, invalid, words, readRequirements, validateResearch } from "./evidence.mjs";
+
+const reconcile = message => failure("ALGORITHM_WEB_RECONCILIATION_REQUIRED", message);
+
+function readLibrary(library) {
+  if (library === undefined || library === null) return [];
+  if (!Array.isArray(library) || library.length > LIMITS.library) invalid(`library must list up to ${LIMITS.library} in-library algorithms`);
+  const ids = new Set();
+  return library.map((entry, index) => {
+    if (!record(entry) || !text(entry.entry_id) || ids.has(entry.entry_id)) invalid(`library[${index}] needs a unique entry_id`);
+    ids.add(entry.entry_id);
+    return { entry_id: entry.entry_id, name: words(entry.name, `library[${index}].name`, 200), category: text(entry.category) ? entry.category.trim().slice(0, 200) : null };
+  });
+}
+
+/** The hardware the vendor queries may name: exact models of a hardware-selection resource, verified or not. */
+async function readHardware(input, readResource) {
+  if (!text(input.hardware_selection_id) || !text(input.hardware_selection_revision)) invalid("hardware research needs hardware_selection_id and hardware_selection_revision");
+  const resource = await readResource(input.hardware_selection_id);
+  if (!resource || resource.kind !== "hardware-selection" || resource.body?.revision !== input.hardware_selection_revision) invalid("hardware selection is missing or its revision is stale");
+  const models = Array.isArray(resource.body.selected_models) ? resource.body.selected_models : [];
+  if (!models.length || models.some(item => !text(item?.component_id) || !text(item?.manufacturer) || !text(item?.model))) invalid("hardware selection needs exact component IDs, manufacturers and models");
+  return { selection_id: input.hardware_selection_id, revision: input.hardware_selection_revision, status: resource.body.status ?? null,
+    models: models.map(item => ({ component_id: item.component_id, manufacturer: item.manufacturer, model: item.model })) };
+}
+
+export function validateResearchInput(input) {
+  if (!record(input)) invalid("input must be an object");
+  const allowed = ["purpose", "requirements", "library", "hardware_selection_id", "hardware_selection_revision", "plan"];
+  if (Object.keys(input).some(key => !allowed.includes(key))) invalid("input has unsupported fields");
+  if (!PURPOSES.includes(input.purpose)) invalid(`purpose must be one of ${PURPOSES.join(", ")}`);
+  const plan = input.plan ?? {};
+  if (!record(plan) || Object.keys(plan).some(key => !["queries", "max_pages"].includes(key))) invalid("plan has unsupported fields");
+  const queries = plan.queries ?? [];
+  if (!Array.isArray(queries) || !queries.length || queries.length > LIMITS.queries) invalid(`plan.queries must list 1–${LIMITS.queries} queries`);
+  const maxPages = plan.max_pages === undefined ? 8 : plan.max_pages;
+  if (!Number.isSafeInteger(maxPages) || maxPages < 0 || maxPages > LIMITS.pages) invalid(`plan.max_pages must be 0–${LIMITS.pages}`);
+  return { purpose: input.purpose, requirements: readRequirements(input.requirements), library: input.purpose === "implementation" ? readLibrary(input.library) : [],
+    queries, maxPages };
+}
+
+/** Interleave search results so one query cannot use the whole page budget; counts what the cap left unread. */
+function pageQueue(searches, max) {
+  const queue = [], seen = new Set();
+  let skipped = 0;
+  for (let rank = 0; ; rank++) {
+    let added = false;
+    for (const search of searches) {
+      const result = search.results[rank];
+      if (!result) continue;
+      added = true;
+      let url;
+      try { url = reader.normalizePublicSourceUrl(result.url).href; } catch { continue; }
+      if (seen.has(url)) continue;
+      seen.add(url);
+      if (queue.length < max) queue.push({ url, search, title: result.title, snippet: result.snippet ?? "" }); else skipped++;
+    }
+    if (!added) break;
+  }
+  return Object.assign(queue, { skipped });
+}
+
+async function pool(list, task, limit = LIMITS.concurrency) {
+  const out = new Array(list.length); let next = 0, failed = false;
+  await Promise.all(Array.from({ length: Math.min(limit, list.length) }, async () => {
+    while (!failed && next < list.length) {
+      const index = next++;
+      try { out[index] = await task(list[index], index); } catch (error) { failed = true; throw error; }
+    }
+  }));
+  return out;
+}
+
+export async function researchAlgorithms({ input, env = {}, fetchImpl, readResource, writeBlob, ports = {}, checkpoint }) {
+  const request = validateResearchInput(input);
+  if (typeof writeBlob !== "function" || typeof readResource !== "function") throw failure("ALGORITHM_HOST", "trusted content writer and resource reader are required");
+  const hardware = request.purpose === "hardware" ? await readHardware(input, readResource) : null;
+  const reactionIds = new Set(request.requirements.reactions.map(item => item.id));
+  const componentIds = new Set(hardware?.models.map(item => item.component_id) ?? []);
+  const queries = request.queries.map((q, index) => {
+    const at = `plan.queries[${index}]`;
+    if (!record(q) || Object.keys(q).some(key => !["reaction_id", "component_id", "query", "count"].includes(key))) invalid(`${at} has unsupported fields`);
+    const query = words(q.query, `${at}.query`, LIMITS.queryChars);
+    if (q.count !== undefined && (!Number.isSafeInteger(q.count) || q.count < 1 || q.count > LIMITS.count)) invalid(`${at}.count must be 1–${LIMITS.count}`);
+    // Implementation queries belong to one reaction; vendor queries to one selected model.
+    if (request.purpose === "implementation" && (!reactionIds.has(q.reaction_id) || q.component_id !== undefined)) invalid(`${at} must name one requirements reaction_id and no component_id`);
+    if (request.purpose === "hardware" && (!componentIds.has(q.component_id) || (q.reaction_id !== undefined && !reactionIds.has(q.reaction_id)))) invalid(`${at} must name a selected component_id`);
+    return { reaction_id: q.reaction_id ?? null, component_id: q.component_id ?? null, query, count: q.count ?? LIMITS.count };
+  });
+  const requestDigest = digest({ purpose: request.purpose, requirements: request.requirements, library: request.library, hardware, queries, max_pages: request.maxPages, shape: RESEARCH_SHAPE });
+  const id = `alg-res-${requestDigest.slice(0, 16)}`;
+  const existing = await readResource(`algorithm-research:${id}`);
+  if (existing?.body?.status === "collected" && existing.body.request_digest === requestDigest) {
+    try { return validateResearch(existing.body); } catch { throw reconcile("saved research fails the current contract; reconcile it instead of re-running the paid searches"); }
+  }
+  const sameQuery = (entry, q, index) => record(entry) && entry.id === `s${index + 1}` && entry.query === q.query && entry.count === q.count
+    && entry.reaction_id === q.reaction_id && entry.component_id === q.component_id;
+  if (existing && (existing.body?.status !== "in_progress" || existing.body.request_digest !== requestDigest || !Array.isArray(existing.body.searches)
+    || existing.body.searches.length > queries.length || existing.body.searches.some((entry, index) => !sameQuery(entry, queries[index], index))))
+    throw reconcile("saved research does not match this request; reconcile the original invocation instead of re-running it");
+  // Fail before anything is marked sent: a missing or malformed key cannot have produced a charge.
+  if (!text(env.WEB_SEARCH_API_KEY) || /[\r\n\0]/.test(env.WEB_SEARCH_API_KEY)) throw failure("ALGORITHM_WEB_CONFIG", "WEB_SEARCH_API_KEY is required from the trusted host");
+  if (typeof checkpoint !== "function") throw failure("ALGORITHM_WEB_CHECKPOINT_REQUIRED", "paid search IO requires the original resource store checkpoint");
+  let expectedDigest = existing?.meta?.digest ?? null;
+  const save = async body => { expectedDigest = (await checkpoint(body, { expectedDigest })).meta.digest; };
+
+  const unknowns = [];
+  const base = { id, schema: SCHEMA, request_digest: requestDigest, purpose: request.purpose, context: request.requirements.context,
+    reactions: request.requirements.reactions, limits: request.requirements.limits, library: request.library, hardware };
+  const progress = { ...base, status: "in_progress", searches: structuredClone(existing?.body.searches ?? []), pages: [], unknowns: [] };
+  const searches = progress.searches;
+  const keepReceipt = (entry, saved) => {
+    if (!saved || typeof saved.raw !== "string") return;
+    if (saved.raw.includes(env.WEB_SEARCH_API_KEY)) throw failure("ALGORITHM_WEB_RESPONSE", "search receipt still contains the key after redaction");
+    Object.assign(entry, { request_id: saved.request_id ?? null, receipt_sha256: saved.raw_sha256, receipt_blob_ref: writeBlob({ text: saved.raw }), response_sha256: saved.response_sha256 ?? null, http_status: saved.http_status ?? null, received_at: saved.received_at ?? null });
+  };
+  for (const [index, q] of queries.entries()) {
+    let entry = searches[index];
+    if (entry && ["completed", "failed"].includes(entry.status)) {
+      if (entry.status === "completed" && !entry.results.length) unknowns.push(`检索「${q.query}」没有结果`);
+      if (entry.status === "failed") unknowns.push(`检索「${q.query}」失败（${entry.error_code}）`);
+      continue;
+    }
+    if (entry?.dispatch_state === "sent") throw reconcile(`search ${entry.id} was sent but its outcome was never saved; reconcile it with the provider, it is not resent`);
+    const body = volc.volcQueryRequest({ query: q.query, count: q.count });
+    volc.validateVolcCapability(body);
+    entry = { id: `s${index + 1}`, reaction_id: q.reaction_id, component_id: q.component_id, query: q.query, count: q.count, request: body, dispatch_state: "sent",
+      sent_at: new Date().toISOString(), status: "in_progress", error_code: null, outcome: null, request_id: null, receipt_sha256: null, receipt_blob_ref: null, results: [] };
+    searches[index] = entry;
+    await save(progress);
+    try {
+      const saved = await volc.volcWebSearch(body, { env, fetchImpl, timeoutMs: LIMITS.searchTimeoutMs });
+      keepReceipt(entry, saved);
+      entry.status = "completed"; entry.outcome = "received";
+      entry.results = (saved.response.Result.WebResults ?? []).filter(r => text(r?.Url)).map((r, rank) => ({ rank: rank + 1, url: r.Url, title: String(r.Title ?? ""), snippet: String(r.Snippet ?? r.Summary ?? "").slice(0, 300) }));
+      if (!entry.results.length) unknowns.push(`检索「${q.query}」没有结果`);
+    } catch (error) {
+      if (!String(error?.code ?? "").startsWith("ALGORITHM_WEB_")) throw error;
+      keepReceipt(entry, error.providerEvidence);
+      entry.status = "failed"; entry.error_code = error.code; entry.outcome = error.ambiguous || !error.providerEvidence ? "unknown" : "rejected";
+      unknowns.push(`检索「${q.query}」失败（${entry.error_code}）`);
+    }
+    await save(progress);
+  }
+
+  const readOptions = { lookup: ports.lookup, pageRequest: ports.pageRequest, dnsRequest: ports.dnsRequest };
+  const queue = pageQueue(searches, request.maxPages);
+  const now = ports.now ?? Date.now, roundEnds = now() + LIMITS.pageRoundMs;
+  const readPage = async url => {
+    for (let attempt = 0; ; attempt++) {
+      const left = roundEnds - now();
+      if (left < LIMITS.pageConnectTimeoutMs) throw Object.assign(new Error("page round budget spent"), { code: "round_budget" });
+      try {
+        return await reader.fetchPublicPage(url, { ...readOptions, timeoutMs: Math.min(LIMITS.pageTimeoutMs, left), connectTimeoutMs: LIMITS.pageConnectTimeoutMs, maxBytes: LIMITS.pageBytes });
+      } catch (error) {
+        const stage = reader.publicReadFailure(error)?.stage;
+        if (attempt || !["timeout", "transport"].includes(stage)) throw error;
+      }
+    }
+  };
+  const pages = await pool(queue, async (entry, index) => {
+    const page = { id: `p${index + 1}`, url: entry.url, final_url: null, search_id: entry.search.id, reaction_id: entry.search.reaction_id, component_id: entry.search.component_id,
+      status: "unavailable", reason: null, title: entry.title ?? "", fetched_at: null, text_blob_ref: null, text_sha256: null, text_source: null, excerpt: "" };
+    try {
+      const read = await readPage(entry.url);
+      Object.assign(page, { status: read.status, reason: read.reason, final_url: read.final_url, fetched_at: read.fetched_at ?? null });
+      if (read.status === "read") {
+        const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(decodeBody(Buffer.from(read.raw_base64, "base64"), read.content_type))?.[1];
+        if (text(title)) page.title = title.replace(/\s+/g, " ").trim().slice(0, 200);
+        Object.assign(page, { text_blob_ref: writeBlob({ text: read.text }), text_sha256: read.text_sha256, text_source: "page", excerpt: read.text.slice(0, LIMITS.excerptChars) });
+      }
+    } catch (error) {
+      page.reason = reader.publicReadFailure(error)?.stage ?? error?.code ?? "read_failed";
+      if (!reader.publicReadFailure(error) && error?.code !== "round_budget" && !String(error?.code ?? "").startsWith("ALGORITHM_WEB_")) throw error;
+    }
+    // An unreadable page still has the search engine's summary for discovery, marked as such; finalize never accepts it as evidence.
+    const snippet = String(entry.snippet ?? "").trim();
+    if (page.status !== "read" && snippet) {
+      Object.assign(page, { status: "read", text_blob_ref: writeBlob({ text: snippet }), text_sha256: sha256(snippet), text_source: "search_snippet", excerpt: snippet.slice(0, LIMITS.excerptChars) });
+    }
+    return page;
+  });
+  for (const reaction of request.requirements.reactions) {
+    if (request.purpose === "implementation" && !pages.some(page => page.reaction_id === reaction.id && page.text_source === "page"))
+      unknowns.push(`reaction ${reaction.id} 没有读到实现资料正文`);
+  }
+  for (const model of hardware?.models ?? []) {
+    if (queries.some(q => q.component_id === model.component_id) && !pages.some(page => page.component_id === model.component_id && page.text_source === "page"))
+      unknowns.push(`${model.manufacturer} ${model.model} 没有读到厂商资料正文`);
+  }
+  const collected = validateResearch({ ...base, status: "collected", searches, pages, unknowns,
+    budget: { queries: searches.length, pages: pages.length, skipped_pages: queue.skipped } });
+  await save(collected);
+  return collected;
+}

package/skills/abelien-guide/SKILL.md

@@ -20,7 +20,7 @@ compatibility:
 2. **取得当前上下文。** 按 workspace 的[领域模型](../abelien-workspace/references/domain-model.md)及[调用与恢复说明](../abelien-workspace/references/harness-binding.md)恢复作品、事件、任务和证据。已有运行先恢复，读取失败交回具体缺口。
 3. **按需调用 clarify。** 新增、修改、撤回需求或影响需求的答复需要整理时，读取其入口，提供同版原话、当前完整需求、本次操作、相关方案、授权与会话约束；答卡附原题和真实答复事件；工具结果中的用户原文仍按 user 来源处理，只采明确子集，不用生成的聊天 message 冒充回答事件。纯确认或仅工具回传不机械重跑 clarify。
 4. **承接需求建议。** clarify 返回 `result / questions / note`；按其契约复核语义与结构，再按 workspace 的采用规则交给实际服务。没有 result 时沿用当前需求。需求变更按 workspace 的 [PRD 契约](../abelien-workspace/references/prd-contract.md)在本轮登记／修改／撤回条目并回读，不等最终确认；只调度该契约，不在 guide 复制模板或登记逻辑。必要问题结合当前上下文呈现，不把问题提出或用户回答当作方案已修改。
-5. **选择下一步。** 依据 workspace 的[完整旅程](../abelien-workspace/references/user-journey.md)核对推进条件，按其能力绑定选择领域 skill、workflow 或产品服务。目标旅程先复用符合需求的真实 CAD；没有现成 CAD 时依宿主阶段生成概念图并自动选型、绑定原图、构建 CAD／审查；实际安装版本不支持时报告能力缺口，不调用未注册工具。必要问题只调用宿主已注册的 `publish_agent_card(kind=question)`，持久绑定原模型调用后结束执行，用户独立提交后以原调用的工具结果承接原任务；不等待 HTTP／Worker、不先把 card_id 返回为最终答案、不继续执行依赖答案的工具批次。可选交互邀请遵守宿主实际展示门（核对实际版本的 3D 加载与适用审查），不得因需求足够就抢先覆盖必要问题卡；按旅程 §4.1 的通用目标告知随时可收尾，不插入需求版 PRD 展示关卡。点击“随时收尾”后按 §4.2 调用宿主成果体验模式，核对仿真或 Three.js 行为演示能力，并保留 PRD 查看／导出入口。调用前读对应 skill；能力不存在时报告具体缺口。实际能力返回后回到当前事实重判，不自行选择型号、算法或编造工程结论。
+5. **选择下一步。** 依据 workspace 的[完整旅程](../abelien-workspace/references/user-journey.md)核对推进条件。A1 通过之后到交付首版这一段，下一阶段与该阶段的规则、允许动作一律取 `workspace.journey-next` 的返回，不凭记忆或旅程摘要自排阶段；再按能力绑定选择领域 skill、领域 workflow 或产品服务。目标旅程先复用符合需求的真实 CAD；没有现成 CAD 时按阶段计划生成概念图并自动选型、绑定原图、构建 CAD／审查；实际安装版本不支持时报告能力缺口，不调用未注册工具。必要问题只调用宿主已注册的 `publish_agent_card(kind=question)`，持久绑定原模型调用后结束执行，用户独立提交后以原调用的工具结果承接原任务；不等待 HTTP／Worker、不先把 card_id 返回为最终答案、不继续执行依赖答案的工具批次。可选交互邀请遵守宿主实际展示门（核对实际版本的 3D 加载与适用审查），不得因需求足够就抢先覆盖必要问题卡；按旅程 §4.1 的通用目标告知随时可收尾，不插入需求版 PRD 展示关卡。点击“随时收尾”后按 §4.2 调用宿主成果体验模式，核对仿真或 Three.js 行为演示能力，并保留 PRD 查看／导出入口。调用前读对应 skill；能力不存在时报告具体缺口。实际能力返回后回到当前事实重判，不自行选择型号、算法或编造工程结论。
 6. **向用户交代结果。** 根据真实产物说明本次变化、当前缺口和下一步，区分 PRD 已登记的需求与仍待实现／检查的方案；没有写入回执就明确尚未保存。首版展示、必要取舍及确认邀请的时机均采用 workspace 规则；表达方式采用共用表达规则。
 
 图片、链接或“做同款”仍走同一入口，不自动开启另一条整机还原流程。入口按本轮意图调度：还原现成产品（restore）、创造新产品（create）或基于现成产品修改（modify）共用同一旅程，差别只在首先展示什么、参考资料怎么用、哪些特征锁定，依据是原话而不是输入形式，详见[意图路由](../../docs/architecture/intent-routing.md)。还原与改现成先识别产品，展示原产品图及来源后继续；新创先参考相似产品再出概念图，用户已有明确设计图时直接沿用。意图、目标深度与识别结果在首版之前不单独发问：按推断继续，作为系统假设展示并可随时修改；型号识别冲突时保留候选，用户切换即视为需求修订。改轮廓、颜色、材质、表面语言或参考匹配时调用 [appearance](../abelien-appearance/SKILL.md)；空间约束、布局、装配、Build123d 或几何检查调用 [structure](../abelien-structure/SKILL.md)。外壳形状同时涉及两者时，由 appearance 定义目标、structure 实现并回传实际渲染、appearance 做视觉验收。只把必须由用户决定的差异交回用户，不让内部视觉审查成为额外的必答关卡。
@@ -41,6 +41,6 @@ compatibility:
 
 原生答卡按[问题工具接续契约](../../docs/architecture/question-card.md)消费：选项 ID 和自由原文走原 toolCallId 的 tool 结果，不能包装成新 User 消息。旧卡缺可信原调用时只走明确旧协议或说明缺口；不伪造调用，不把答卡、暂停追问或物理接续 run 当作品确认。可选交互邀请沿用非阻塞接口，不使用必要问题的等待机制。
 
-workflow 的恢复、advance、cancel 及确认后的交接均按 workspace 的运行约定执行。guide 只消费真实回执，不把工具成功、需求建议或自己的总结当成作品已采用、已确认或已交付。
+领域 workflow 的恢复、advance、cancel 按 workspace 的运行约定执行；作品推进与确认后的交接由宿主回执决定，不推进任何 workflow。guide 只消费真实回执，不把工具成功、需求建议或自己的总结当成作品已采用、已确认或已交付。
 
 用户看到的是方案、变化、问题和产物；内部阶段编号、HTTL、cursor 与资源 ID 留在工作上下文。

package/skills/abelien-harness/references/workflow-spec.md

@@ -32,8 +32,7 @@ create 输入为 `schemaVersion:1, creationOperationId, inputRevision:0, manifes
   `args` 支持 `{{expr}}` 插值
 - `executor: "agent"`：`instruction` 必填；运行到此暂停（`awaiting_agent`），
   instruction 随实例返回给 agent
-- 可选 `completionGuard:"<domain-owned-name>"` 只适用于 agent step。advance 在任何持久化之前调用可信宿主 `verifyCompletion({guard,instance,result})`；只有显式 `{ok:true,receipt?}` 通过。未接解析器或不通过返回 `WORKFLOW_COMPLETION_REQUIRED`，原运行保持 awaiting_agent；宿主异常亦不写入。宿主必须回读业务事实，不能回显模型填的引用或 pass 布尔值。
-- `main(argv,{verifyCompletion})`、底层 workflow deps 接受该回调。内核不解释业务 guard 名称。当前 user-journey 声明 `workspace.confirmed-snapshot`；产品检查／同版确认／快照服务未接时禁止 done。未声明 guard 的一般工作流行为不变。
+- **范围：** 一条 workflow 只承载单一领域内的多步流程——`capability.run` 步骤只调用同一个能力命名空间（如全是 `hardware.*`），不跨领域串接。作品推进、采用、确认与交付由宿主持有，不写成 workflow；`completionGuard` 已移除，定义里出现即 `WORKFLOW_INVALID`。随包定义由 `test/workflow-scope.test.mjs` 把守。
 
 ## 运行实例（`.abelien/workflows/<runId>.json`）
 
@@ -188,7 +187,6 @@ abelien-harness receipt get --wait <waitId> --digest <resultDigest> --workdir <
 | `WORKFLOW_INVALID` | 步骤定义非法（id 重复、action/instruction 缺失等） |
 | `WORKFLOW_RUN_NOT_FOUND` | runId 不存在 |
 | `WORKFLOW_STATE` | 状态机非法转移（如 cancel 已终态的 run） |
-| `WORKFLOW_COMPLETION_REQUIRED` | 缺可信宿主完成校验或回读未通过；保持暂停 |
 | `WORKFLOW_DRIFTED` | 历史步骤形状与现行定义不同；只读恢复 |
 | `VALIDATION` | 必填 input 缺失 |
 | `RECEIPT_INVALID` / `RECEIPT_SIZE` | envelope 不符合 v1／超过大小边界 |