abelien-harness 0.9.0 → 0.10.0

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-harness/scripts/ab.mjs

@@ -64,6 +64,32 @@ export function createStore(workdir) {
   const logFile = path.join(dirs.log, "operations.jsonl");
 
   const readIndex = () => readJson(indexFile);
+  // Index writes are read-modify-write. Two ab processes on one workdir (a host running a parallel lane next to the
+  // main line, P2-03) would otherwise lose each other's entries, so every index write holds a short cross-process lock.
+  const lockFile = path.join(dirs.store, ".index.lock");
+  const pause = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  const alive = pid => { try { process.kill(pid, 0); return true; } catch (error) { return error.code === "EPERM"; } };
+  function withIndexLock(task) {
+    const deadline = Date.now() + 10000;
+    for (let attempt = 0; ; attempt++) {
+      let fd;
+      try { fd = fs.openSync(lockFile, "wx", 0o600); } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        // Index writes take milliseconds: a lock whose holder is gone, or older than 30 s, was left by a crash.
+        let stale = false;
+        try {
+          const owner = JSON.parse(fs.readFileSync(lockFile, "utf8"));
+          stale = !Number.isSafeInteger(owner.pid) || !alive(owner.pid) || Date.now() - owner.at > 30000;
+        } catch { try { stale = Date.now() - fs.statSync(lockFile).mtimeMs > 30000; } catch { /* already released */ } }
+        if (stale) { fs.rmSync(lockFile, { force: true }); continue; }
+        if (Date.now() > deadline) throw fail("STORE_LOCKED", "resource index is held by another process; retry the command");
+        pause(Math.min(50, 5 * (attempt + 1)));
+        continue;
+      }
+      try { fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() })); } finally { fs.closeSync(fd); }
+      try { return task(); } finally { fs.rmSync(lockFile, { force: true }); }
+    }
+  }
   const appendLog = entry =>
     fs.appendFileSync(logFile, canonicalJson({ ts: new Date().toISOString(), ...entry }) + "\n");
   const blobFile = digest => path.join(dirs.blobs, `${digest}.json`);
