@oj-module/cli 0.2.30 → 0.2.43

package/src/lifecycle/__tests__/manifest-contract.test.ts

@@ -14,7 +14,7 @@ import { parse } from "yaml";
 // 跨端引用（双端一致钉）：被测实现同仓分居两运行时（计划 §1「两运行时取舍」），
 // 测试直接互调，比「两套件各读同一夹具」更强——漂移即本文件红。
 import { preflight } from "../../../templates/src/_platform/api/_lifecycle/steps/preflight";
-import { checkLocalesComplete, checkTablesAgainstSchema, parseManifest, validateContract } from "../../manifest-contract";
+import { checkLocalesComplete, checkTablesAgainstSchema, parseManifest, RESERVED_NAMES, reservedNameSuggestions, validateContract } from "../../manifest-contract";
 
 const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), "fixtures");
 const readText = (p: string) => readFileSync(join(FIXTURES, p), "utf8");
@@ -62,6 +62,11 @@ interface RuleCase {
 const RULES: RuleCase[] = [
 	{ rule: "name 白名单（大写拒绝）", clause: "C2-01", keyword: "name", mutate: (m) => { m.name = "Demo"; } },
 	{ rule: "name 保留名（market，R9）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "market"; } },
+	{ rule: "name 保留名（oj，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "oj"; } },
+	{ rule: "name 保留名（ojm，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "ojm"; } },
+	{ rule: "name 保留名（registry，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "registry"; } },
+	{ rule: "api.prefix 保留段（registry，REG-CS7）", clause: "C2-13", keyword: "保留名", mutate: (m) => { m.api.prefix = "/api/registry"; } },
+	{ rule: "web.route_prefix 保留段（ojm，REG-CS7）", clause: "C2-14", keyword: "保留名", mutate: (m) => { m.web.route_prefix = "/ojm"; } },
 	{ rule: "version 禁 +（oj 相容排除，附录 B-1）", clause: "C2-02", keyword: "version", mutate: (m) => { m.version = "1.0.0+build.5"; } },
 	{ rule: "version 禁下划线（契约收紧）", clause: "C2-02", keyword: "version", mutate: (m) => { m.version = "1.0.0_beta"; } },
 	{ rule: "title ≤100", clause: "C2-03", keyword: "title", mutate: (m) => { m.title = "x".repeat(101); } },
@@ -170,6 +175,40 @@ describe("parseManifest", () => {
 	});
 });
 
+describe("rEG-CS7 保留名扩项（红队 F5）", () => {
+	it("oj/ojm/registry 命中保留名 → C2-01 违规且含替代名建议（两候选）", () => {
+		for (const bad of ["oj", "ojm", "registry"]) {
+			const m = structuredClone(VALID);
+			m.name = bad;
+			const v = validateContract(m);
+			const hit = v.find(x => x.includes("C2-01") && x.includes(bad));
+			expect(hit, `期望 ${bad} 命中 C2-01 保留名，实际：\n${v.join("\n")}`).toBeTruthy();
+			expect(hit).toContain("为保留名");
+			expect(hit).toContain("替代名建议");
+			const [a1, a2] = reservedNameSuggestions(bad);
+			expect(hit).toContain(a1);
+			expect(hit).toContain(a2);
+		}
+	});
+
+	it("真实第一方方案名不被误伤（oj-registry / demo-solution 等）", () => {
+		for (const okName of ["oj-registry", "demo-solution", "oj-module", "ojm-cli"]) {
+			expect(RESERVED_NAMES.has(okName)).toBe(false);
+			const m = structuredClone(VALID);
+			m.name = okName;
+			const v = validateContract(m);
+			expect(v.find(x => x.includes("C2-01") && x.includes(okName))).toBeUndefined();
+		}
+	});
+
+	it("rEG-CS7 扩项后保留名清单含 oj/ojm/registry 且数量正确", () => {
+		expect(RESERVED_NAMES.has("oj")).toBe(true);
+		expect(RESERVED_NAMES.has("ojm")).toBe(true);
+		expect(RESERVED_NAMES.has("registry")).toBe(true);
+		expect(RESERVED_NAMES.size).toBe(11);
+	});
+});
+
 // ── 文件面契约（构建期专属执行点；纯内容入参，fs 在 bundle.ts）──
 
 describe("checkTablesAgainstSchema（C2-12a：构建 ✅ 对照 schema.yaml）", () => {

package/src/lifecycle/__tests__/publish.test.ts

@@ -1,33 +1,46 @@
-// publish 命令 spec（P3-5/6/7）：重算索引 + detached .sig 签名写回 + 离线自检。
-// 纯 Node 侧（与 ojm sign 同签名原语 lifecycle/sign.ts），验证侧用 verifyCanonical 复核。
-import { existsSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+// ojm publish spec（P3-5/6/7，REG-CS5 三级化后）：对发布目录的 catalog.yaml + shards/<n>.yaml
+// 重算 → 盖章代次时效 → detached .sig 签名写回 → 离线自检。纯 Node 侧（与 ojm sign 同签名
+// 原语 lifecycle/sign.ts），验证侧用 verifyCanonical 复核。
+//
+// 本文件钉死的不变量：
+// ① catalog / shard 两种 kind 的签名各自覆盖 (kind, seq)——换 kind 或换代即失配（REG-CS1）；
+// ② 分片代次由 catalog 的 `shards` 钉值承载，逐片与盘上 .sig 交叉核对，对不上不替它签字；
+// ③ 落盘顺序固定「先分片 → 再 catalog」（catalog 是提交点，红队 F2 半写防线）；
+// ④ 索引写入全仓只有 writeIndexFile 一条路径（源码级不变量，grep 可证）。
+import fs, { existsSync, mkdirSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { indexCanonical, publishCommand, recomputeIndex, signIndex } from "../../publish";
-import { verifyCanonical } from "../sign";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { parse as yamlParse } from "yaml";
+import { INDEX_TTL_SECONDS, indexCanonical, publishCommand, recomputeIndex, signIndex } from "../../publish";
+import { CANON, verifyCanonical } from "../sign";
 import { defaultTestKey } from "./helpers";
 
-const BUNDLES = `solutions:
+/** 首代索引夹具：catalog 钉 1 号片（代次 1），分片持一个方案的一个版本 */
+const CATALOG = `shards:
+  "1": 1
+solutions:
+  - name: demo-solution
+    shards:
+      - 1
+`;
+const SHARD1 = `solutions:
   - name: demo-solution
     latest: 0.1.0
     versions:
       - version: 0.1.0
         file: demo-solution-0.1.0.tgz
 `;
-const MANIFESTS = `- name: demo-solution
-  version: 0.1.0
-  author: acme
-  changelog: initial
-`;
 
 let dir: string;
 let keyPath: string;
 
 beforeEach(() => {
 	dir = mkdtempSync(join(tmpdir(), "ojm-publish-"));
-	writeFileSync(join(dir, "bundles.yaml"), BUNDLES);
-	writeFileSync(join(dir, "manifests.yaml"), MANIFESTS);
+	writeFileSync(join(dir, "catalog.yaml"), CATALOG);
+	mkdirSync(join(dir, "shards"), { recursive: true });
+	writeFileSync(join(dir, "shards", "1.yaml"), SHARD1);
 	keyPath = join(dir, "key.pem");
 	writeFileSync(keyPath, defaultTestKey().privateKeyPem);
 });
@@ -36,23 +49,57 @@ afterEach(() => {
 	// 临时目录由 OS 回收（测试用 tmpdir，无需手动 rm）
 });
 
-describe("ojm publish 索引重算 + 签名（P3-5/6/7）", () => {
-	it("重算两份索引并产出 detached .sig，签名可被 verifyCanonical 复核通过", () => {
+/** 读回 catalog 正文（解析后的文档） */
+function catalogDoc(): Record<string, unknown> {
+	return yamlParse(readFileSync(join(dir, "catalog.yaml"), "utf8")) as Record<string, unknown>;
+}
+
+/** 读回某个分片的 .sig（JSON） */
+function shardSig(no: number): { seq?: unknown, value: string } {
+	return JSON.parse(readFileSync(join(dir, "shards", `${no}.yaml.sig`), "utf8"));
+}
+
+describe("ojm publish 索引重算 + 签名（P3-5/6/7，REG-CS5 三级化）", () => {
+	it("重算 catalog 与分片并产出 detached .sig，两种 kind 各自可被 verifyCanonical 复核通过", () => {
 		const res = publishCommand(dir, { key: keyPath, id: "test.publisher" });
-		expect(existsSync(res.bundlesSigPath)).toBe(true);
-		expect(existsSync(res.manifestsSigPath)).toBe(true);
+		expect(existsSync(res.catalogSigPath)).toBe(true);
+		expect(res.shardPaths).toEqual([join(dir, "shards", "1.yaml")]);
+		expect(res.shardSigPaths).toEqual([join(dir, "shards", "1.yaml.sig")]);
 		expect(res.keyId).toBe("test.publisher");
 
-		const bundlesText = readFileSync(res.bundlesPath, "utf8");
-		const manifestsText = readFileSync(res.manifestsPath, "utf8");
-		const bundlesSig = JSON.parse(readFileSync(res.bundlesSigPath, "utf8"));
-		const manifestsSig = JSON.parse(readFileSync(res.manifestsSigPath, "utf8"));
+		const catalogText = readFileSync(res.catalogPath, "utf8");
+		const shard1Text = readFileSync(res.shardPaths[0]!, "utf8");
+		const catalogSig = JSON.parse(readFileSync(res.catalogSigPath, "utf8"));
+		const sig1 = shardSig(1);
+
+		expect(catalogSig.alg).toBe("Ed25519");
+		expect(catalogSig.key_id).toBe("test.publisher");
+		expect(catalogSig.canon).toBe(CANON);
+		// REG-CS1/CS2：签名覆盖代次——`.sig` 与 catalog 正文各带 seq 且相等；分片代次 = catalog 钉值
+		expect(catalogSig.seq).toBe(1);
+		expect(sig1.seq).toBe(1);
+		expect(catalogDoc().seq).toBe(1);
+		// 时效盖进 catalog 正文并由签名锁定（REG-CS2）：有效期 = 全仓唯一的 INDEX_TTL_SECONDS
+		const times = catalogDoc() as { issued_at?: unknown, expires_at?: unknown };
+		expect(typeof times.issued_at).toBe("number");
+		expect(times.expires_at as number - (times.issued_at as number)).toBe(INDEX_TTL_SECONDS);
+		// 两种 kind 分别验过（规范串首段就是 kind）
+		expect(verifyCanonical(res.publicKeyHex, indexCanonical("catalog", 1, catalogText), catalogSig.value)).toBe(true);
+		expect(verifyCanonical(res.publicKeyHex, indexCanonical("shard", 1, shard1Text), sig1.value)).toBe(true);
+	});
+
+	it("换代即失效、换 kind 即失效（REG-CS1：签名锁定 (kind, seq)，两代拼不起来）", () => {
+		const res = publishCommand(dir, { key: keyPath, id: "test.publisher" });
+		const catalogText = readFileSync(res.catalogPath, "utf8");
+		const shard1Text = readFileSync(res.shardPaths[0]!, "utf8");
+		const catalogSig = JSON.parse(readFileSync(res.catalogSigPath, "utf8"));
+		const sig1 = shardSig(1);
 
-		expect(bundlesSig.alg).toBe("Ed25519");
-		expect(bundlesSig.key_id).toBe("test.publisher");
-		expect(bundlesSig.canon).toBe("v1");
-		expect(verifyCanonical(res.publicKeyHex, indexCanonical("bundles", bundlesText), bundlesSig.value)).toBe(true);
-		expect(verifyCanonical(res.publicKeyHex, indexCanonical("manifests", manifestsText), manifestsSig.value)).toBe(true);
+		// 换代：同一份正文谎称第 2 代 → 验不过（防「新总目录 + 旧分册」被拼起来用，红队 F2）
+		expect(verifyCanonical(res.publicKeyHex, indexCanonical("catalog", 2, catalogText), catalogSig.value)).toBe(false);
+		// 换 kind：分片签名不能当 catalog 签名用，反之亦然
+		expect(verifyCanonical(res.publicKeyHex, indexCanonical("catalog", 1, shard1Text), sig1.value)).toBe(false);
+		expect(verifyCanonical(res.publicKeyHex, indexCanonical("shard", 1, catalogText), catalogSig.value)).toBe(false);
 	});
 
 	it("--check 离线自检通过（checkPassed === true）", () => {
@@ -64,17 +111,111 @@ describe("ojm publish 索引重算 + 签名（P3-5/6/7）", () => {
 		const a = recomputeIndex("x: 1\ny: 2\n");
 		const b = recomputeIndex("y: 2\nx: 1\n");
 		expect(a).toBe(b);
-		// 重算文本可被 signIndex 正常签出五字段
-		const sig = signIndex("bundles", a, defaultTestKey().privateKeyPem, "test.publisher");
-		expect(verifyCanonical(defaultTestKey().publicKeyHex, indexCanonical("bundles", a), sig.value)).toBe(true);
+		// 重算文本可被 signIndex 正常签出六字段（含 seq）
+		const sig = signIndex("catalog", 7, a, defaultTestKey().privateKeyPem, "test.publisher");
+		expect(sig.seq).toBe(7);
+		expect(verifyCanonical(defaultTestKey().publicKeyHex, indexCanonical("catalog", 7, a), sig.value)).toBe(true);
+	});
+
+	it("补签沿用既有的代次与时效（catalog seq 2 + 分片钉 5：重签不改时效语义）", () => {
+		// 第二代索引：catalog 顶层 seq=2、时效是一代签发时刻盖的；1 号片钉第 5 代且盘上 .sig 就是第 5 代
+		writeFileSync(join(dir, "catalog.yaml"), `seq: 2\nissued_at: 1000\nexpires_at: ${1000 + INDEX_TTL_SECONDS}\n${CATALOG.replace(/shards:\n {2}"1": 1/, "shards:\n  \"1\": 5")}`);
+		writeFileSync(join(dir, "shards", "1.yaml.sig"), `${JSON.stringify(signIndex("shard", 5, recomputeIndex(SHARD1), defaultTestKey().privateKeyPem, "test.publisher"), null, 2)}\n`);
+
+		const res = publishCommand(dir, { key: keyPath, id: "test.publisher" });
+		const catalogSig = JSON.parse(readFileSync(res.catalogSigPath, "utf8"));
+		expect(catalogSig.seq).toBe(2); // 代次沿用，不重置
+		expect(shardSig(1).seq).toBe(5); // 分片代次跟 catalog 钉值，不跟 catalog seq
+		const times = catalogDoc() as { issued_at?: unknown, expires_at?: unknown };
+		expect(times.issued_at).toBe(1000); // 重签不改时效
+		expect(times.expires_at).toBe(1000 + INDEX_TTL_SECONDS);
+	});
+
+	it("同内容重复 publish 字节一致（Ed25519 确定性签名 + 键序归一化）", () => {
+		const first = publishCommand(dir, { key: keyPath, id: "test.publisher" });
+		const catalogA = readFileSync(first.catalogPath);
+		const sigA = readFileSync(first.catalogSigPath);
+		const shardA = readFileSync(first.shardPaths[0]!);
+		const shardSigA = readFileSync(first.shardSigPaths[0]!);
+
+		const second = publishCommand(dir, { key: keyPath, id: "test.publisher" });
+		expect(readFileSync(second.catalogPath)).toEqual(catalogA);
+		expect(readFileSync(second.catalogSigPath)).toEqual(sigA);
+		expect(readFileSync(second.shardPaths[0]!)).toEqual(shardA);
+		expect(readFileSync(second.shardSigPaths[0]!)).toEqual(shardSigA);
+	});
+
+	it("缺 catalog.yaml → 抛错（不发半成品 .sig）", () => {
+		unlinkSync(join(dir, "catalog.yaml"));
+		expect(() => publishCommand(dir, { key: keyPath, id: "test.publisher" })).toThrow(/须含 catalog\.yaml/);
+	});
+
+	it("catalog 钉了 shards/2.yaml 但文件不存在 → 抛错（钉引用与盘上内容对不上就不签）", () => {
+		writeFileSync(join(dir, "catalog.yaml"), "shards:\n  \"1\": 1\n  \"2\": 1\nsolutions:\n  - name: demo-solution\n    shards:\n      - 1\n      - 2\n");
+		expect(() => publishCommand(dir, { key: keyPath, id: "test.publisher" })).toThrow(/catalog 钉了 shards\/2\.yaml 但文件不存在/);
+	});
+
+	it("分片 .sig 代次与 catalog 钉值不符 → index_generation_mismatch，且什么都不写", () => {
+		// 盘上 1 号片签的是第 1 代，catalog 却钉第 2 代——中间态（源正在重建 / 索引被手改）
+		writeFileSync(join(dir, "shards", "1.yaml.sig"), `${JSON.stringify(signIndex("shard", 1, recomputeIndex(SHARD1), defaultTestKey().privateKeyPem, "test.publisher"), null, 2)}\n`);
+		writeFileSync(join(dir, "catalog.yaml"), CATALOG.replace("\"1\": 1", "\"1\": 2"));
+		const catalogBefore = readFileSync(join(dir, "catalog.yaml"));
+		const shardBefore = readFileSync(join(dir, "shards", "1.yaml"));
+
+		expect(() => publishCommand(dir, { key: keyPath, id: "test.publisher" })).toThrow(/index_generation_mismatch/);
+		// fail-closed 的完整性：拒签时盘上一个字节都没动（没有半代索引落盘）
+		expect(readFileSync(join(dir, "catalog.yaml"))).toEqual(catalogBefore);
+		expect(readFileSync(join(dir, "shards", "1.yaml"))).toEqual(shardBefore);
+		expect(existsSync(join(dir, "catalog.yaml.sig"))).toBe(false);
+		expect(existsSync(join(dir, "shards", "1.yaml.sig"))).toBe(true); // 旧签名原样保留（本来就对不上，不擦除证据）
 	});
 
-	it("缺索引文件 → 抛错（不发半成品 .sig）", () => {
-		unlinkSync(join(dir, "bundles.yaml"));
-		expect(() => publishCommand(dir, { key: keyPath, id: "test.publisher" })).toThrow(/须含 bundles\.yaml 与 manifests\.yaml/);
+	it("分片 .sig 不可解析 → 抛错（无法核对代次，拒签）", () => {
+		writeFileSync(join(dir, "shards", "1.yaml.sig"), "{ not json");
+		expect(() => publishCommand(dir, { key: keyPath, id: "test.publisher" })).toThrow(/不可解析/);
 	});
 
 	it("私钥缺失 → 抛错（fail-closed，不静默）", () => {
 		expect(() => publishCommand(dir, { key: join(dir, "nope.pem"), id: "test.publisher" })).toThrow(/私钥文件不存在/);
 	});
+
+	it("原子落盘顺序固定「先分片 → 再 catalog」（catalog 是提交点，红队 F2 半写防线）", () => {
+		// 两片夹具：1 号片未签名（首签）、2 号片已有旧签名（补签）
+		writeFileSync(join(dir, "shards", "2.yaml"), SHARD1.replace("0.1.0", "0.2.0"));
+		writeFileSync(join(dir, "catalog.yaml"), "shards:\n  \"1\": 1\n  \"2\": 4\nsolutions:\n  - name: demo-solution\n    shards:\n      - 1\n      - 2\n");
+		writeFileSync(join(dir, "shards", "2.yaml.sig"), `${JSON.stringify(signIndex("shard", 4, recomputeIndex(readFileSync(join(dir, "shards", "2.yaml"), "utf8")), defaultTestKey().privateKeyPem, "test.publisher"), null, 2)}\n`);
+
+		const landed: string[] = [];
+		const origRename = fs.renameSync.bind(fs);
+		const spy = vi.spyOn(fs, "renameSync").mockImplementation(((...args: Parameters<typeof fs.renameSync>) => {
+			landed.push(join(String(args[0])).split("/").pop()!.replace(/\.tmp\..*$/, "")); // 记录落盘目标名（剥掉 tmp 后缀）
+			return origRename(...args);
+		}) as typeof fs.renameSync);
+		try {
+			publishCommand(dir, { key: keyPath, id: "test.publisher" });
+		}
+		finally {
+			spy.mockRestore();
+		}
+		// 全部分片（正文 + 签名）落完后才落 catalog（正文 + 签名）——catalog 一变即新代生效，
+		// 它钉的片必须早已在盘上；顺序反了就会开出「catalog 钉了不存在的片」的窗口
+		expect(landed).toEqual(["1.yaml", "1.yaml.sig", "2.yaml", "2.yaml.sig", "catalog.yaml", "catalog.yaml.sig"]);
+	});
+
+	it("索引写入只有 writeIndexFile 一条路径（源码级不变量，grep 可证）", () => {
+		const srcOf = (rel: string) => readFileSync(fileURLToPath(new URL(rel, import.meta.url)), "utf8");
+		const countOf = (text: string, re: RegExp) => text.split("\n").filter(line => re.test(line)).length;
+		// 生成侧：publish.ts 里唯一的 fs.writeFileSync 就在 writeIndexFile 体内（tmp+rename）；
+		// build-index.ts 零直写——索引文件全部经唯一写入口
+		expect(countOf(srcOf("../../publish.ts"), /fs\.writeFileSync/)).toBe(1);
+		expect(countOf(srcOf("../../publish.ts"), /appendFileSync/)).toBe(0);
+		expect(countOf(srcOf("../../market/build-index.ts"), /fs\.writeFileSync|writeFileSync\(/)).toBe(0);
+		expect(countOf(srcOf("../../market/build-index.ts"), /appendFileSync/)).toBe(0);
+		// 全仓其余直写只剩 walkthrough 的负向演练：往 catalog 追加重码标记（drill 本身），
+		// 且回抄恢复走 writeIndexFile——除这一行 deliberate tamper 外没有第二个索引直写点
+		const walkthrough = srcOf("../../market/walkthrough.ts");
+		expect(countOf(walkthrough, /appendFileSync/)).toBe(1);
+		expect(countOf(walkthrough, /# tampered/)).toBe(1);
+		expect(countOf(walkthrough, /writeIndexFile\(catalog/)).toBe(1);
+	});
 });

package/src/lifecycle/__tests__/sig-fixtures.test.ts

@@ -15,6 +15,7 @@ import {
 	canonicalString,
 	fingerprintOf,
 	FIXTURE_NAME,
+	FIXTURE_REGISTRY_ID,
 	FIXTURE_VERSION,
 	generate,
 	TRUSTED_KEY,
@@ -31,6 +32,7 @@ interface Sig {
 	public_key: string
 	value: string
 	canon: string
+	registry_id: string
 }
 
 const readSig = (suffix: string): Sig => JSON.parse(readFileSync(`${tgzPath}${suffix}`, "utf8")) as Sig;
@@ -43,20 +45,21 @@ const KEY_ID = /^[a-z][a-z0-9-]*\.[a-z0-9-]+$/;
 describe("签名链夹具（P2-0）", () => {
 	const tgz = readFileSync(tgzPath);
 	const sha256 = createHash("sha256").update(tgz).digest("hex");
-	const canonical = canonicalString(FIXTURE_NAME, FIXTURE_VERSION, sha256);
+	const canonical = canonicalString(FIXTURE_REGISTRY_ID, FIXTURE_NAME, FIXTURE_VERSION, sha256);
 	const good = readSig(".sig");
 	const bad = readSig(".bad.sig");
 	const unknownSig = readSig(".unknown.sig");
 
-	it("规范串逐字 = <name>@<version>:<sha256>（契约 §2.11 格式表）", () => {
-		expect(canonical).toBe(`${FIXTURE_NAME}@${FIXTURE_VERSION}:${sha256}`);
-		expect(canonical).toMatch(/^demo-solution@0\.2\.0:[0-9a-f]{64}$/);
+	it("规范串逐字 = <registry_id>:<name>@<version>:<sha256>（REG-CS3 v2 格式表）", () => {
+		expect(canonical).toBe(`${FIXTURE_REGISTRY_ID}:${FIXTURE_NAME}@${FIXTURE_VERSION}:${sha256}`);
+		expect(canonical).toMatch(/^test\.registry:demo-solution@0\.2\.0:[0-9a-f]{64}$/);
 	});
 
-	it(".sig 五字段齐备且形态合法（alg 恒 Ed25519 / canon 恒 v1）", () => {
+	it(".sig 字段齐备且形态合法（alg 恒 Ed25519 / canon 恒 v2 / registry_id 存在）", () => {
 		for (const sig of [good, bad, unknownSig]) {
 			expect(sig.alg).toBe("Ed25519");
 			expect(sig.canon).toBe(CANON);
+			expect(sig.registry_id).toBe(FIXTURE_REGISTRY_ID);
 			expect(sig.public_key).toMatch(HEX64);
 			expect(sig.value).toMatch(STD_B64);
 			expect(sig.value).not.toMatch(/[-_]/); // 禁 base64url（§2.11 编码约束）
@@ -77,7 +80,7 @@ describe("签名链夹具（P2-0）", () => {
 		const tampered = Buffer.from(tgz);
 		tampered[100] ^= 0xFF;
 		const sha2 = createHash("sha256").update(tampered).digest("hex");
-		expect(verifyCanonicalB64(good.public_key, canonicalString(FIXTURE_NAME, FIXTURE_VERSION, sha2), good.value)).toBe(false);
+		expect(verifyCanonicalB64(good.public_key, canonicalString(FIXTURE_REGISTRY_ID, FIXTURE_NAME, FIXTURE_VERSION, sha2), good.value)).toBe(false);
 	});
 
 	it("未知 key 夹具是真实签名但 key_id 不在信任库（TOFU 场景锚点）", () => {

package/src/lifecycle/__tests__/sign.test.ts

@@ -7,25 +7,26 @@ import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { generateKeyPair } from "../keygen";
 import { CANON, canonicalString, exportRawPublicKeyHex, fingerprintOfPublicKey, SIG_ALG, signCanonical, verifyCanonical } from "../sign";
-import { FIXTURE_NAME, FIXTURE_VERSION, TRUSTED_KEY, UNKNOWN_KEY } from "./fixtures/sig/gen-signed-fixtures.mjs";
+import { FIXTURE_NAME, FIXTURE_REGISTRY_ID, FIXTURE_VERSION, TRUSTED_KEY, UNKNOWN_KEY } from "./fixtures/sig/gen-signed-fixtures.mjs";
 import { defaultTestKey, signedArchiveFor } from "./helpers";
 
 const SHA_A = "a".repeat(64);
+const REGISTRY = "test.registry";
 
-describe("规范串（C2-34）", () => {
-	it("拼接式逐字 <name>@<version>:<sha256>（契约 §2.11 格式表）", () => {
-		expect(canonicalString("demo-solution", "0.2.0", SHA_A)).toBe(`demo-solution@0.2.0:${SHA_A}`);
+describe("规范串（C2-34 / REG-CS3 v2）", () => {
+	it("拼接式逐字 <registry_id>:<name>@<version>:<sha256>（REG-CS3 v2 格式表）", () => {
+		expect(canonicalString(REGISTRY, "demo-solution", "0.2.0", SHA_A)).toBe(`test.registry:demo-solution@0.2.0:${SHA_A}`);
 	});
 
 	it("sha256 形态非法不拦截（规范化属调用方结构校验序，P2-3）", () => {
 		// 纯函数只负责拼接；sha256 合法性由 verify 段比对时保证（C2-29 fail-closed）
-		expect(canonicalString("a", "1", "short")).toBe("a@1:short");
+		expect(canonicalString(REGISTRY, "a", "1", "short")).toBe("test.registry:a@1:short");
 	});
 });
 
 describe("签验往返与对拍", () => {
 	const key = generateKeyPair();
-	const canonical = canonicalString("demo-solution", "0.1.0", SHA_A);
+	const canonical = canonicalString(REGISTRY, "demo-solution", "0.1.0", SHA_A);
 
 	it("sign → verifyCanonical 往返 true；篡改 canonical 一字符 → false", () => {
 		const sig = signCanonical(key.privateKeyPem, canonical);
@@ -59,7 +60,7 @@ describe("签验往返与对拍", () => {
 
 describe("编码面严格拒（C2-36，禁归一）", () => {
 	const key = generateKeyPair();
-	const canonical = canonicalString("demo-solution", "0.1.0", SHA_A);
+	const canonical = canonicalString(REGISTRY, "demo-solution", "0.1.0", SHA_A);
 	const good = signCanonical(key.privateKeyPem, canonical);
 
 	it("value 含 -/_（base64url 变体）→ false", () => {
@@ -101,7 +102,7 @@ describe("p2-0 夹具对拍（双端三同一锚点）", () => {
 	const SIG_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "sig");
 	const tgz = readFileSync(path.join(SIG_DIR, `${FIXTURE_NAME}-${FIXTURE_VERSION}.tgz`));
 	const sha256 = createHash("sha256").update(tgz).digest("hex");
-	const canonical = canonicalString(FIXTURE_NAME, FIXTURE_VERSION, sha256);
+	const canonical = canonicalString(FIXTURE_REGISTRY_ID, FIXTURE_NAME, FIXTURE_VERSION, sha256);
 	const readSig = (suffix: string) => JSON.parse(readFileSync(path.join(SIG_DIR, `${FIXTURE_NAME}-${FIXTURE_VERSION}.tgz${suffix}`), "utf8")) as { key_id: string, public_key: string, value: string, canon: string, alg: string };
 
 	it("已签/篡改/未知 key 三态经 sign.ts 验签结果与生成器一致", () => {

package/src/lifecycle/__tests__/smoke.test.ts

@@ -52,7 +52,7 @@ describe.skipIf(!smokeReady)("真机冒烟（需 OJM_SMOKE_URL/OJM_SMOKE_USER/OJ
 		const [built] = await buildBundle(project, { out: join(project, "dist") });
 		const { tgz } = built!;
 
-		const record = await installCommand(tgz, { url: SMOKE_URL ?? DEFAULT_SITE_URL, user: SMOKE_USER, pass: SMOKE_PASS });
+		const record = await installCommand(tgz, { siteUrl: SMOKE_URL ?? DEFAULT_SITE_URL, user: SMOKE_USER, pass: SMOKE_PASS });
 		expect(record.status).toBe("done");
 		expect(record.name).toBe("demo-solution");
 		expect(record.version).toBe("0.1.0");

package/src/lifecycle/__tests__/uninstall.test.ts

@@ -44,7 +44,7 @@ describe("uninstallCommand · 卸载瘦客户端（P1-15a 缺口 B）", () => {
 			"/api/auth/login": () => ok({ access_token: "tok", refresh_token: "r", expires_in: 1 }),
 			"/api/_platform/market/uninstall": () => ok({ ok: true, message: "卸载完成：四处同删（demo-solution@0.1.0）" }),
 		});
-		await uninstallCommand("demo-solution", { url: "http://x", user: "u", pass: "p", fetchFn });
+		await uninstallCommand("demo-solution", { siteUrl: "http://x", user: "u", pass: "p", fetchFn });
 		// 登录体 + uninstall JSON 体 + Bearer
 		expect(JSON.parse(String(calls[0]?.init?.body))).toEqual({ username: "u", password: "p" });
 		const call = calls[1]!;
@@ -63,7 +63,7 @@ describe("uninstallCommand · 卸载瘦客户端（P1-15a 缺口 B）", () => {
 		const exitBackup = process.exitCode;
 		process.exitCode = 0;
 		try {
-			await uninstallCommand("x", { url: "http://x", user: "u", pass: "p", fetchFn });
+			await uninstallCommand("x", { siteUrl: "http://x", user: "u", pass: "p", fetchFn });
 			expect(process.exitCode).toBe(1);
 		}
 		finally {
@@ -74,7 +74,7 @@ describe("uninstallCommand · 卸载瘦客户端（P1-15a 缺口 B）", () => {
 
 	it("空名 → 人话用法报错（不发网络）", async () => {
 		const { fetchFn, calls } = fetchStub({});
-		await expect(uninstallCommand("", { url: "http://x", user: "u", pass: "p", fetchFn })).rejects.toThrow(/用法/);
+		await expect(uninstallCommand("", { siteUrl: "http://x", user: "u", pass: "p", fetchFn })).rejects.toThrow(/用法/);
 		expect(calls).toHaveLength(0);
 	});
 
@@ -82,6 +82,6 @@ describe("uninstallCommand · 卸载瘦客户端（P1-15a 缺口 B）", () => {
 		const { fetchFn } = fetchStub({
 			"/api/auth/login": () => ({ ok: true, status: 200, text: async () => JSON.stringify({ code: 403, msg: "forbidden" }) }),
 		});
-		await expect(uninstallCommand("x", { url: "http://x", user: "u", pass: "p", fetchFn })).rejects.toThrow(/forbidden/);
+		await expect(uninstallCommand("x", { siteUrl: "http://x", user: "u", pass: "p", fetchFn })).rejects.toThrow(/forbidden/);
 	});
 });

package/src/lifecycle/sign.ts

@@ -6,8 +6,8 @@
 import { Buffer } from "node:buffer";
 import { createHash, createPrivateKey, createPublicKey, sign as nodeSign, verify as nodeVerify } from "node:crypto";
 
-/** 规范串版本标记（契约 §2.11：canon 字段恒 "v1"） */
-export const CANON = "v1";
+/** 规范串版本标记（REG-CS3 v2：canon 字段恒 "v2"；v1 一律按 canon_stale 拒） */
+export const CANON = "v2";
 /** 签名算法标识（大小写敏感，契约 §2.11 / C2-35） */
 export const SIG_ALG = "Ed25519";
 
@@ -18,12 +18,13 @@ const STD_B64 = /^[A-Z0-9+/]+={0,2}$/i;
 const SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 
 /**
- * 规范串（C2-34，拼接式逐字）：`<name>@<version>:<sha256>`。
- * name/version 取 bundle manifest 值，sha256 = tgz 字节 sha256（hex 小写）；
- * 禁止自造分隔符/归一化/大小写变换——两端与夹具三方逐字一致的前提。
+ * 规范串（REG-CS3 v2，拼接式逐字）：`<registry_id>:<slug>@<version>:<sha256>`。
+ * registry_id = 签发方 registry 身份（防跨仓库重放：A 签的包不能被 B 的 CDN 安装）；
+ * slug/version 取 bundle manifest 值，sha256 = tgz 字节 sha256（hex 小写）；
+ * 禁止自造分隔符/归一化/大小写变换——CLI 签发与站点验签两端逐字一致的前提。
  */
-export function canonicalString(name: string, version: string, sha256: string): string {
-	return `${name}@${version}:${sha256}`;
+export function canonicalString(registryId: string, slug: string, version: string, sha256: string): string {
+	return `${registryId}:${slug}@${version}:${sha256}`;
 }
 
 /** 指纹 = sha256Hex(publicKey) 全 64 hex（契约 §2.11，TOFU 展示用） */

package/src/list.ts

@@ -0,0 +1,146 @@
+// `ojm list`（站点已装方案的可查面）：登录 → GET /api/_platform/market/index → 只挑已装的打表。
+//
+// 为什么需要它：到 0.3.2 为止，CLI **没有任何一条命令能回答「这个站点上装了什么」**——
+// 装完只有一条终态文案，之后要核对版本/启用态得登站点翻市场页。运维与 CI 都需要一个
+// 可脚本化的清单（升级前看谁落后、禁用后确认状态、卸载前确认名字）。
+//
+// 为什么复用 `GET /_platform/market/index` 而不是新增端点：这一条已经把三件事聚合好了——
+// sidecar 里的 installed/enabled、索引里的 latest/available（算 upgradable）、信任库判定
+// 出的 trust_state。新增一个「只列已装」的端点等于让两个真相源各自漂移，而站点侧那边
+// 本来就要维护全量行（市场页在用）。
+//
+// 缺省只列**已装**（installed != null）：`ojm list` 的语义是「我这台机器上有什么」，
+// 不是「市场里有什么」；要后者用 `--all`（未装的行 installed 显示 `-`）。
+import { emit } from "./cli-output";
+import { UsageError } from "./exit-codes";
+import { callApi, login, resolveSite } from "./site";
+
+/** 市场索引行里本命令消费的字段（其余字段站点可能扩，不读即不依赖） */
+interface MarketIndexRow {
+	name?: unknown
+	installed?: unknown
+	enabled?: unknown
+	latest?: unknown
+	upgradable?: unknown
+	trust_state?: unknown
+}
+
+export type TrustState = "trusted" | "untrusted" | "absent" | null;
+
+export interface SolutionRow {
+	/** 物理名（= 磁盘目录/路由前缀/包名，站点侧 identity） */
+	name: string
+	/** 已装版本；null = 未装 */
+	installed: string | null
+	/** 启用态；null = 未装或站点未给 */
+	enabled: boolean | null
+	/** 索引里的最新版；null = 该方案只在本地存在（源自建包） */
+	latest: string | null
+	/** 已装且落后于最新版 */
+	upgradable: boolean
+	/** 站点信任库对已装包签名 key 的判定 */
+	trustState: TrustState
+}
+
+export interface ListOptions {
+	siteUrl?: string
+	user?: string
+	pass?: string
+	/** 连未安装的索引行一起列（缺省只列已装） */
+	all?: boolean
+	json?: boolean
+	/** 测试注入；缺省 globalThis.fetch */
+	fetchFn?: typeof fetch
+}
+
+function asTrustState(raw: unknown): TrustState {
+	return raw === "trusted" || raw === "untrusted" || raw === "absent" ? raw : null;
+}
+
+/** 取一份已装清单（`--all` 时含未装）。不打印、不 exit 的纯函数层，便于 CI 直接在进程内用。 */
+export async function fetchInstalled(fetchFn: typeof fetch, base: string, token: string, all: boolean): Promise<SolutionRow[]> {
+	const rows = await callApi<MarketIndexRow[]>(fetchFn, base, token, "GET", "/api/_platform/market/index");
+	const out: SolutionRow[] = [];
+	for (const raw of rows) {
+		const name = String(raw.name ?? "").trim();
+		if (name === "")
+			continue;
+		const installed = typeof raw.installed === "string" && raw.installed !== "" ? raw.installed : null;
+		if (installed === null && !all)
+			continue;
+		out.push({
+			name,
+			installed,
+			enabled: typeof raw.enabled === "boolean" ? raw.enabled : null,
+			latest: typeof raw.latest === "string" && raw.latest !== "" ? raw.latest : null,
+			upgradable: raw.upgradable === true,
+			trustState: asTrustState(raw.trust_state),
+		});
+	}
+	return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+/** 按单元格宽度补齐（ASCII slug + 数字，不做 CJK 宽度换算） */
+function pad(text: string, width: number): string {
+	return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+
+function renderTable(rows: SolutionRow[]): string[] {
+	const header = ["NAME", "INSTALLED", "ENABLED", "LATEST", "UPGRADABLE", "TRUST"];
+	const cells = rows.map(r => [
+		r.name,
+		r.installed ?? "-",
+		r.enabled === null ? "-" : r.enabled ? "yes" : "no",
+		r.latest ?? "-",
+		r.installed === null ? "-" : r.upgradable ? "yes" : "no",
+		r.trustState ?? "-",
+	]);
+	const widths = header.map((h, i) => Math.max(h.length, ...cells.map(c => c[i]!.length)));
+	const line = (cols: string[]): string => cols.map((c, i) => pad(c, widths[i]!)).join("  ").trimEnd();
+	return [line(header), ...cells.map(line)];
+}
+
+/**
+ * 列表命令体：登录 → 取市场索引 → 过滤 → 打印（`--json` 走统一信封）。
+ * 返回行数组（测试/CI 断言用）。
+ */
+export async function listCommand(opts: ListOptions = {}): Promise<SolutionRow[]> {
+	let site: { base: string, user: string, pass: string };
+	try {
+		site = resolveSite(opts);
+	}
+	catch (error) {
+		// 缺凭据是用法错误（2）：补参数就能解决，不该和「站点报错」混成 1
+		throw new UsageError((error as Error).message);
+	}
+	const fetchFn = opts.fetchFn ?? globalThis.fetch;
+	const token = await login(fetchFn, site.base, site.user, site.pass);
+	const solutions = await fetchInstalled(fetchFn, site.base, token, opts.all === true);
+
+	const human: string[] = [];
+	if (solutions.length === 0) {
+		human.push(opts.all === true
+			? `[ojm] 站点 ${site.base} 的市场索引是空的（既没有已装方案，也没有可装方案）`
+			: `[ojm] 站点 ${site.base} 上还没有已装方案（要连可装的一起看：ojm list --all）`);
+	}
+	else {
+		const installed = solutions.filter(r => r.installed !== null).length;
+		human.push(opts.all === true
+			? `[ojm] 站点 ${site.base}：${solutions.length} 个方案（已装 ${installed} 个）`
+			: `[ojm] 站点 ${site.base}：已装 ${installed} 个方案`);
+		human.push(...renderTable(solutions));
+		const upgradable = solutions.filter(r => r.upgradable).map(r => r.name);
+		if (upgradable.length > 0)
+			human.push(`[ojm] 可升级：${upgradable.join(", ")}（ojm install <name> 装最新版）`);
+		const untrusted = solutions.filter(r => r.trustState === "untrusted").map(r => r.name);
+		if (untrusted.length > 0)
+			human.push(`[ojm] 签名不受信：${untrusted.join(", ")}（先 ojm trust add 确认发布方公钥）`);
+	}
+
+	emit({
+		command: "list",
+		data: { site: site.base, all: opts.all === true, solutions },
+		human,
+	}, { json: !!opts.json });
+	return solutions;
+}