skill-family-engineering-kit 0.25.0 → 0.26.0

package/package.json

@@ -8,8 +8,8 @@
     "url": "https://github.com/ifoohoo/skill-family-engineering-kit/issues"
   },
   "dependencies": {
-    "skill-family-contracts": "0.25.0",
-    "skill-family-harness-node": "0.25.0",
+    "skill-family-contracts": "0.26.0",
+    "skill-family-harness-node": "0.26.0",
     "yaml": "2.9.0"
   },
   "description": "Build-time scaffold, adoption planning, projection, and checks.",
@@ -52,7 +52,7 @@
     "url": "https://github.com/ifoohoo/skill-family-engineering-kit.git"
   },
   "type": "module",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "scripts": {
     "check": "node --test",
     "test": "node --test"

package/release-notes/0.26.0.yaml

@@ -0,0 +1,29 @@
+version: 0.26.0
+date: 2026-10-17
+locales:
+  en:
+    summary: "Version 0.26.0 extends shared read-only static loading checks to seven hosts through the existing runHostLoadingCheck function and skill-family-kit check host-loading CLI action. The four top-level commands scaffold, adopt-plan, projection, and check remain unchanged; no new top-level command or public API is added. Checks do not start hosts, models, hooks, or scripts, access the network, or write files."
+    changes:
+      changed:
+        - "Add shared static loading checks for seven hosts. The exact host versions, categories, and project directories are listed in the authoritative [NATIVE_HOSTS table](src/host-loading-native.mjs); this internal table is not a package-root public export."
+        - "Retain Codex CLI 0.154.0 project .agents/skills support and its existing activationRules mechanism."
+        - "Apply each host’s own discovery, parsing, ignore, name-competition, and local-file flag rules. Report Cursor menu, completion, and model metadata separately."
+        - "Only modelMetadata.* for Cursor CLI 2026.09.10-fd3934a may use source-reviewed-unexecuted, labeled “源码核实、未作原生运行校准” (source reviewed; not calibrated through native execution). This is not native runtime calibration and does not mean the check starts the host."
+        - "Other native-observed markers mean the check uses previously calibrated native rules; they do not mean this check starts the host."
+        - "The API project root must be an absolute working directory; the CLI resolves relative input to an absolute path first. A missing or unbindable project root returns 2. A missing, non-directory, or empty skill container within an existing project returns 1. Proven local loading blockers return 1; specific uncovered behavior or unknown competition returns 2 and takes precedence over 1. A fully covered static scope without blockers returns 0; normal skills cannot mask blockers or uncovered behavior. Only Codex supports activationRules; the seven other hosts accept only omission or null, and any other value, including an empty array, returns 2."
+        - "Retain link-containment and read boundaries. Uncalibrated actual competition, uncalibrated WorkBuddy optional metadata or version-source forms and icon resolution, Cursor completion string false, and CodeBuddy block scalars without proven equivalence remain specifically uncovered. Do not guess success or return 2 permanently for all ordinary input."
+        - "Exit 0 proves only static-check success. It does not prove final activation, installation, update, session selection, real triggering, or business execution. Codex evidence cannot establish calibration for other hosts."
+    upgradeNotes: "Pin skill-family-engineering-kit, skill-family-contracts, skill-family-harness-node, and the independent Plugin to exactly 0.26.0 in lockstep. Contracts specification 1.20.0 remains separate from package versions and does not advance with Kit. Consume actual published public interfaces for the exact host version and category. Release notes do not replace post-publish verification or formal consumer acceptance. Exit 0 is not an upgrade-safety guarantee or evidence of production validation."
+  zh-CN:
+    summary: "0.26.0 版本通过既有公共函数 `runHostLoadingCheck` 与 CLI 子动作 `skill-family-kit check host-loading`，扩展对七宿主的共享只读静态加载检查能力。四顶层命令 `scaffold`、`adopt-plan`、`projection`、`check` 保持不变，未新增顶层命令或公共 API。检查不启动宿主、模型、hook 或脚本，不联网、不写文件。"
+    changes:
+      changed:
+        - "新增七宿主共享静态加载检查；精确宿主版本、类别与项目目录见权威 [NATIVE_HOSTS 表](src/host-loading-native.mjs)。该内部表不是包根公共导出。"
+        - "**兼容性保留**：Codex CLI 0.154.0 的 `.agents/skills` 项目结构继续支持，其 `activationRules` 机制保持可用。"
+        - "**检查逻辑**：各宿主独立执行发现、解析、忽略、名称竞争与局部文件标志判断。Cursor 的菜单、补全与模型元数据三类行为分别报告。"
+        - "**证据例外**：仅当 `modelMetadata.*` 字段来自 Cursor CLI 2026.09.10-fd3934a 版本时，允许标注 `source-reviewed-unexecuted`，文字为“源码核实、未作原生运行校准”。该标记不表示原生运行已校准，也不代表本次检查启动宿主。"
+        - "**标记语义**：其余 `native-observed` 标记仅表示采用已有原生校准规则，不表示本次检查启动宿主。"
+        - "**边界与退出码**： 项目 root 必须为绝对工作目录，CLI 先将相对输入解析为绝对路径。 项目根不存在或不可绑定 → 退出码 2。 项目存在但技能容器缺失、非目录或为空 → 退出码 1。 已证明本地加载阻断 → 退出码 1。 具体未覆盖或未知竞争 → 退出码 2，且优先于 1。 普通完整静态范围无阻断 → 退出码 0；已有正常技能不能掩盖阻断或未覆盖。 Codex 支持原有 `activationRules`；其余七宿主仅接受省略或 `null`，其他值（包括空数组）返回 2。"
+        - "**数据边界**：保留链接收容与读取边界。未校准的实际竞争、WorkBuddy 尚未校准的可选元信息或版本来源形态及图标解析、Cursor 补全字符串 `false`、CodeBuddy 未证明等价的块标量等，均按具体未覆盖处理，不猜测成功，也不将所有普通输入永久返回 2。"
+        - "**静态通过不等于业务成功**：退出码 0 仅表示静态检查通过，不证明最终启用、安装、更新、会话选择、真实触发或业务执行成功。不得复用 Codex 证据宣称其他宿主已校准。"
+    upgradeNotes: "三个 Foundation npm 包（`skill-family-engineering-kit`、`skill-family-contracts`、`skill-family-harness-node`）及独立 Plugin 均需精确锁定至 0.26.0 版本，实现四单元锁步。 Contracts 规格保持 1.20.0，与包版本为独立坐标，不随 Kit 升级。 消费方应按精确宿主版本与类别，使用实际已发布的公共接口。 发布说明不替代发布后验证或正式消费者验收。 退出码 0 不构成升级安全保证，不等同于可安全升级或已通过生产验证。"

package/src/cli.mjs

@@ -80,9 +80,9 @@ const HELP_TEXT = `skill-family-engineering-kit —— 构建期工程工具包
                显式资格子动作: check qualification 仅在显式提供
                capability/request/bindings/native 后适配目录声明的能力特定入口，
                可在预检后调用能力特定的原生宿主。
-               宿主加载子动作: check host-loading 按 Codex CLI 0.154.0 已校准规则
-               只读检查项目根 .agents/skills（pathCategory=codex-project-skills）；
-               不启动宿主、模型、hook 或脚本，零写入。
+               宿主加载子动作: check host-loading 按已校准宿主版本只读检查所选项目技能容器
+               （Codex 0.154.0 的 .agents/skills，以及 Claude/Cursor/Kimi/WorkBuddy/CodeBuddy/Qoder/DSH
+               各自精确版本的项目根类别）；不启动宿主、模型、hook 或脚本，零写入。
 
 全局选项:
   --root <dir>  目标工作区根目录（默认当前目录）
@@ -193,10 +193,10 @@ function commandHelp(command) {
       "",
       "宿主加载子动作: skill-family-kit check host-loading [options]",
       "  --root <dir>          绝对或可解析的项目工作目录（默认当前目录）",
-      "  --host <id>           宿主 id（须解析为 codex）",
-      "  --host-version <ver>  精确版本（当前仅 0.154.0）",
-      "  --path-category <id>  发现形态（当前仅 codex-project-skills）",
-      "  --activation-rules <relpath>  根内相对 JSON，有序 name XOR path + enabled 规则",
+      "  --host <id>           宿主 id（codex 或已校准七宿主之一）",
+      "  --host-version <ver>  精确版本（Codex 0.154.0 或对应已校准原生版本）",
+      "  --path-category <id>  发现形态（codex-project-skills 或对应已校准项目根类别）",
+      "  --activation-rules <relpath>  仅 Codex：根内相对 JSON，有序 name XOR path + enabled 规则；其他宿主仅允许省略或 null",
       "  --hosts-root <dir>    可选宿主 Profile 根；缺省为包内 bundledHostProfilesRoot()",
     ],
   };

package/src/host-loading-check.mjs

@@ -6,6 +6,13 @@ import {
   readFileBound,
 } from "skill-family-harness-node";
 import { bundledHostProfilesRoot, describeHost } from "./host-profiles.mjs";
+import {
+  matchNativeHost,
+  NATIVE_HOSTS,
+  nativeLimitations,
+  nativeRuleSources,
+  runNativeHostLoadingCheck,
+} from "./host-loading-native.mjs";
 import { KIT_TOOL_NAME, KIT_VERSION } from "./skeleton.mjs";
 
 /**
@@ -56,6 +63,8 @@ const LIMITATIONS = Object.freeze([
   "Caller-supplied activationRules are the only enablement input; project-layer config.toml is not read.",
 ]);
 
+const NATIVE_POLICY = "host loading check is diagnosis only: it reads the selected project skill container through the existing root binding and never writes, spawns, or contacts a network";
+
 function uncovered(kind, message, extra = {}) {
   return { class: "host-loading", kind, message, ...extra };
 }
@@ -815,30 +824,38 @@ function reportDocument({
   uncoveredItems,
   nameAmbiguities,
   incomplete,
+  coverageExtras,
+  limitations,
+  policy,
 }) {
   const blocking = findings.length > 0;
   const exitCode = incomplete || uncoveredItems.length > 0 ? 2 : blocking ? 1 : 0;
+  const coverage = {
+    hostId,
+    hostVersion,
+    pathCategory,
+    root: rootAbs,
+    skillsRoot,
+  };
+  if (coverageExtras && Object.keys(coverageExtras).length > 0) {
+    Object.assign(coverage, coverageExtras);
+  } else if (!coverageExtras) {
+    coverage.officialTag = "rust-v0.154.0";
+    coverage.officialCommit = "6b9826e3aa83b1a5947db50f4332cb9c65f1b340";
+  }
   return {
     kind: HOST_LOADING_CHECK_REPORT_KIND,
     schemaVersion: 1,
     generatedBy: { tool: KIT_TOOL_NAME, version: KIT_VERSION },
-    coverage: {
-      hostId,
-      hostVersion,
-      pathCategory,
-      root: rootAbs,
-      skillsRoot,
-      officialTag: "rust-v0.154.0",
-      officialCommit: "6b9826e3aa83b1a5947db50f4332cb9c65f1b340",
-    },
-    limitations: [...LIMITATIONS],
+    coverage,
+    limitations: [...(limitations ?? LIMITATIONS)],
     skills,
     nameAmbiguities,
     findings,
     uncovered: uncoveredItems,
     ok: exitCode === 0,
     exitCode,
-    policy: "host loading check is diagnosis only: it reads SKILL.md and optional agents/openai.yaml under the selected project root and never writes, spawns, or contacts a network",
+    policy: policy ?? "host loading check is diagnosis only: it reads SKILL.md and optional agents/openai.yaml under the selected project root and never writes, spawns, or contacts a network",
   };
 }
 
@@ -849,7 +866,11 @@ function incompleteReport({
   hostVersion = null,
   pathCategory = null,
   item,
+  coverageExtras,
+  limitations,
+  policy,
 }) {
+  const omitCodexSources = hostId !== HOST_LOADING_SUPPORTED_HOST_ID;
   return reportDocument({
     rootAbs,
     skillsRoot,
@@ -861,6 +882,9 @@ function incompleteReport({
     uncoveredItems: [item],
     nameAmbiguities: [],
     incomplete: true,
+    coverageExtras: coverageExtras ?? (omitCodexSources ? {} : undefined),
+    limitations,
+    policy,
   });
 }
 
@@ -914,17 +938,6 @@ export async function runHostLoadingCheck({
     });
   }
   const rootAbs = path.normalize(root);
-  const normalizedRules = normalizeActivationRules(activationRules, rootAbs);
-  if (normalizedRules.incomplete) {
-    return incompleteReport({
-      rootAbs,
-      hostId,
-      hostVersion,
-      pathCategory,
-      item: normalizedRules.incomplete,
-    });
-  }
-
   const selectedHostsRoot = hostsRoot ?? bundledHostProfilesRoot();
   let descriptor;
   try {
@@ -945,46 +958,123 @@ export async function runHostLoadingCheck({
     });
   }
   const canonicalHostId = descriptor.hostId;
-  if (canonicalHostId !== HOST_LOADING_SUPPORTED_HOST_ID || hostVersion !== HOST_LOADING_SUPPORTED_HOST_VERSION) {
-    return incompleteReport({
-      rootAbs,
-      hostId: canonicalHostId,
-      hostVersion,
-      pathCategory,
-      item: uncovered("uncalibrated-host", `host ${canonicalHostId}@${hostVersion} is outside the calibrated Codex 0.154.0 slice`),
-    });
-  }
-  if (pathCategory !== HOST_LOADING_SUPPORTED_PATH_CATEGORY) {
-    return incompleteReport({
-      rootAbs,
-      hostId: canonicalHostId,
-      hostVersion,
-      pathCategory,
-      item: uncovered("uncalibrated-path-category", `pathCategory ${pathCategory} is not a calibrated Codex project skill root`),
-    });
-  }
   const category = (descriptor.pathCategories ?? []).find((item) => item.id === pathCategory);
-  if (!category) {
+  const relPath = path.posix.normalize(String(category?.relPath ?? ""));
+  const nativeSpec = category
+    ? matchNativeHost({ hostId: canonicalHostId, hostVersion, pathCategory, relPath })
+    : null;
+  const isCodex = canonicalHostId === HOST_LOADING_SUPPORTED_HOST_ID
+    && hostVersion === HOST_LOADING_SUPPORTED_HOST_VERSION
+    && pathCategory === HOST_LOADING_SUPPORTED_PATH_CATEGORY;
+
+  if (isCodex) {
+    const normalizedEarly = normalizeActivationRules(activationRules, rootAbs);
+    if (normalizedEarly.incomplete) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: normalizedEarly.incomplete,
+      });
+    }
+    if (!category) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered("uncalibrated-path-category", `pathCategory ${pathCategory} is not a calibrated Codex project skill root`),
+      });
+    }
+    if (relPath !== HOST_LOADING_SUPPORTED_REL_PATH) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered(
+          "uncalibrated-path-mapping",
+          `calibrated pathCategory ${pathCategory} must map to ${HOST_LOADING_SUPPORTED_REL_PATH}`,
+          { relPath },
+        ),
+      });
+    }
+  } else if (nativeSpec) {
+    if (activationRules !== undefined && activationRules !== null) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered(
+          "unsupported-activation-rules",
+          `activationRules are not calibrated for ${canonicalHostId}; only omitted or null are accepted`,
+        ),
+        coverageExtras: { ruleSources: nativeRuleSources(canonicalHostId) },
+        limitations: nativeLimitations(canonicalHostId),
+        policy: NATIVE_POLICY,
+      });
+    }
+  } else {
+    const expectedNative = NATIVE_HOSTS[canonicalHostId];
+    if (canonicalHostId === HOST_LOADING_SUPPORTED_HOST_ID) {
+      if (hostVersion !== HOST_LOADING_SUPPORTED_HOST_VERSION) {
+        return incompleteReport({
+          rootAbs,
+          hostId: canonicalHostId,
+          hostVersion,
+          pathCategory,
+          item: uncovered("uncalibrated-host", `host ${canonicalHostId}@${hostVersion} is outside the calibrated Codex 0.154.0 slice`),
+        });
+      }
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered("uncalibrated-path-category", `pathCategory ${pathCategory} is not a calibrated Codex project skill root`),
+      });
+    }
+    if (!expectedNative || expectedNative.hostVersion !== hostVersion) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered("uncalibrated-host", `host ${canonicalHostId}@${hostVersion} is outside the calibrated native slice`),
+      });
+    }
+    if (!category || pathCategory !== expectedNative.pathCategory) {
+      return incompleteReport({
+        rootAbs,
+        hostId: canonicalHostId,
+        hostVersion,
+        pathCategory,
+        item: uncovered("uncalibrated-path-category", `pathCategory ${pathCategory} is not a calibrated project skill root for ${canonicalHostId}`),
+      });
+    }
     return incompleteReport({
       rootAbs,
       hostId: canonicalHostId,
       hostVersion,
       pathCategory,
-      item: uncovered("uncalibrated-path-category", `pathCategory ${pathCategory} is not a calibrated Codex project skill root`),
+      item: uncovered(
+        "uncalibrated-path-mapping",
+        `calibrated pathCategory ${pathCategory} must map to ${expectedNative.relPath}`,
+        { relPath },
+      ),
     });
   }
-  const relPath = path.posix.normalize(String(category.relPath ?? ""));
-  if (relPath !== HOST_LOADING_SUPPORTED_REL_PATH) {
+
+  const normalizedRules = isCodex ? normalizeActivationRules(activationRules, rootAbs) : { rules: null };
+  if (normalizedRules.incomplete) {
     return incompleteReport({
       rootAbs,
       hostId: canonicalHostId,
       hostVersion,
       pathCategory,
-      item: uncovered(
-        "uncalibrated-path-mapping",
-        `calibrated pathCategory ${pathCategory} must map to ${HOST_LOADING_SUPPORTED_REL_PATH}`,
-        { relPath },
-      ),
+      item: normalizedRules.incomplete,
     });
   }
 
@@ -1011,7 +1101,15 @@ export async function runHostLoadingCheck({
     });
   }
 
-  const skillsRoot = path.join(rootAbs, ".agents", "skills");
+  const selectedRelPath = nativeSpec?.relPath ?? HOST_LOADING_SUPPORTED_REL_PATH;
+  const skillsRoot = path.join(rootAbs, ...selectedRelPath.split("/"));
+  const nativeReportOptions = nativeSpec
+    ? {
+      coverageExtras: { ruleSources: nativeRuleSources(canonicalHostId) },
+      limitations: nativeLimitations(canonicalHostId),
+      policy: NATIVE_POLICY,
+    }
+    : {};
   let skillsRootStat;
   try {
     skillsRootStat = await lstat(skillsRoot);
@@ -1019,9 +1117,10 @@ export async function runHostLoadingCheck({
     if (cause?.code !== "ENOENT" && cause?.code !== "ENOTDIR") {
       return incompleteReport({
         rootAbs, skillsRoot, hostId: canonicalHostId, hostVersion, pathCategory,
-        item: uncovered("discovery-root-unreadable", "project .agents/skills cannot be inspected", {
+        item: uncovered("discovery-root-unreadable", `project ${selectedRelPath} cannot be inspected`, {
           causeKind: boundReadKind(cause),
         }),
+        ...nativeReportOptions,
       });
     }
     return reportDocument({
@@ -1031,10 +1130,11 @@ export async function runHostLoadingCheck({
       hostVersion,
       pathCategory,
       skills: [],
-      findings: [finding("missing-discovery-root", "project .agents/skills does not exist")],
+      findings: [finding("missing-discovery-root", `project ${selectedRelPath} does not exist`)],
       uncoveredItems: [],
       nameAmbiguities: [],
       incomplete: false,
+      ...nativeReportOptions,
     });
   }
   if (skillsRootStat.isSymbolicLink()) {
@@ -1045,6 +1145,7 @@ export async function runHostLoadingCheck({
       hostVersion,
       pathCategory,
       item: uncovered("directory-symlink-unfollowed", "the calibrated skills root is a directory symlink and is not followed"),
+      ...nativeReportOptions,
     });
   }
   if (!skillsRootStat.isDirectory()) {
@@ -1055,10 +1156,35 @@ export async function runHostLoadingCheck({
       hostVersion,
       pathCategory,
       skills: [],
-      findings: [finding("missing-discovery-root", "project .agents/skills is not a directory")],
+      findings: [finding("missing-discovery-root", `project ${selectedRelPath} is not a directory`)],
       uncoveredItems: [],
       nameAmbiguities: [],
       incomplete: false,
+      ...nativeReportOptions,
+    });
+  }
+
+  if (nativeSpec) {
+    const nativeResult = await runNativeHostLoadingCheck({
+      rootAbs,
+      skillsRootAbs: skillsRoot,
+      hostId: canonicalHostId,
+      rootBinding,
+    });
+    return reportDocument({
+      rootAbs,
+      skillsRoot,
+      hostId: canonicalHostId,
+      hostVersion,
+      pathCategory,
+      skills: nativeResult.skills,
+      findings: nativeResult.findings,
+      uncoveredItems: nativeResult.uncoveredItems,
+      nameAmbiguities: nativeResult.nameAmbiguities,
+      incomplete: nativeResult.uncoveredItems.length > 0,
+      coverageExtras: { ruleSources: nativeResult.ruleSources },
+      limitations: nativeResult.limitations,
+      policy: NATIVE_POLICY,
     });
   }