@geoly-ai/skills-hub 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoly-ai/skills-hub",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "geoly-ai 的 skill 分发中心 —— 安装、校验、审计",
   "type": "module",
   "bin": {
@@ -24,7 +24,11 @@
   },
   "files": [
     "bin",
-    "src"
+    "src",
+    "scripts/submission/structural-gates.mjs",
+    "scripts/submission/run-gates.mjs",
+    "scripts/submission/promotion-file.mjs",
+    "scripts/submission/scan-text.mjs"
   ],
   "scripts": {
     "test": "node --test test/*.test.mjs",

package/scripts/submission/promotion-file.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+// `submissions/<ns>/<name>@<ver>/PROMOTION.json` —— 06-submission.md §6，
+// 以及 2026-08-31 的决策 ②（R-19 的闭合方式）。
+//
+// ── 🔴 这个文件解决什么 ────────────────────────────────────────────────────
+// `build-inputs.mjs` 要两份**只有 PR 侧才有**的事实：
+//   · `--claim-owner` —— 首次注册 namespace 时的 owner（不在 manifest 的键集里）；
+//   · `--provenance-of` —— pack 的 provenance（`pack.json` 的键集里没有这个字段）。
+// 在它们有来处之前，registry 只收得了「已注册 namespace 下的 skill 续版本」。
+//
+// ── 🔴🔴 分工：投稿者声明什么，promote 填什么 ─────────────────────────────
+// **投稿者只能声明「只有他知道」的事**，凡是「只有 promote 能证明」的字段
+// 一律由 promote 自己填 —— 让投稿者写它们，等于让他自称是谁。
+//
+// | 字段 | 谁给 | 为什么 |
+// |---|---|---|
+// | `owner.kind`（user/org） | 投稿者 | 意图，只有他知道 |
+// | `owner.login` | 投稿者 | `user` 时必须等于 PR 作者，promote 会核 |
+// | `owner.id` | **promote** | 不可变 node id 是身份本身；投稿者写它 = 冒名 |
+// | `provenance.kind` | 投稿者 | 原创还是搬运，只有他知道 |
+// | `author_github_id` | **promote** | 同上 |
+// | `submitted_by_pr` / `imported_by_pr` | **promote** | 开 PR 之前根本不存在 |
+// | `imported_at` | **promote** | 用**投稿 PR 的 created_at** —— 见下面的说明 |
+// | `origin_*` / `license_evidence` | 投稿者 | 关于上游的事实，promote 无从得知 |
+//
+// 🔴 **投稿者写了 promote 该填的字段 → 直接拒**，不是「忽略它」。
+//    忽略的话，一个想冒名的投稿看起来会像被接受了；而拒掉是一次沟通。
+//
+// ⚠️ 这份文件**不是**信任来源，是**待审材料**：`origin_*` 与 `license_evidence`
+//    没有任何自动门能证实，它们归 §8 人工门第 8 条（license 与 provenance 是否可信）。
+
+import { readFileSync, existsSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+
+import { parseStrict } from '../../src/canonical-json.mjs';
+
+export const PROMOTION_SCHEMA = 'geoly.skills.promotion-file/1';
+export const PROMOTION_FILE = 'PROMOTION.json';
+
+class PromotionFileError extends Error {
+  constructor(code, msg) { super(msg); this.name = 'PromotionFileError'; this.code = code; }
+}
+const bad = (code, msg) => { throw new PromotionFileError(code, msg); };
+
+/** promote 自己填的字段 —— 投稿者写了任何一个都拒。 */
+const FILLED_BY_PROMOTE = [
+  'id', 'author_github_id', 'submitted_by_pr', 'imported_by_pr', 'imported_at',
+];
+
+const OWNER_KEYS = ['kind', 'login'];
+const PROV_ORIGINAL_KEYS = ['kind'];
+const PROV_VENDORED_KEYS = [
+  'kind', 'origin_repo', 'origin_ref', 'origin_commit', 'origin_subpath',
+  'origin_tree_digest', 'license_evidence', 'added_files',
+];
+
+const RE_COMMIT = /^[0-9a-f]{40}$/;
+const RE_TREE = /^geoly-tree-v1:sha256:[0-9a-f]{64}$/;
+
+function assertExact(obj, keys, where) {
+  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
+    bad('E_PROMO_SHAPE', `${where} 必须是对象`);
+  }
+  const got = Object.keys(obj).sort();
+  for (const k of got) {
+    if (FILLED_BY_PROMOTE.includes(k)) {
+      bad('E_PROMO_FORBIDDEN',
+        `${where}.${k} 由 promote 自己填，投稿里不能写它。\n`
+        + '  🔴 这一类字段是**身份与时间**（node id、PR 号、导入时刻）——\n'
+        + '     让投稿声明它们，等于让投稿者自称是谁、自称什么时候来的。');
+    }
+  }
+  const want = [...keys].sort();
+  if (got.join(',') !== want.join(',')) {
+    bad('E_PROMO_SHAPE', `${where} 的键集必须正好是 {${want.join(', ')}}，得到 {${got.join(', ')}}`);
+  }
+}
+
+const str = (v, where) => {
+  if (typeof v !== 'string' || v === '') bad('E_PROMO_SHAPE', `${where} 必须是非空字符串`);
+  return v;
+};
+
+/**
+ * 读并校验一个投稿目录里的 `PROMOTION.json`。
+ * @returns {{owner:object|null, provenance:object|null}|null} 没有这个文件时返回 null
+ */
+export function readPromotionFile(submissionDir) {
+  const p = join(submissionDir, PROMOTION_FILE);
+  if (!existsSync(p)) return null;
+
+  let doc;
+  try {
+    doc = parseStrict(readFileSync(p, 'utf8'));
+  } catch (e) {
+    bad('E_PROMO_PARSE', `${PROMOTION_FILE} 读不出来：${e.message.split('\n')[0]}`);
+  }
+  if (doc.schema !== PROMOTION_SCHEMA) {
+    bad('E_PROMO_SHAPE', `${PROMOTION_FILE}.schema 应为 ${PROMOTION_SCHEMA}，得到 ${JSON.stringify(doc.schema)}`);
+  }
+  const keys = Object.keys(doc).sort().filter((k) => k !== 'schema');
+  for (const k of keys) {
+    if (!['claim_owner', 'provenance'].includes(k)) {
+      bad('E_PROMO_SHAPE', `${PROMOTION_FILE} 里不认识的键：${k}（只能有 schema / claim_owner / provenance）`);
+    }
+  }
+
+  let owner = null;
+  if (doc.claim_owner !== undefined) {
+    assertExact(doc.claim_owner, OWNER_KEYS, 'claim_owner');
+    const kind = str(doc.claim_owner.kind, 'claim_owner.kind');
+    if (kind !== 'user' && kind !== 'org') {
+      bad('E_PROMO_SHAPE', `claim_owner.kind 只能是 user / org，得到 ${JSON.stringify(kind)}`);
+    }
+    str(doc.claim_owner.login, 'claim_owner.login');
+    owner = { kind, login: doc.claim_owner.login };
+  }
+
+  let provenance = null;
+  if (doc.provenance !== undefined) {
+    const kind = doc.provenance?.kind;
+    if (kind === 'original') {
+      assertExact(doc.provenance, PROV_ORIGINAL_KEYS, 'provenance');
+      provenance = { kind: 'original' };
+    } else if (kind === 'vendored') {
+      assertExact(doc.provenance, PROV_VENDORED_KEYS, 'provenance');
+      const v = doc.provenance;
+      for (const k of ['origin_repo', 'origin_ref', 'origin_subpath', 'license_evidence']) {
+        str(v[k], `provenance.${k}`);
+      }
+      // 🔴 只记 tag 不行 —— tag 可以被移动，那正是「审核后换内容」的路径
+      //    （05-lifecycle.md §6）。与 snapshot.mjs 的 E_PROV_COMMIT 同一条判据。
+      if (!RE_COMMIT.test(v.origin_commit ?? '')) {
+        bad('E_PROMO_SHAPE', `provenance.origin_commit 必须是 40 位小写 hex，得到 ${JSON.stringify(v.origin_commit)}`);
+      }
+      // 🔴 是**树**摘要，要带 geoly-tree-v1: 前缀（ERRATA E-8）——
+      //    系统里有两种树算法，裸 sha256 分不出是哪一种。
+      if (!RE_TREE.test(v.origin_tree_digest ?? '')) {
+        bad('E_PROMO_SHAPE',
+          `provenance.origin_tree_digest 必须形如 geoly-tree-v1:sha256:<64hex>，`
+          + `得到 ${JSON.stringify(v.origin_tree_digest)}`);
+      }
+      if (!Array.isArray(v.added_files) || v.added_files.some((x) => typeof x !== 'string' || x === '')) {
+        bad('E_PROMO_SHAPE', 'provenance.added_files 必须是非空字符串数组（没有新增就写 []）');
+      }
+      // 🔴 重复项要拒：它进快照、且是「相对上游多了哪些文件」的权威列表 ——
+      //    列两遍会让读它的人以为有两个文件。
+      const dup = v.added_files.filter((x, i) => v.added_files.indexOf(x) !== i);
+      if (dup.length) bad('E_PROMO_SHAPE', `provenance.added_files 有重复项：${[...new Set(dup)].join('、')}`);
+      provenance = { ...v };
+    } else {
+      bad('E_PROMO_SHAPE', `provenance.kind 只能是 original / vendored，得到 ${JSON.stringify(kind)}`);
+    }
+  }
+  return { owner, provenance };
+}
+
+/**
+ * 把投稿声明的那一半，与 promote 才知道的那一半合起来。
+ *
+ * @param {object} a
+ * @param {object|null} a.declared      `readPromotionFile` 的结果
+ * @param {string} a.kind               skill / pack
+ * @param {object} a.pr                 `{number, authorId, authorLogin, createdAt}`
+ * @param {object} [a.orgIds]           `login → node id`，**由 promote 从 API 解析**
+ * @returns {{owner:object|undefined, provenance:object|undefined}}
+ */
+export function fillFromPr({ declared, kind, pr, orgIds = {} }) {
+  const out = {};
+  if (declared?.owner) {
+    // 🔴 `user` 的 owner 必须**就是** PR 作者。允许写别人的 login，
+    //    等于让 A 用一次投稿把 namespace 注册到 B 名下。
+    //    `org` 走不了这条自动判据 —— 归 §8 人工门（维护者要确认这个 org 真是他的）。
+    if (declared.owner.kind === 'user' && declared.owner.login !== pr.authorLogin) {
+      bad('E_PROMO_OWNER',
+        `claim_owner.login 是 ${declared.owner.login}，而 PR 作者是 ${pr.authorLogin}。\n`
+        + '  🔴 kind: user 的首次注册只能注册到**投稿者自己**名下。\n'
+        + '  要注册到别人 / 组织名下，用 kind: org，并由维护者人工确认。');
+    }
+    // 🔴 **`org` 的 id 必须是那个 org 的 node id，不是投稿者的。**
+    //    早先这里两种 kind 都写 `pr.authorId` —— 于是记录里是
+    //    「login: 某组织 + id: 某个人」，而 05-lifecycle §1 说 id 才是身份本身：
+    //    那条绑定实际上把 namespace 给了这个人，却显示成组织的（Codex 2026-08-31）。
+    //    ⚠️ 「这个人是不是该组织的成员 / 有没有权代表它」**没有自动判据**，
+    //       归 §8 人工门 —— 维护者必须确认。
+    let id;
+    if (declared.owner.kind === 'org') {
+      id = orgIds[declared.owner.login];
+      if (typeof id !== 'string' || id === '') {
+        bad('E_PROMO_ORG_ID',
+          `claim_owner 是 org ${declared.owner.login}，但没有拿到它的 node id。\n`
+          + '  🔴 org 的绑定必须记**组织自己**的不可变 id —— 记成投稿者的 id，\n'
+          + '     等于把 namespace 给了这个人却显示成组织的。\n'
+          + '  promote 应当用 `gh api orgs/<login> --jq .node_id` 解析后传进来。');
+      }
+    } else {
+      id = pr.authorId;
+    }
+    out.owner = { kind: declared.owner.kind, login: declared.owner.login, id };
+  }
+  if (declared?.provenance) {
+    const p = declared.provenance;
+    out.provenance = p.kind === 'original'
+      ? { kind: 'original', author_github_id: pr.authorId, submitted_by_pr: pr.number }
+      : { ...p, imported_at: pr.createdAt, imported_by_pr: pr.number };
+  }
+  // skill 的 provenance 在 manifest 里，不该由这个文件提供
+  if (kind === 'skill' && declared?.provenance) {
+    bad('E_PROMO_SHAPE',
+      'skill 的 provenance 在 skill.json 里（它的键集有这个字段），'
+      + `${PROMOTION_FILE} 不要重复声明 —— 两个来源就会有两个真值。`);
+  }
+  return out;
+}
+
+export { PromotionFileError };
+
+// ── CLI（只校验，给结构门用）────────────────────────────────────────────────
+
+export function main(argv) {
+  if (argv.length !== 1) bad('E_PROMO_INPUT', '用法：promotion-file.mjs <投稿目录>');
+  const r = readPromotionFile(argv[0]);
+  process.stderr.write(r === null
+    ? `${argv[0]} 没有 ${PROMOTION_FILE}（已注册 namespace 下的 skill 续版本不需要它）。\n`
+    : `✔ ${PROMOTION_FILE} 形状合规（owner=${r.owner ? r.owner.kind : '无'}，`
+      + `provenance=${r.provenance ? r.provenance.kind : '无'}）。\n`
+      + '⚠️ 形状合规 ≠ 内容可信：origin_* 与 license_evidence 没有自动门能证实，\n'
+      + '   它们归 §8 人工门第 8 条。\n');
+  return 0;
+}
+
+// 入口守卫比 realpath —— 见 scripts/release/build-timestamp.mjs 里的说明。
+function invokedDirectly() {
+  if (process.argv[1] === undefined) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch { return true; }
+}
+
+if (invokedDirectly()) {
+  try { process.exit(main(process.argv.slice(2))); } catch (e) {
+    process.stderr.write(`${e.code ? `[${e.code}] ` : ''}${e.message}\n`);
+    process.exit(1);
+  }
+}

package/scripts/submission/run-gates.mjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+// 把 §6 的结构门跑在 `submissions/**` 上 —— 06-submission.md §6。
+//
+// 🔴 **不执行载荷**（§5）：这里只读文件、算摘要、比字符串。
+//    没有任何一步会跑投稿带来的脚本。
+//
+// 布局（01-artifacts.md §2）：`submissions/<namespace>/<name>@<version>/`
+//
+// 🔴 **一次跑完全部投稿、把所有失败一起报出来**，不是遇到第一个就退出。
+//    投稿者要能一次看到所有问题 —— 让人来回改三轮的门，人会绕着走。
+
+import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+
+import { parseStrict } from '../../src/canonical-json.mjs';
+import { collectTree } from '../../src/packer.mjs';
+import {
+  readReserved, assertReservedNamespaceAllowed, assertNoNormalizedCollision,
+  assertVersionUnused, assertCapabilityConsistency,
+} from './structural-gates.mjs';
+import { readPromotionFile } from './promotion-file.mjs';
+import { assertSkillFrontmatter } from '../../src/artifact.mjs';
+
+const RE_SUBMISSION_DIR = /^([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)@(.+)$/;
+
+class RunError extends Error {
+  constructor(msg) { super(msg); this.name = 'RunError'; }
+}
+
+/** 枚举 `submissions/<ns>/<name>@<ver>/`。 */
+export function scanSubmissions(root) {
+  if (!existsSync(root)) return [];
+  const out = [];
+  for (const ns of readdirSync(root).sort()) {
+    for (const entry of readdirSync(join(root, ns)).sort()) {
+      const m = RE_SUBMISSION_DIR.exec(entry);
+      if (m === null) {
+        throw new RunError(
+          `submissions/${ns}/${entry} 不合布局 —— 必须是 <name>@<version>/`
+          + '（01-artifacts.md §2）。目录名本身就是投稿在声明它是什么，不该靠猜。',
+        );
+      }
+      out.push({ namespace: ns, name: m[1], version: m[2], dir: join(root, ns, entry) });
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {object} a
+ * @param {string} a.submissionsRoot
+ * @param {object} a.reserved
+ * @param {string[]} a.existingIds     已有的全部 ArtifactId（**含已 yank**）
+ * @param {Map<string,string[]>} a.existingNamesByNs  同 namespace 内已有的 name
+ * @param {boolean} a.byMaintainer
+ * @returns {{checked:number, problems:string[]}}
+ */
+export function runGates({
+  submissionsRoot, reserved, existingIds = [], existingNamesByNs = new Map(),
+  byMaintainer = false, registeredNamespaces = new Set(),
+}) {
+  const problems = [];
+  const subs = scanSubmissions(submissionsRoot);
+
+  for (const s of subs) {
+    const where = `submissions/${s.namespace}/${s.name}@${s.version}`;
+    const push = (e) => problems.push(`${where}：${e.message.split('\n')[0]}`);
+
+    // ① 保留 namespace
+    try {
+      assertReservedNamespaceAllowed({ namespace: s.namespace, reserved, byMaintainer });
+    } catch (e) { push(e); }
+
+    // ② 归一化重名（同 namespace 内）
+    try {
+      assertNoNormalizedCollision({
+        name: s.name, existing: existingNamesByNs.get(s.namespace) ?? [],
+      });
+    } catch (e) { push(e); }
+
+    // ③ 版本未占用（含已 yank）
+    //    kind 由载荷里有 skill.json 还是 pack.json 决定 —— 目录名不带 kind。
+    const isPack = existsSync(join(s.dir, 'pack.json'));
+    const isSkill = existsSync(join(s.dir, 'skill.json'));
+    if (isPack === isSkill) {
+      problems.push(
+        `${where}：载荷根必须**恰好**有 skill.json 或 pack.json 其中一个`
+        + `（现在 skill.json=${isSkill}、pack.json=${isPack}）——`
+        + '两个都在时「这是什么制品」有两个答案。',
+      );
+      continue;                      // kind 都定不下来，后面的门无从谈起
+    }
+    const kind = isPack ? 'pack' : 'skill';
+    try {
+      assertVersionUnused({ id: `${kind}:${s.namespace}/${s.name}@${s.version}`, existingIds });
+    } catch (e) { push(e); }
+
+    // ④ PROMOTION.json：形状 + **必需性**
+    //    🔴 在**投稿 PR** 上就检，而不是等到 promote —— 那时投稿已经合并进 main，
+    //    再报「你的 PROMOTION.json 写错了」，改起来要走一整轮。
+    //    🔴 「有就检」不够：一个没有 provenance 的 pack、或一个未注册 namespace
+    //    下没有 claim_owner 的首投，会**通过投稿 CI、合并进 main、然后卡住
+    //    promote** —— 那时它已经在 main 上了（Codex 2026-08-31）。
+    let declared = null;
+    try {
+      declared = readPromotionFile(s.dir);
+    } catch (e) { push(e); }
+    if (declared === null && !existsSync(join(s.dir, 'PROMOTION.json'))) {
+      if (isPack) {
+        problems.push(`${where}：pack 必须有 PROMOTION.json —— `
+          + 'pack.json 的键集里没有 provenance（03-packs §2），它只能由投稿声明。');
+      }
+      if (!registeredNamespaces.has(s.namespace)) {
+        problems.push(`${where}：namespace ${s.namespace} 尚未注册，`
+          + '必须在 PROMOTION.json 里给出 claim_owner（首次注册）。');
+      }
+    } else if (declared !== null) {
+      if (isPack && declared.provenance === null) {
+        problems.push(`${where}：pack 的 PROMOTION.json 必须声明 provenance`);
+      }
+      if (!registeredNamespaces.has(s.namespace) && declared.owner === null) {
+        problems.push(`${where}：namespace ${s.namespace} 尚未注册，`
+          + 'PROMOTION.json 必须声明 claim_owner');
+      }
+    }
+
+    // ⑤ˢ SKILL.md frontmatter —— 调**建快照将来要调的同一个函数**
+    //    🔴 2026-09-02 补上：这道门以前根本不解析 frontmatter，于是 11 个投稿
+    //    全绿合并进 main，promote 建快照时才红在 E_FRONTMATTER（10 个用了 YAML
+    //    折叠标量 `>`，而解析器是刻意最小化的、只认单行 key: value）。
+    //    那正是本文件④处注释里写的那件事：等到 promote 才报，投稿已经在 main 上了。
+    //    ⚠️ 共用 `assertSkillFrontmatter`，不在这里另写一份 —— 另写就是又一处会分叉的实现。
+    if (kind === 'skill') {
+      try {
+        assertSkillFrontmatter({
+          payloadDir: s.dir,
+          name: s.name,
+          viol: (code, msg) => { throw new Error(`[${code}] ${msg}`); },
+        });
+      } catch (e) { push(e); }
+    }
+
+    // ⑤ capability 一致性（只对 skill —— pack.json 里没有 capabilities）
+    if (kind === 'skill') {
+      try {
+        const manifest = parseStrict(readFileSync(join(s.dir, 'skill.json'), 'utf8'));
+        assertCapabilityConsistency({
+          capabilities: manifest.capabilities, entries: collectTree(s.dir),
+        });
+      } catch (e) { push(e); }
+    }
+  }
+
+  return { checked: subs.length, problems };
+}
+
+// ── CLI ────────────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const o = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith('--')) throw new RunError(`不认得参数 ${a}`);
+    const eq = a.indexOf('=');
+    const name = eq === -1 ? a : a.slice(0, eq);
+    const val = eq === -1 ? argv[++i] : a.slice(eq + 1);
+    if (val === undefined) throw new RunError(`${name} 需要一个值`);
+    o[name.slice(2)] = val;
+  }
+  return o;
+}
+
+/** `owners.json` 里已注册的 namespace 集合。文件不存在 = 一个都还没注册。 */
+function readRegistered(path) {
+  if (!existsSync(path)) return new Set();
+  try {
+    return new Set(Object.keys(parseStrict(readFileSync(path, 'utf8')).namespaces ?? {}));
+  } catch {
+    // 🔴 读不出来时**当成空的**是危险的：那会让每个 namespace 都被判成
+    //    「首次注册」，于是任何人都能声明 claim_owner。宁可整个门失败。
+    throw new RunError(`${path} 读不出来 —— 拒绝在「不知道谁注册过」的情况下判首次注册`);
+  }
+}
+
+export function main(argv) {
+  const o = parseArgs(argv);
+  const submissionsRoot = o.submissions ?? 'submissions';
+
+  // 已有制品：从 artifacts/ 树里数（快照可能还不存在）
+  const existingIds = [];
+  const existingNamesByNs = new Map();
+  const artifactsRoot = o.artifacts ?? 'artifacts';
+  if (existsSync(artifactsRoot)) {
+    for (const kindDir of readdirSync(artifactsRoot)) {
+      const kind = kindDir === 'skills' ? 'skill' : kindDir === 'packs' ? 'pack' : null;
+      if (kind === null) continue;
+      for (const ns of readdirSync(join(artifactsRoot, kindDir))) {
+        for (const name of readdirSync(join(artifactsRoot, kindDir, ns))) {
+          if (!existingNamesByNs.has(ns)) existingNamesByNs.set(ns, []);
+          existingNamesByNs.get(ns).push(name);
+          for (const v of readdirSync(join(artifactsRoot, kindDir, ns, name))) {
+            existingIds.push(`${kind}:${ns}/${name}@${v}`);
+          }
+        }
+      }
+    }
+  }
+
+  const { checked, problems } = runGates({
+    submissionsRoot,
+    reserved: readReserved(o.reserved ?? 'registry/reserved.json'),
+    existingIds,
+    existingNamesByNs,
+    // 🔴 「是不是维护者」是 PR 侧的事实，默认 **false**（fail-closed）：
+    //    没传就按「不是维护者」处理，保留 namespace 因此会被拒。
+    byMaintainer: o['by-maintainer'] === 'true',
+    // 已注册的 namespace —— 用来判「这次是不是首次注册」
+    registeredNamespaces: readRegistered(o.owners ?? 'registry/owners.json'),
+  });
+
+  if (checked === 0) {
+    process.stderr.write('没有待检的投稿（submissions/ 为空）。\n');
+    return 0;
+  }
+  if (problems.length) {
+    process.stderr.write(`🔴 ${checked} 个投稿里有 ${problems.length} 处不合规：\n`);
+    for (const p of problems) process.stderr.write(`  · ${p}\n`);
+    return 1;
+  }
+  process.stderr.write(`✔ ${checked} 个投稿全部通过结构门。\n`);
+  return 0;
+}
+
+export { RunError };
+
+// 入口守卫比 realpath —— 见 scripts/release/build-timestamp.mjs 里的说明。
+function invokedDirectly() {
+  if (process.argv[1] === undefined) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch { return true; }
+}
+
+if (invokedDirectly()) {
+  try { process.exit(main(process.argv.slice(2))); } catch (e) {
+    process.stderr.write(`${e.message}\n`);
+    process.exit(1);
+  }
+}