@@ -78,6 +104,9 @@ export function createStore(workdir) {
   function put(kind, localId, body) {
     if (!KIND_RE.test(kind)) throw fail("INVALID_KIND", `bad kind: ${kind}`);
     if (typeof localId !== "string" || !localId) throw fail("INVALID_ID", "localId must be a non-empty string");
+    return withIndexLock(() => putLocked(kind, localId, body));
+  }
+  function putLocked(kind, localId, body) {
     const id = `${kind}:${localId}`;
     const digest = sha256Hex(canonicalJson(body));
     const now = new Date().toISOString();
@@ -116,6 +145,9 @@ export function createStore(workdir) {
     return ref;
   }
   function setMachineState(id, machineName, state) {
+    return withIndexLock(() => setMachineStateLocked(id, machineName, state));
+  }
+  function setMachineStateLocked(id, machineName, state) {
     const index = readIndex();
     const entry = index.resources[id];
     if (!entry) throw fail("INSTANCE_NOT_FOUND", `machine instance not found: ${id}`, { id });
@@ -135,6 +167,9 @@ export function createStore(workdir) {
       .map(([id, e]) => assemble(id, e, readJson(blobFile(e.digest)).body));
   }
   function remove_(id) {
+    return withIndexLock(() => removeLocked(id));
+  }
+  function removeLocked(id) {
     const index = readIndex();
     if (!index.resources[id]) return false;
     delete index.resources[id];
@@ -170,7 +205,7 @@ export function createStore(workdir) {
 // doctor must report the shipped package version, never a frozen constant (0.2.3 drifted across
 // six releases). The npm tree always ships package.json at the skill root; standalone skill copies
 // fall back to FALLBACK_VERSION, which scripts/release-check.mjs pins to package.json.
-const FALLBACK_VERSION = "0.8.0";
+const FALLBACK_VERSION = "0.10.0";
 export let VERSION = FALLBACK_VERSION;
 try {
   VERSION = String(JSON.parse(fs.readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version || FALLBACK_VERSION);
@@ -539,7 +574,7 @@ async function moduleAdapter(a, ctx) {
     throw fail("ADAPTER_MODULE", `module adapter export not found: ${exportName}`, { path: a.path, export: exportName });
   }
   try {
-    return await handler({ input: ctx.input ?? {}, env: ctx.env ?? {}, fetchImpl: ctx.fetchImpl ?? fetch, readResource: ctx.readResource, readEvidence: ctx.readEvidence, readBlob: ctx.readBlob, writeBlob: ctx.writeBlob, ports: ctx.ports, checkpoint: ctx.checkpoint });
+    return await handler({ input: ctx.input ?? {}, env: ctx.env ?? {}, fetchImpl: ctx.fetchImpl ?? fetch, readResource: ctx.readResource, readEvidence: ctx.readEvidence, readBlob: ctx.readBlob, writeBlob: ctx.writeBlob, listResources: ctx.listResources, ports: ctx.ports, checkpoint: ctx.checkpoint });
   } catch (e) {
     // Node 系统错误（EACCES、ENOENT 等）的 message 带绝对路径。stdout 只留 code 与 syscall；
     // 原文仅在显式 AB_DEBUG=1 时写到 stderr。错误码不变，结构仍是 {code,message}。
@@ -623,7 +658,7 @@ export async function runCapability(deps, capability, args = {}) {
     if (typeof deps.onCheckpoint === "function") deps.onCheckpoint(checkpointResource);
     return checkpointResource;
   } : undefined;
-  const baseCtx = { readBlob: ref => deps.store.getContent(ref), writeBlob: hit.cap.checkpoint === true ? value => deps.store.putContent(value) : undefined, input: args.input ?? {}, resource, env: deps.env ?? {}, fetchImpl: deps.fetchImpl, readResource, readEvidence, ports: deps.modulePorts?.[capability], checkpoint };
+  const baseCtx = { readBlob: ref => deps.store.getContent(ref), listResources: kind => deps.store.list({ kind }), writeBlob: hit.cap.checkpoint === true ? value => deps.store.putContent(value) : undefined, input: args.input ?? {}, resource, env: deps.env ?? {}, fetchImpl: deps.fetchImpl, readResource, readEvidence, ports: deps.modulePorts?.[capability], checkpoint };
   const adapterInput = hit.cap.input?.from ? dotGet(baseCtx, hit.cap.input.from) : baseCtx.input;
   const decl = resolveAdapter(hit.d, hit.cap.adapter);
   const result = await runAdapter(decl, { ...baseCtx, input: adapterInput });

package/skills/abelien-workspace/assets/lane-plan.json

@@ -0,0 +1,36 @@
+{
+  "plan_version": "2026-10-14.2",
+  "description": "与主线阶段并行的车道。宿主在每个自动阶段开跑时调用 workspace.lanes-next，按返回的步骤在同一 run 里并发执行，不阻塞主线；车道结果不反向约束主线（2026-10-12 碰头会：算法依赖本阶段冻结，不约束硬件选型）。",
+  "artifacts": ["algorithm_proposed", "hardware", "algorithm_selection"],
+  "lanes": {
+    "algorithm": {
+      "starts_with": ["hardware", "real_image"],
+      "steps": {
+        "research": {
+          "goal": "需求明确后立即检索每个 reaction 可用的实现，与硬件选型同时进行",
+          "needs": [],
+          "produces": "algorithm_proposed",
+          "directives": [
+            "只凭本次需求的 reaction、limits 和落点检索，不等硬件，也不猜硬件型号；离线、隐私、延迟、费用等硬约束从一开始就用来筛选。",
+            "先看宿主给出的库内已适配算法，能满足 reaction 的优先；库外再联网，顺序是实现官方资料（模型卡、SDK、发布记录）→ Hugging Face → 成熟云服务官方文档；博客、论坛与聚合文章只用来发现线索。",
+            "每个 reaction 用 1–2 条英文查询调用 algorithm.research（purpose=implementation，查询带 reaction_id），读正文后再判断，不凭检索摘要下结论。",
+            "用 algorithm.candidates 为每个 reaction 提交 1–3 个候选，格式按 abelien-algorithm 的 algorithm-candidates.v1 schema：implementation_ref 是简短名称（不带网址和说明，说明写 summary），implementation_version 只写来源写明的确定版本，没写就填 null；needs 按原文记录，没写的填 null；quotes 逐字取自本次研究读到的正文，同一份资料可以同时支撑几个 reaction。违反硬约束的不提交，确实找不到的写进 unresolved 并说明原因。",
+            "算法结果不反向约束硬件选型，也不阻塞首版 CAD；只记录资源需求，供硬件登记后绑定。"
+          ]
+        },
+        "bind": {
+          "goal": "硬件登记后，把每个 reaction 绑定到已选型号上的一个实现并复核兼容",
+          "needs": ["algorithm_proposed", "hardware"],
+          "produces": "algorithm_selection",
+          "directives": [
+            "读取已登记的 hardware-selection（id 与 revision）和已提议的候选；硬件尚未 verified 也照常绑定，结果会保持待确认。",
+            "先为主控等相关型号检索厂商官方资料：algorithm.research（purpose=hardware，查询带 component_id），看 SDK、runtime、算子支持、内存与外设接口。",
+            "每个 reaction 恰好选一个已提议的候选（implementation_ref 照抄），绑定到具体 component_id；逐项核对 io、runtime、dependencies、network、license、resources 和每条硬约束，各写 pass／conflict／unknown、理由与来源。格式按 algorithm-bindings.v1 schema：sources 只写 research_id 与 page_id 指向的正文页（search_snippet 不算），url、访问时间与哈希由 Harness 回填；source_type 按发布方选（所选型号厂商 hardware_vendor、实现官方 implementation_official、模型卡 huggingface、云服务官方 cloud_vendor），分销商、博客不是一手来源。",
+            "用 algorithm.finalize（operation=bind，proposed_id 为已提议候选）提交；证据不足就如实写 unknowns／blocking_unknowns，结果保持 needs_confirmation，不编造通过。",
+            "只有换硬件（算力或接口变化）才重新绑定；需求的 reaction 或 limits 变化才重新研究。"
+          ]
+        }
+      }
+    }
+  }
+}

package/skills/abelien-workspace/domain.json

@@ -1,6 +1,6 @@
 {
   "name": "abelien-workspace",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "作品旅程、PRD 与业务契约；user-journey 由 Agent 驱动，draft 供真实硬件阶段使用；不声明假 PRD、确认、报价或支付能力",
   "resources": [
     "draft"
@@ -28,6 +28,27 @@
           "completed"
         ]
       }
+    },
+    "workspace.lanes-next": {
+      "description": "给出当前自动阶段旁边要并发执行的车道步骤（目前是算法车道：research 与硬件选型同时开始，硬件登记后 bind）及该步骤的领域规则；纯计算，不联网、不写资源。规则来自 assets/lane-plan.json",
+      "adapter": {
+        "type": "module",
+        "path": "scripts/lanes-next.mjs",
+        "export": "lanesNext"
+      },
+      "input": {
+        "from": "input"
+      },
+      "resultContract": {
+        "nonEmptyStrings": [
+          "plan_version",
+          "intent",
+          "stage"
+        ],
+        "arrays": [
+          "lanes"
+        ]
+      }
     }
   },
   "machines": {},

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

@@ -0,0 +1,38 @@
+// workspace.lanes-next（P2-03 算法并行车道）：给出当前自动阶段旁边要并发执行的车道步骤及其领域规则。
+// 纯函数：不联网、不写资源、不读宿主状态。车道从哪个主线阶段开始、每步需要什么、带什么规则都只来自
+// assets/lane-plan.json；宿主把已有产物映射为 artifacts 后调用，按返回的步骤在同一 run 里并发执行。
+import { readFileSync } from "node:fs";
+import { PLAN as JOURNEY } from "./journey-next.mjs";
+
+const deepFreeze = value => {
+  if (value !== null && typeof value === "object") { for (const child of Object.values(value)) deepFreeze(child); Object.freeze(value); }
+  return value;
+};
+export const LANES = deepFreeze(JSON.parse(readFileSync(new URL("../assets/lane-plan.json", import.meta.url), "utf8")));
+const invalid = message => { throw Object.assign(new Error(message), { code: "VALIDATION" }); };
+const record = value => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** A lane runs from the first of its starts_with stages present in this intent's main line; side stages all come after it. */
+function laneActive(lane, intent, stage) {
+  if (JOURNEY.side.includes(stage)) return true;
+  const order = JOURNEY.orders[intent];
+  const start = lane.starts_with.map(name => order.indexOf(name)).find(index => index >= 0);
+  return start !== undefined && order.indexOf(stage) >= start;
+}
+
+export function lanesNext({ input }) {
+  if (!record(input) || Object.keys(input).some(key => !["intent", "stage", "artifacts"].includes(key))) invalid("input accepts intent, stage and artifacts only");
+  if (!Object.hasOwn(JOURNEY.orders, input.intent)) invalid(`intent must be one of ${Object.keys(JOURNEY.orders).join(", ")}`);
+  const allowed = [...JOURNEY.orders[input.intent], ...JOURNEY.side];
+  if (!allowed.includes(input.stage)) invalid(`stage for ${input.intent} must be one of ${allowed.join(", ")}`);
+  const artifacts = input.artifacts ?? {};
+  if (!record(artifacts) || Object.entries(artifacts).some(([key, value]) => !LANES.artifacts.includes(key) || typeof value !== "boolean")) invalid(`artifacts must map ${LANES.artifacts.join(", ")} to booleans`);
+  const lanes = [];
+  for (const [name, lane] of Object.entries(LANES.lanes)) {
+    if (!laneActive(lane, input.intent, input.stage)) continue;
+    // The first step whose output is missing and whose inputs are all present; a lane does one step per stage.
+    const step = Object.entries(lane.steps).find(([, entry]) => artifacts[entry.produces] !== true && entry.needs.every(need => artifacts[need] === true));
+    if (step) lanes.push({ lane: name, step: step[0], goal: step[1].goal, directives: [...step[1].directives] });
+  }
+  return { plan_version: LANES.plan_version, intent: input.intent, stage: input.stage, lanes };
+}