abelien-harness 0.8.0 → 0.9.0

package/skills/abelien-hardware/scripts/{tos-wiki-search.mjs → oss-wiki-search.mjs}

@@ -2,7 +2,7 @@ import zlib from "node:zlib";
 import { dimensionFields, evaluateDimensions, orderByDimensionTier, sameDimensionMetadata, screenDimensions, shortlistByDimensionTier, validateFitEnvelope, validateRequirementEnvelopes } from "./dimensions.mjs";
 import { electricalFields } from "./electrical.mjs";
 import { selectionRequestDigest, validCategoryPath } from "./selection-request.mjs";
-import { createTosConfig, getTosObject, sha256 } from "./tos-object-store.mjs";
+import { createOssConfig, getOssObject, sha256 } from "./oss-object-store.mjs";
 
 const SEARCH_CATALOG_SCHEMA = "abelien.hardware-wiki-search-catalog.v1";
 const SEARCH_INDEX_SCHEMA = "abelien.hardware-wiki-category-index.v1";
@@ -15,13 +15,13 @@ function error(code, message, details) {
 }
 
 async function getObject(config, key, fetchImpl, { optional = false } = {}) {
-  const object = await getTosObject(config, key, { fetchImpl, optional });
+  const object = await getOssObject(config, key, { fetchImpl, optional });
   if (!object) return null;
   const bytes = object.bytes;
   let content = bytes;
   if (key.endsWith(".gz") && bytes[0] === 0x1f && bytes[1] === 0x8b) {
     try { content = zlib.gunzipSync(bytes); }
-    catch { throw error("WIKI_SEARCH_INDEX_INVALID", "TOS category index is not valid gzip", { key }); }
+    catch { throw error("WIKI_SEARCH_INDEX_INVALID", "OSS category index is not valid gzip", { key }); }
   }
   return {
     text: content.toString("utf8"),
@@ -171,9 +171,9 @@ function parseJsonObject(object, code, message, key) {
 }
 
 function parseCatalog(object, key) {
-  const catalog = parseJsonObject(object, "WIKI_SEARCH_CATALOG_INVALID", "TOS hardware search catalog is not valid JSON", key);
+  const catalog = parseJsonObject(object, "WIKI_SEARCH_CATALOG_INVALID", "OSS hardware search catalog is not valid JSON", key);
   if (catalog?.schema !== SEARCH_CATALOG_SCHEMA || !Array.isArray(catalog.categories)) {
-    throw error("WIKI_SEARCH_CATALOG_INVALID", "TOS hardware search catalog has an unsupported shape", { key });
+    throw error("WIKI_SEARCH_CATALOG_INVALID", "OSS hardware search catalog has an unsupported shape", { key });
   }
   const categories = new Map();
   for (const descriptor of catalog.categories) {
@@ -195,9 +195,9 @@ function parseCategoryIndex(object, descriptor, key) {
   if (descriptor.sha256 && descriptor.sha256 !== object.raw_sha256) {
     throw error("WIKI_SEARCH_INDEX_INVALID", "category index SHA-256 does not match catalog", { key });
   }
-  const index = parseJsonObject(object, "WIKI_SEARCH_INDEX_INVALID", "TOS hardware category index is not valid JSON", key);
+  const index = parseJsonObject(object, "WIKI_SEARCH_INDEX_INVALID", "OSS hardware category index is not valid JSON", key);
   if (index?.schema !== SEARCH_INDEX_SCHEMA || !categoryMatches(index.category_path, descriptor.category_path) || !Array.isArray(index.records)) {
-    throw error("WIKI_SEARCH_INDEX_INVALID", "TOS hardware category index has an unsupported shape", { key });
+    throw error("WIKI_SEARCH_INDEX_INVALID", "OSS hardware category index has an unsupported shape", { key });
   }
   if (index.records.length !== descriptor.record_count) {
     throw error("WIKI_SEARCH_INDEX_INVALID", "category index record count does not match catalog", { key });
@@ -327,7 +327,7 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
   const results = [];
   const unmatchedSlots = [];
   const shardSnapshots = [];
-  const concurrency = envPositiveInteger(env, "TOS_SEARCH_CONCURRENCY", 8);
+  const concurrency = envPositiveInteger(env, "OSS_SEARCH_CONCURRENCY", 8);
 
   async function loadIndex(descriptor) {
     if (!indexCache.has(descriptor.index_key)) {
@@ -383,7 +383,7 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
     results,
     unmatchedSlots,
     unknowns: [],
-    sourceSnapshot: `tos:${config.bucket}:${config.prefix}:catalog:${catalogObject.etag}:indexes:${shardsDigest}:content:${catalogObject.raw_sha256}`,
+    sourceSnapshot: `oss:${config.bucket}:${config.prefix}:catalog:${catalogObject.etag}:indexes:${shardsDigest}:content:${catalogObject.raw_sha256}`,
     retrievalMode: "category_index",
   };
 }
@@ -391,8 +391,8 @@ async function searchWithCategoryIndexes({ input, env, config, catalogObject, fe
 async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, maxFetch, includeContent }) {
   const manifestKey = `${config.prefix}_manifest.json`;
   const manifestObject = await getObject(config, manifestKey, fetchImpl);
-  const manifest = parseJsonObject(manifestObject, "WIKI_MANIFEST_INVALID", "TOS hardware Wiki manifest is not valid JSON", manifestKey);
-  if (!Array.isArray(manifest)) throw error("WIKI_MANIFEST_INVALID", "TOS hardware Wiki manifest must be an array", { key: manifestKey });
+  const manifest = parseJsonObject(manifestObject, "WIKI_MANIFEST_INVALID", "OSS hardware Wiki manifest is not valid JSON", manifestKey);
+  if (!Array.isArray(manifest)) throw error("WIKI_MANIFEST_INVALID", "OSS hardware Wiki manifest must be an array", { key: manifestKey });
   const scanLimit = Number.isInteger(input.policy?.scan_limit_per_slot) && input.policy.scan_limit_per_slot > 0
     ? input.policy.scan_limit_per_slot : null;
   const wikiLoader = createWikiLoader(config, fetchImpl, { legacy: true });
@@ -405,7 +405,7 @@ async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, m
     if (scanLimit && allEntries.length > entries.length) {
       unknowns.push({ slot_id: slot.slot_id, code: "SCAN_LIMIT", available: allEntries.length, scanned: entries.length });
     }
-    const loaded = await mapConcurrent(entries, envPositiveInteger(env, "TOS_SEARCH_CONCURRENCY", 8), wikiLoader);
+    const loaded = await mapConcurrent(entries, envPositiveInteger(env, "OSS_SEARCH_CONCURRENCY", 8), wikiLoader);
     const semanticQuery = semanticQueryFor(input, slot);
     const candidates = shortlistByDimensionTier(loaded.map(document => {
       const ranking = scoreDocument(document, semanticQuery, input.policy?.prefer_system_candidates !== false);
@@ -421,28 +421,28 @@ async function searchWithLegacyManifest({ input, env, config, fetchImpl, topK, m
   }
   return {
     results, unmatchedSlots, unknowns,
-    sourceSnapshot: `tos:${config.bucket}:${config.prefix}:manifest:${manifestObject.etag}`,
+    sourceSnapshot: `oss:${config.bucket}:${config.prefix}:manifest:${manifestObject.etag}`,
     retrievalMode: "legacy_manifest_full_scan",
   };
 }
 
 export async function searchHardware({ input, env, fetchImpl = fetch }) {
   validateInput(input);
-  const config = createTosConfig(env);
+  const config = createOssConfig(env);
   const policy = input.policy ?? {};
   const topK = Number.isInteger(policy.top_k_per_slot) && policy.top_k_per_slot > 0 ? policy.top_k_per_slot : 8;
-  const maxFullWikiFetch = envPositiveInteger(env, "TOS_MAX_FULL_WIKI_FETCH_PER_SLOT", 24);
+  const maxFullWikiFetch = envPositiveInteger(env, "OSS_MAX_FULL_WIKI_FETCH_PER_SLOT", 24);
   if (topK > maxFullWikiFetch) {
-    throw error("VALIDATION", `top_k_per_slot exceeds TOS_MAX_FULL_WIKI_FETCH_PER_SLOT (${maxFullWikiFetch})`, {
+    throw error("VALIDATION", `top_k_per_slot exceeds OSS_MAX_FULL_WIKI_FETCH_PER_SLOT (${maxFullWikiFetch})`, {
       top_k_per_slot: topK, max_full_wiki_fetch_per_slot: maxFullWikiFetch,
     });
   }
   const includeContent = policy.include_content !== false;
   const catalogObject = await getObject(config, `${config.prefix}_catalog.json`, fetchImpl, { optional: true });
-  const allowLegacy = policy.allow_legacy_manifest_fallback === true || env.TOS_ALLOW_LEGACY_MANIFEST_FALLBACK === "true";
+  const allowLegacy = policy.allow_legacy_manifest_fallback === true || env.OSS_ALLOW_LEGACY_MANIFEST_FALLBACK === "true";
   if (!catalogObject && !allowLegacy) {
-    throw error("WIKI_SEARCH_INDEX_MISSING", "TOS hardware category search catalog is missing; publish _catalog.json and indexes before searching", {
-      key: `${config.prefix}_catalog.json`, migration_env: "TOS_ALLOW_LEGACY_MANIFEST_FALLBACK=true",
+    throw error("WIKI_SEARCH_INDEX_MISSING", "OSS hardware category search catalog is missing; publish _catalog.json and indexes before searching", {
+      key: `${config.prefix}_catalog.json`, migration_env: "OSS_ALLOW_LEGACY_MANIFEST_FALLBACK=true",
     });
   }
   const searched = catalogObject

package/skills/abelien-hardware/scripts/search-index-release.mjs

@@ -3,8 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import zlib from "node:zlib";
 import { buildSearchIndex } from "./build-search-index.mjs";
-import { searchHardware } from "./tos-wiki-search.mjs";
-import { createTosConfig, getTosObject, headTosObject, putTosObject, sha256 } from "./tos-object-store.mjs";
+import { searchHardware } from "./oss-wiki-search.mjs";
+import { createOssConfig, getOssObject, headOssObject, putOssObject, sha256 } from "./oss-object-store.mjs";
 
 const CATALOG_SCHEMA = "abelien.hardware-wiki-search-catalog.v1";
 const INDEX_SCHEMA = "abelien.hardware-wiki-category-index.v1";
@@ -102,11 +102,11 @@ async function mapConcurrent(items, limit, worker) {
 async function requireMatchingManifest(config, catalog, fetchImpl, { optional = false } = {}) {
   const relative = catalog.source_manifest?.object_key || "_manifest.json";
   const key = `${config.prefix}${relative}`;
-  const object = await getTosObject(config, key, { fetchImpl, optional });
+  const object = await getOssObject(config, key, { fetchImpl, optional });
   if (!object) return null;
   const actual = sha256(object.bytes);
   if (actual !== catalog.source_manifest?.sha256) {
-    throw releaseError("SOURCE_MANIFEST_MISMATCH", "TOS Wiki Manifest does not match the index source", {
+    throw releaseError("SOURCE_MANIFEST_MISMATCH", "OSS Wiki Manifest does not match the index source", {
       key, expected_sha256: catalog.source_manifest?.sha256, actual_sha256: actual,
     });
   }
@@ -126,7 +126,7 @@ async function bootstrapRemoteManifest({ config, catalog, sourceDir, fetchImpl,
     const localFile = safeFile(sourceDir, entry.path);
     const localSize = fs.statSync(localFile).size;
     const key = `${config.prefix}${entry.path}`;
-    const head = await headTosObject(config, key, { fetchImpl });
+    const head = await headOssObject(config, key, { fetchImpl });
     if (head.contentLength !== null && head.contentLength !== localSize) {
       throw releaseError("REMOTE_WIKI_MISMATCH", "remote Wiki object size does not match local source", { key, expected_bytes: localSize, actual_bytes: head.contentLength });
     }
@@ -134,13 +134,13 @@ async function bootstrapRemoteManifest({ config, catalog, sourceDir, fetchImpl,
       if (head.metadataSha256 !== entry.sha256) throw releaseError("REMOTE_WIKI_MISMATCH", "remote Wiki metadata SHA-256 does not match Manifest", { key, expected_sha256: entry.sha256, actual_sha256: head.metadataSha256 });
       return;
     }
-    const object = await getTosObject(config, key, { fetchImpl });
+    const object = await getOssObject(config, key, { fetchImpl });
     const actual = sha256(object.bytes);
     if (actual !== entry.sha256) throw releaseError("REMOTE_WIKI_MISMATCH", "remote Wiki SHA-256 does not match Manifest", { key, expected_sha256: entry.sha256, actual_sha256: actual });
   });
   const key = `${config.prefix}${catalog.source_manifest.object_key || "_manifest.json"}`;
   await putImmutable(config, key, manifestBytes, fetchImpl);
-  const uploaded = await getTosObject(config, key, { fetchImpl });
+  const uploaded = await getOssObject(config, key, { fetchImpl });
   if (sha256(uploaded.bytes) !== catalog.source_manifest.sha256) {
     throw releaseError("SOURCE_MANIFEST_MISMATCH", "uploaded Wiki Manifest SHA-256 mismatch", { key });
   }
@@ -158,38 +158,38 @@ function objectContentType(key) {
 // 并发写同一键只会写入同一份字节；已存在但字节不同即冲突失败，不覆盖。
 async function putImmutable(config, key, bytes, fetchImpl) {
   const expected = sha256(bytes);
-  const existing = await getTosObject(config, key, { fetchImpl, optional: true });
+  const existing = await getOssObject(config, key, { fetchImpl, optional: true });
   if (existing) {
     const actual = sha256(existing.bytes);
     if (actual !== expected) throw releaseError("IMMUTABLE_OBJECT_CONFLICT", "release object already exists with different bytes", { key, expected_sha256: expected, actual_sha256: actual });
     return { key, sha256: expected, reused: true };
   }
-  await putTosObject(config, key, bytes, {
+  await putOssObject(config, key, bytes, {
     fetchImpl,
     headers: { "content-type": objectContentType(key), "x-amz-meta-sha256": expected },
   });
-  const uploaded = await getTosObject(config, key, { fetchImpl });
+  const uploaded = await getOssObject(config, key, { fetchImpl });
   const actual = sha256(uploaded.bytes);
   if (actual !== expected) throw releaseError("INDEX_UPLOAD_VERIFY_FAILED", "uploaded release object SHA-256 mismatch", { key, expected_sha256: expected, actual_sha256: actual });
   return { key, sha256: expected, reused: false };
 }
 
 export async function verifyPublishedIndex({ env, fetchImpl = fetch, concurrency } = {}) {
-  const config = createTosConfig(env);
+  const config = createOssConfig(env);
   const catalogKey = `${config.prefix}_catalog.json`;
-  const catalogObject = await getTosObject(config, catalogKey, { fetchImpl });
+  const catalogObject = await getOssObject(config, catalogKey, { fetchImpl });
   const catalog = parseJson(catalogObject.bytes, "WIKI_SEARCH_CATALOG_INVALID", catalogKey);
   if (catalog.schema !== CATALOG_SCHEMA || !catalog.release_id || !Array.isArray(catalog.categories) || !catalog.categories.length) {
     throw releaseError("WIKI_SEARCH_CATALOG_INVALID", "published search catalog is invalid", { key: catalogKey });
   }
   const manifest = await requireMatchingManifest(config, catalog, fetchImpl);
-  const limit = Number(concurrency || env?.TOS_PUBLISH_CONCURRENCY || 6);
+  const limit = Number(concurrency || env?.OSS_PUBLISH_CONCURRENCY || 6);
   const checked = await mapConcurrent(catalog.categories, Number.isFinite(limit) ? limit : 6, async descriptor => {
     if (!descriptor.index_key?.startsWith(`indexes/releases/${catalog.release_id}/`)) {
       throw releaseError("WIKI_SEARCH_CATALOG_INVALID", "published catalog points outside its release", { index_key: descriptor.index_key });
     }
     const key = `${config.prefix}${descriptor.index_key}`;
-    const object = await getTosObject(config, key, { fetchImpl });
+    const object = await getOssObject(config, key, { fetchImpl });
     const actual = sha256(object.bytes);
     if (actual !== descriptor.sha256) throw releaseError("INDEX_UPLOAD_VERIFY_FAILED", "published index SHA-256 mismatch", { key, expected_sha256: descriptor.sha256, actual_sha256: actual });
     const index = parseJson(indexBytes(object, descriptor.index_key), "WIKI_SEARCH_INDEX_INVALID", key);
@@ -211,9 +211,9 @@ export async function verifyPublishedIndex({ env, fetchImpl = fetch, concurrency
 }
 
 export async function smokePublishedIndex({ env, fetchImpl = fetch, categoryPath, query, limit = 8 } = {}) {
-  const config = createTosConfig(env);
+  const config = createOssConfig(env);
   const catalogKey = `${config.prefix}_catalog.json`;
-  const catalogObject = await getTosObject(config, catalogKey, { fetchImpl });
+  const catalogObject = await getOssObject(config, catalogKey, { fetchImpl });
   const catalog = parseJson(catalogObject.bytes, "WIKI_SEARCH_CATALOG_INVALID", catalogKey);
   const requested = Array.isArray(categoryPath) ? categoryPath : typeof categoryPath === "string" ? categoryPath.split("/") : null;
   const descriptor = requested
@@ -221,7 +221,7 @@ export async function smokePublishedIndex({ env, fetchImpl = fetch, categoryPath
     : catalog.categories?.[0];
   if (!descriptor) throw releaseError("SMOKE_CATEGORY_NOT_FOUND", "no published category is available for smoke test", { category_path: requested });
   const indexKey = `${config.prefix}${descriptor.index_key}`;
-  const indexObject = await getTosObject(config, indexKey, { fetchImpl });
+  const indexObject = await getOssObject(config, indexKey, { fetchImpl });
   const index = parseJson(indexBytes(indexObject, descriptor.index_key), "WIKI_SEARCH_INDEX_INVALID", indexKey);
   const probe = index.records?.[0];
   if (!probe) throw releaseError("SMOKE_EMPTY_CATEGORY", "published category has no records", { category_path: descriptor.category_path });
@@ -270,11 +270,11 @@ export async function publishHardwareSearchIndex({ sourceDir, outputDir, release
       catalog_sha256: local.catalog_sha256,
     };
 
-    const config = createTosConfig(env);
+    const config = createOssConfig(env);
     if (built.generated_source) {
       const manifestBytes = fs.readFileSync(path.join(built.generated_source, "_manifest.json"));
       const entries = JSON.parse(manifestBytes);
-      const limit = Number(concurrency || env?.TOS_PUBLISH_CONCURRENCY || 6);
+      const limit = Number(concurrency || env?.OSS_PUBLISH_CONCURRENCY || 6);
       await mapConcurrent(entries, Number.isFinite(limit) ? limit : 6, async entry => {
         const bytes = fs.readFileSync(safeFile(built.generated_source, entry.path));
         if (sha256(bytes) !== entry.sha256) throw releaseError("SOURCE_WIKI_MISMATCH", "generated Wiki changed after build");
@@ -285,28 +285,28 @@ export async function publishHardwareSearchIndex({ sourceDir, outputDir, release
     }
     let manifest = await requireMatchingManifest(config, local.catalog, fetchImpl, { optional: true });
     if (!manifest && !bootstrapManifest) {
-      throw releaseError("SOURCE_MANIFEST_MISSING", "TOS Wiki Manifest is missing; rerun with --bootstrap-manifest to verify every remote Wiki object before creating it", {
+      throw releaseError("SOURCE_MANIFEST_MISSING", "OSS Wiki Manifest is missing; rerun with --bootstrap-manifest to verify every remote Wiki object before creating it", {
         key: `${config.prefix}${local.catalog.source_manifest.object_key || "_manifest.json"}`,
       });
     }
     if (!manifest) {
-      manifest = await bootstrapRemoteManifest({ config, catalog: local.catalog, sourceDir, fetchImpl, concurrency: concurrency || env?.TOS_PUBLISH_CONCURRENCY });
+      manifest = await bootstrapRemoteManifest({ config, catalog: local.catalog, sourceDir, fetchImpl, concurrency: concurrency || env?.OSS_PUBLISH_CONCURRENCY });
     }
     const catalogKey = `${config.prefix}_catalog.json`;
-    const previousCatalog = await getTosObject(config, catalogKey, { fetchImpl, optional: true });
-    const limit = Number(concurrency || env?.TOS_PUBLISH_CONCURRENCY || 6);
+    const previousCatalog = await getOssObject(config, catalogKey, { fetchImpl, optional: true });
+    const limit = Number(concurrency || env?.OSS_PUBLISH_CONCURRENCY || 6);
     const uploaded = await mapConcurrent(local.files, Number.isFinite(limit) ? limit : 6, item =>
       putImmutable(config, `${config.prefix}${item.key}`, item.bytes, fetchImpl));
 
     // OSS 没有条件 PUT（见 putImmutable），激活前按内容 SHA 重读比对；OSS 对 JSON 对象不回 ETag，
     // 故不能比 ETag。重读到写入之间仍有窗口，写后 verify 的 release_id 比对兜住输掉的竞争。
     const previousSha256 = previousCatalog ? sha256(previousCatalog.bytes) : null;
-    const currentCatalog = await getTosObject(config, catalogKey, { fetchImpl, optional: true });
+    const currentCatalog = await getOssObject(config, catalogKey, { fetchImpl, optional: true });
     const currentSha256 = currentCatalog ? sha256(currentCatalog.bytes) : null;
     if (currentSha256 !== previousSha256) {
       throw releaseError("CATALOG_ACTIVATION_RACE", "active catalog changed while this release was uploading", { expected_sha256: previousSha256, actual_sha256: currentSha256 });
     }
-    await putTosObject(config, catalogKey, local.catalogBytes, { fetchImpl, headers: { "content-type": "application/json" } });
+    await putOssObject(config, catalogKey, local.catalogBytes, { fetchImpl, headers: { "content-type": "application/json" } });
     const verified = await verifyPublishedIndex({ env, fetchImpl, concurrency: limit });
     if (verified.release_id !== local.catalog.release_id) {
       throw releaseError("CATALOG_ACTIVATION_RACE", "active catalog is not the release just published", { expected_release_id: local.catalog.release_id, actual_release_id: verified.release_id });

package/skills/abelien-hardware-selection/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: abelien-hardware-selection
-description: 为已澄清的需求分层选择硬件分类，经真实 TOS 召回、英文 Volc 搜索加来源直读的来源绑定补选（Prismer 默认关闭）、Agent 语义比较与本地 hardware.select 校验身份、数量和引用。用于硬件选型，不用于需求澄清、独立数据库兼容求解或实物验证。
+description: 为已澄清的需求分层选择硬件分类，经真实 OSS 召回、英文 Volc 搜索加来源直读的来源绑定补选（Prismer 默认关闭）、Agent 语义比较与本地 hardware.select 校验身份、数量和引用。用于硬件选型，不用于需求澄清、独立数据库兼容求解或实物验证。
 license: MIT
 compatibility:
   - claude-code
@@ -14,7 +14,7 @@ compatibility:
 
 可用 `node <本包>/scripts/load-guide.mjs entry`，随后按需调用 `level1 --paths compute-control,power-energy`、`level2 --paths compute-control/controller-board,power-energy/charging`、`contract`。每次只返回指定文件及内容；分类不确定时再加载相邻页。
 
-分类阶段只产出功能槽位、数量、三级路径及用户硬约束，不指定 SKU。当前本地链路由 `hardware.search` 读取真实 TOS 索引与 Wiki，Agent 逐项比较，再由 `hardware.select` 回读召回资源校验身份、数量和证据。无需独立服务地址；缺证据保持待确认。`verified` 是 Wiki 证据判断，不是独立数据库兼容求解或实物测试。旧规则快照中的数据库契约不是当前完成声明，运行时以 [本地选型契约](references/selection-service-contract.md) 为准。
+分类阶段只产出功能槽位、数量、三级路径及用户硬约束，不指定 SKU。当前本地链路由 `hardware.search` 读取真实 OSS 索引与 Wiki，Agent 逐项比较，再由 `hardware.select` 回读召回资源校验身份、数量和证据。无需独立服务地址；缺证据保持待确认。`verified` 是 Wiki 证据判断，不是独立数据库兼容求解或实物测试。旧规则快照中的数据库契约不是当前完成声明，运行时以 [本地选型契约](references/selection-service-contract.md) 为准。
 
 ## 输入形状
 

package/skills/abelien-hardware-selection/domain.json

@@ -1,7 +1,7 @@
 {
   "name": "abelien-hardware-selection",
-  "version": "0.7.0",
-  "description": "本地硬件选型：真实 TOS 召回、Agent 证据判断与受信资源校验；不是数据库兼容性求解器",
+  "version": "0.7.1",
+  "description": "本地硬件选型：真实 OSS 召回、Agent 证据判断与受信资源校验；不是数据库兼容性求解器",
   "resources": ["hardware-selection"],
   "requires": ["abelien-harness", "abelien-hardware"],
   "capabilities": {

package/skills/abelien-hardware-selection/scripts/load-guide.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "references", "hardware-selection-v2");
 const slug = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const runtimeBoundary = "分类快照只用于路由；其中数据库服务的描述不是当前实现。当前执行契约请加载 contract：TOS 真实召回、Agent 证据比较、本地 hardware.select；不是独立数据库兼容求解或实物测试。";
+const runtimeBoundary = "分类快照只用于路由；其中数据库服务的描述不是当前实现。当前执行契约请加载 contract：OSS 真实召回、Agent 证据比较、本地 hardware.select；不是独立数据库兼容求解或实物测试。";
 
 export function loadGuide(phase, paths = []) {
   let files;

package/skills/abelien-harness/references/adapter-contract.md

@@ -78,7 +78,7 @@ adapter 返回值整体作为新资源 body：
 ```json
 {
   "type": "module",
-  "path": "scripts/tos-wiki-search.mjs",
+  "path": "scripts/oss-wiki-search.mjs",
   "export": "searchHardware"
 }
 ```

package/skills/abelien-harness/references/m1-integration.md

@@ -6,7 +6,7 @@
 
 本仓只带创建谱系的 **wire 契约**与受信客户端（`ab studio creation create|active|get`，宿主中立说明见 AGENTS.md 与 workflow 规范），不带第二份编排：Web 侧的创建请求只接受 schemaVersion、creationOperationId、inputRevision（必须 0）、manifestDigest、executionDefinitionVersion、executionDefinitionDigest、executionPath，并要求 studio.create 作用域；active/get 要求 state:read。HTTP origin/token 固定来自受信宿主 0600 context，不可由模型传入。工具登记 request/response 恰好一个 creationOperationId 或 modificationOperationId。creation receipt 与 Web 的 revision-zero 契约一致：requirementsSnapshot、requirementsHash、三项来源 Ref、plannedOccurrenceBindings，baseline.designRevision 为 0、designDigest 为 null；receipt 只保存、回读和观察，不自动 advance。
 
-hardware.search 只检索已配置的 TOS Wiki 压缩分类索引（索引缺失即 fail-closed，不静默回落全量扫描）；hardware.finalize 只把本次召回的候选比较归一化为 hardware-proposal（proposed 或 needs_confirmation），**不产生正式选型、也不写 verified**；但每个 selected_models 条目仍必须给出显式的 1–128 整数 quantity——不授正式权限不等于放弃可复核性，缺了数量，覆盖账本上的 verified_allocated_quantity 就没有对照物。正式选型由独立包 `abelien-hardware-selection` 的 hardware.select 提供——**本地 module adapter**（`scripts/select.mjs`），不再读 `ABELIEN_HARDWARE_SELECT_URL`，也不会因为设了旧 URL 就静默切回 HTTP；该包运行时要 import `abelien-hardware`（`domain.json` 的 `requires` 声明），域包在安装清单中一并落盘，须在干净隔离安装目录验证。hardware.revise 基于已验证选型做局部修订（HTTP，`env:ABELIEN_HARDWARE_REVISE_URL`）。
+hardware.search 只检索已配置的 OSS Wiki 压缩分类索引（索引缺失即 fail-closed，不静默回落全量扫描）；hardware.finalize 只把本次召回的候选比较归一化为 hardware-proposal（proposed 或 needs_confirmation），**不产生正式选型、也不写 verified**；但每个 selected_models 条目仍必须给出显式的 1–128 整数 quantity——不授正式权限不等于放弃可复核性，缺了数量，覆盖账本上的 verified_allocated_quantity 就没有对照物。正式选型由独立包 `abelien-hardware-selection` 的 hardware.select 提供——**本地 module adapter**（`scripts/select.mjs`），不再读 `ABELIEN_HARDWARE_SELECT_URL`，也不会因为设了旧 URL 就静默切回 HTTP；该包运行时要 import `abelien-hardware`（`domain.json` 的 `requires` 声明），域包在安装清单中一并落盘，须在干净隔离安装目录验证。hardware.revise 基于已验证选型做局部修订（HTTP，`env:ABELIEN_HARDWARE_REVISE_URL`）。
 
 ## 固定与验证
 
@@ -18,4 +18,4 @@ prepack 的 clarify 锚点检查在缺少原始上游仓库时会报告 skipped
 
 ## 明确付费边界
 
-构建、离线安装、fixture 测试、doctor、capability list、hardware.finalize 和 receipt 本地消费不调用 provider。真实 TOS search 是网络读取，可能有存储流量成本；本次也不执行。studio creation/tool register 会写受信 Web 状态，invocation submit 可能触发平台付费生成；generate 3d submit 的 confirm-spend 也是显式花费边界。此构建不调用任何这些真实入口，不设置账号/价格，不继承旧 50 元授权。集成验收不能以本包单测替代真实 Web/Agent 消费、同方案产物和反馈闭环验收。
+构建、离线安装、fixture 测试、doctor、capability list、hardware.finalize 和 receipt 本地消费不调用 provider。真实 OSS search 是网络读取，可能有存储流量成本；本次也不执行。studio creation/tool register 会写受信 Web 状态，invocation submit 可能触发平台付费生成；generate 3d submit 的 confirm-spend 也是显式花费边界。此构建不调用任何这些真实入口，不设置账号/价格，不继承旧 50 元授权。集成验收不能以本包单测替代真实 Web/Agent 消费、同方案产物和反馈闭环验收。

package/skills/abelien-harness/scripts/ab.mjs

@@ -167,7 +167,14 @@ export function createStore(workdir) {
 }
 
 // ---------- CLI shell ----------
-export const VERSION = "0.2.3";
+// 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";
+export let VERSION = FALLBACK_VERSION;
+try {
+  VERSION = String(JSON.parse(fs.readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version || FALLBACK_VERSION);
+} catch {}
 
 const USAGE_TEXT = `ab — Abelien harness CLI
 

package/skills/abelien-harness/scripts/studio.mjs

@@ -484,6 +484,18 @@ export async function studioCmd(pos, flags, deps = {}) {
     const suffix = action === "active" ? "active" : text(pos[2], "creationOperationId", UUID, 36);
     return request(context, "GET", `creations/${suffix}`, undefined, "creation", fetchImpl);
   }
+  if (resource === "modification" && (action === "active" || action === "get")) {
+    argsExactly(pos, action === "active" ? 2 : 3, "studio modification active | get <id>"); flagsOnly(flags);
+    requireScope(context, "state:read");
+    const suffix = action === "active" ? "active" : text(pos[2], "modificationOperationId", UUID, 36);
+    return request(context, "GET", `modifications/${suffix}`, undefined, "modification", fetchImpl);
+  }
+  if (resource === "invocation" && action === "get") {
+    argsExactly(pos, 3, "studio invocation get <invocationId>"); flagsOnly(flags);
+    requireScope(context, "state:read");
+    const id = text(pos[2], "invocationId", UUID, 36);
+    return request(context, "GET", `invocations/${id}`, undefined, "invocation", fetchImpl);
+  }
   requireScope(context, "tools:invoke");
   if (resource === "creation") {
     if (action === "create") {
@@ -495,18 +507,12 @@ export async function studioCmd(pos, flags, deps = {}) {
   }
   if (resource === "modification" && action === "create") {
     argsExactly(pos, 2, "studio modification create --input '<json>'"); flagsOnly(flags, ["input"]);
+    // The broker settles modification writes on studio.modify; the actionScope vocabulary stays
+    // Web-owned (component_replace / parameter_patch both carry it), so only the scope is mirrored.
+    requireScope(context, "studio.modify");
     const input = validateModificationRequest(parseJsonFlag(flags.input));
     return request(context, "POST", "modifications", input, "modification", fetchImpl);
   }
-  if (resource === "modification" && action === "active") {
-    argsExactly(pos, 2, "studio modification active"); flagsOnly(flags);
-    return request(context, "GET", "modifications/active", undefined, "modification", fetchImpl);
-  }
-  if (resource === "modification" && action === "get") {
-    argsExactly(pos, 3, "studio modification get <modificationOperationId>"); flagsOnly(flags);
-    const id = text(pos[2], "modificationOperationId", UUID, 36);
-    return request(context, "GET", `modifications/${id}`, undefined, "modification", fetchImpl);
-  }
   if (resource === "tool" && action === "register") {
     argsExactly(pos, 2, "studio tool register --input '<json>'"); flagsOnly(flags, ["input"]);
     const input = validateToolOperationRequest(parseJsonFlag(flags.input));
@@ -517,10 +523,5 @@ export async function studioCmd(pos, flags, deps = {}) {
     const input = validateInvocationRequest(parseJsonFlag(flags.input));
     return request(context, "POST", "invocations", input, "invocation", fetchImpl);
   }
-  if (resource === "invocation" && action === "get") {
-    argsExactly(pos, 3, "studio invocation get <invocationId>"); flagsOnly(flags);
-    const id = text(pos[2], "invocationId", UUID, 36);
-    return request(context, "GET", `invocations/${id}`, undefined, "invocation", fetchImpl);
-  }
   throw fail("USAGE", "studio command is probe, replacement request, creation|modification create|active|get, tool register, or invocation submit|get");
 }

package/skills/abelien-reference/domain.json

@@ -1,6 +1,6 @@
 {
   "name": "abelien-reference",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "参考研究域包：按 Agent 的检索计划收集产品识别、拆解资料与相似产品证据（检索、公开页面、主图、用户原图测量），再核验 Agent 的判断，产出 reference-evidence v1；判定码来自确定性检查",
   "requires": [
     "abelien-harness"

package/skills/abelien-reference/references/research-contract.md

@@ -62,6 +62,7 @@
 ### 核验
 
 - 引用经过 NFKC（全半角）与空白归一后，必须逐字出现在该页已保存的正文里，且归一后至少 8 个字。只能引用读取成功的页面。
+- 判定产出的引文对象保留该页的 `text_source` 标记：页面正文读不到、这段引用实际取自检索结果摘要时，`quote.text_source` 为 `search_snippet`。报告消费者据此即可区分「页面原文」与「检索摘要」，无需回读证据资源。
 - 候选的 `quote.page_id` 必须等于它的 `item_id`；没读到的页面（`too_large`、不可用）不能作为候选，因而不会被判为 `closest`。`name` 只有出现在该引用里（`name_in_quote: true`）才替换格子标题，否则标题保持页面标题，依据与冲突说明也用页面标题。
 - 给出尺寸时，宽、高（以及给出时的深）都必须以带长度单位的数值出现在同一条引用里：单位为 mm/毫米、cm/厘米、m/米、in/inch/英寸，换算成毫米后与提交值一致（容差 0.2% 或 0.05 mm 取大）；`118 × 118 × 215 mm` 这类连写时，单位作用于整串数值。重量、价格等不带长度单位的数字不算。没给尺寸时，比例核对为 `unknown`（`no_dimensions`），并写入 `unknowns`。
 - 规格值（`specs[].value`）必须能在其引用中定位：归一后是引用的子串；或值里的每个数字都以相同单位出现在引用里（长度按毫米换算，值里没写单位的数字只要求数字在引用里）。定位不到时整份判断以 `VALIDATION` 拒绝，不会把 Agent 的说法写成来源事实。

package/skills/abelien-reference/schemas/reference-evidence.v1.json

@@ -159,7 +159,7 @@
       "properties": {
         "name_in_quote": { "type": "boolean", "description": "名称是否出现在该候选自己的引用里；只有为 true 时名称才替换画布格子的标题，否则标题保持页面标题" },
         "dimensions_mm": { "description": "页面未给尺寸时为 null，此时比例核对为 unknown；给出时每个值都以带长度单位（mm/cm/m/in 等，换算到毫米一致）的数值出现在同一引用里", "oneOf": [{ "type": "null" }, { "type": "object", "required": ["width", "height"] }] },
-        "quote": { "type": "object", "required": ["page_id", "text"], "description": "page_id 必须等于该候选的 item_id；text 规范化后至少 8 字，逐字出现在该页正文里" },
+        "quote": { "type": "object", "required": ["page_id", "text"], "description": "page_id 必须等于该候选的 item_id；text 规范化后至少 8 字，逐字出现在该页正文里", "properties": { "page_id": { "type": "string" }, "text": { "type": "string" }, "text_source": { "enum": ["search_snippet"], "description": "仅当该页正文读不到、这段引用实际取自检索结果摘要时出现（同 page 的 text_source）" } } },
         "ratio_check": { "type": "object", "required": ["status"], "properties": { "status": { "enum": ["consistent", "mismatch", "unknown"] } } }
       }
     },

package/skills/abelien-reference/scripts/finalize.mjs

@@ -75,7 +75,9 @@ export async function finalizeReference({ input, readResource, readBlob }) {
     const quoted = words(quote.text, `${label}.text`, 500);
     if ([...normalize(quoted)].length < QUOTE_MIN_CHARS) invalid(`${label}.text must be a quote of at least ${QUOTE_MIN_CHARS} characters`);
     if (!pageText.get(page.id).includes(normalize(quoted))) invalid(`${label}.text must appear verbatim in page ${page.id}`);
-    return { page_id: page.id, text: quoted };
+    // The finalized quote carries the page's own text_source mark: a judgement quoted from the search
+    // summary (search_snippet) stays distinguishable at the report layer from one quoted from page body.
+    return { page_id: page.id, text: quoted, ...(page.text_source === undefined ? {} : { text_source: page.text_source }) };
   };
   const itemOf = (id, kinds, label) => {
     const item = items.get(id);

package/skills/abelien-workspace/SKILL.md

@@ -50,7 +50,7 @@ node <skills目录>/abelien-harness/scripts/ab.mjs --workdir <作品工作目录
   --input '{"intent":"restore","artifacts":{"reference_final":true}}'
 ```
 
-它是纯计算，返回下一阶段、目标与 `directives`。宿主先跑完自己的守卫，再把 `directives` 原样附在自己的执行说明（工具名、字段）之后。restore 默认锁定外形；锁定时，CAD 阶段的规则会写明不得放大外壳；未锁定时只允许在 appearance 认可的外观容差内调整外壳，超出容差换件或交用户取舍。意图的划分见 [意图路由](../../docs/architecture/intent-routing.md)。阶段计划是[完整用户旅程](references/user-journey.md)中 A1 通过之后到交付首版这一段（及其旁路）的机读派生，规则正文以 user-journey.md 为准；本能力在[能力映射](references/harness-binding.md#当前能力映射)中登记。
+它是纯计算，返回下一阶段、目标、`directives` 与 `actions`。宿主先跑完自己的守卫，再把 `directives` 原样附在自己的执行说明（工具名、字段）之后；`actions` 是该阶段允许的动作（取自计划的 `action_catalog`），宿主把它们映射成自己的工具，只放行这些。restore 默认锁定外形；锁定时，CAD 阶段的规则会写明不得放大外壳；未锁定时只允许在 appearance 认可的外观容差内调整外壳，超出容差换件或交用户取舍。意图的划分见 [意图路由](../../docs/architecture/intent-routing.md)。阶段计划是[完整用户旅程](references/user-journey.md)中 A1 通过之后到交付首版这一段（及其旁路）的机读派生，规则正文以 user-journey.md 为准；本能力在[能力映射](references/harness-binding.md#当前能力映射)中登记。
 
 本包定义作品事实之间的关系，不表示已实现完整的产品后台。现有可用能力和未接入项集中维护在[能力映射](references/harness-binding.md)，不使用旧 `workspace.*` mock 顶替。