@oj-module/cli 0.2.69 → 0.2.71

package/src/market/verify.ts

@@ -1,18 +1,20 @@
 /**
- * `ojm market verify`（T7 + REG-CS5 三级化）：离线验包——不起站点、不装、不要凭据、不要 DB。
+ * `ojm market verify`（A6 瘦身）：离线验包——不起站点、不装、不要凭据、不要 DB。
  *
- * 分四类列结果（包级与索引级**分开**，因为语义不同）：
- * - 完整性：tgz 实际 sha256 与索引声明的 archive.sha256 是否一致（三级化后声明住在分片正文里）；
- * - 包级签名：`<tgz>.sig` 能否用包内公钥复核规范串 `<name>@<version>:<sha256>`——**这是信任锚**；
- * - 索引签名：索引字节与其 `.sig`——只是完整性层（防目录/索引被改），不是信任锚；
- * - manifest 结构：必填字段、内嵌原生清单 desc 是否非空（oj 装配面必填）、同方案各版本 0001 迁移是否逐字节一致。
+ * v4 DB 目录化后**只剩包级面**（计划退役清单点名：generationCheck/driftOf/declaredHashes
+ * 等索引面整建制删除——目录真源已移交站点 market_release 表，索引文件不复存在）：
+ * - 包级签名：`<tgz>.sig` 能否用包内公钥复核规范串 `<registry_id>:<name>@<version>:<sha256>`
+ *   ——**这是信任锚**（安装侧 TOFU 的同一道验签）；
+ * - manifest 结构：必填字段、内嵌原生清单 desc 是否非空（oj 装配面必填）、同方案各版本
+ *   0001 迁移是否逐字节一致。
+ *
+ * 完整性（sha256 对索引声明比对）随之退役——声明真源是站点 DB 行，离线 CLI 无声明可比；
+ * 字节-声明一致性由上传端点服务端重算 sha256 硬约束在写通道守住。
  *
  * 复用既有原语，一行密码学都不重写：`lifecycle/sign.ts` 的 canonicalString/verifyCanonical、
- * `publish.ts` 的 indexCanonical/shardPinsOf、`node:crypto` 的 sha256。
+ * `scan.ts` 的 readTgz、`node:crypto` 的 sha256。
  */
 
-import type { IndexKind } from "../publish";
-import type { IndexedPackage } from "./index-builder";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -20,7 +22,6 @@ import path from "node:path";
 import process from "node:process";
 import { parse as yamlParse } from "yaml";
 import { CANON, canonicalString, verifyCanonical } from "../lifecycle/sign";
-import { indexCanonical, indexSeqOf, indexTimesOf, shardPinsOf } from "../publish";
 import { resolveCdnLayout } from "./cdn-layout";
 import { readTgz } from "./scan";
 
@@ -28,11 +29,7 @@ export interface VerifyCheck {
 	item: string
 	ok: boolean
 	detail: string
-	/**
-	 * 失败码（REG-CS1）：可区分的三种拒因，供安装侧与报告侧共用同一套判定。
-	 * `index_sig_missing` 缺 `.sig` / `index_sig_mismatch` 签名不符 /
-	 * `index_generation_mismatch` 跨文件不同代（运维事故，与安全事件分开报）。
-	 */
+	/** 失败码：可区分的拒因（包级面），供报告侧共用同一套判定 */
 	code?: string
 }
 
@@ -40,37 +37,20 @@ export interface VerifyOptions {
 	projectRoot?: string
 	/** 验指定的 tgz（缺省扫 cdn/ 下全部包） */
 	file?: string
-	/** 比对扫描重建出的索引与盘上索引，检出漂移 */
-	rebuildCheck?: boolean
 }
 
 export interface VerifyResult {
 	checks: VerifyCheck[]
 	passed: boolean
 	conclusion: string
-	/** `--rebuild-check` 的漂移描述；未传该开关时为 undefined */
-	drift?: string[]
 }
 
 const BOUNDARY = "完整性 / 来源校验通过——不构成内容安全性背书";
 
-/** 三级索引的读面快照：catalog 正文 + 各分片正文（REG-CS5：catalog.yaml + shards/<n>.yaml） */
-interface IndexSnapshot {
-	catalogPath: string
-	catalogText: string | null
-	shardsDir: string
-	/** 片号 → 正文（盘上现存、可解析的片；缺文件/不可解析 → null） */
-	shardTexts: Map<number, string | null>
-}
-
 export function verifyMarket(opts: VerifyOptions = {}): VerifyResult {
 	const projectRoot = opts.projectRoot ?? process.cwd();
 	const layout = resolveCdnLayout(projectRoot);
 	const checks: VerifyCheck[] = [];
-	const drift: string[] = [];
-
-	const index = readIndexSnapshot(layout.dir);
-	const declared = declaredHashes(index);
 
 	const tgzFiles = opts.file !== undefined
 		? [opts.file]
@@ -79,7 +59,7 @@ export function verifyMarket(opts: VerifyOptions = {}): VerifyResult {
 	for (const file of tgzFiles) {
 		const tgzPath = path.isAbsolute(file) ? file : path.join(layout.dir, file);
 		if (!fs.existsSync(tgzPath)) {
-			checks.push({ item: "完整性", ok: false, detail: `${file}：文件不存在` });
+			checks.push({ item: "包级签名", ok: false, detail: `${file}：文件不存在` });
 			continue;
 		}
 		const bytes = new Uint8Array(fs.readFileSync(tgzPath));
@@ -87,66 +67,25 @@ export function verifyMarket(opts: VerifyOptions = {}): VerifyResult {
 		const name = nameOf(file);
 		const version = versionOf(file);
 
-		// 文件名解析对含连字符的 slug / 预发布版本（x-y-z.tgz）不可靠，故以「内容摘要」兜底匹配：
-		// 优先按文件名定位声明；定位不到时改用 sha256 命中索引任一声明条目，
-		// 避免预发布包被「未声明」误判而静默放过篡改。
-		const declaredShas = new Set(declared.values());
-		const want = declared.get(`${name}@${version}`);
-		const ok = want === undefined ? declaredShas.has(sha256) : want === sha256;
-		checks.push({
-			item: "完整性",
-			ok,
-			detail: want === undefined
-				? (declaredShas.has(sha256)
-					? `${file}：文件名未解析到精确版本，但 sha256 与索引某条目一致（${sha256.slice(0, 12)}…）`
-					: `${file}：索引未声明该文件名对应版本，且 sha256 与索引任何条目都不一致（疑似篡改或未发布）（${sha256.slice(0, 12)}…）`)
-				: `${file}：${want === sha256 ? `sha256 与索引一致（${sha256.slice(0, 12)}…）` : `sha256 不一致（索引 ${want.slice(0, 12)}… vs 实际 ${sha256.slice(0, 12)}…）`}`,
-		});
-
 		checks.push(signatureCheck(tgzPath, name, version, sha256));
 		checks.push(...structureCheck(bytes, file));
 	}
-
-	checks.push(indexSigCheck(path.join(layout.dir, "catalog.yaml.sig"), "catalog.yaml", "catalog", index.catalogText));
-	for (const [no, text] of index.shardTexts)
-		checks.push(indexSigCheck(path.join(index.shardsDir, `${no}.yaml.sig`), `shards/${no}.yaml`, "shard", text));
-	checks.push(generationCheck(index));
-	checks.push(expiryCheck(index.catalogText));
 	checks.push(...migrationConsistencyCheck(layout.dir, tgzFiles));
 
-	if (opts.rebuildCheck === true)
-		drift.push(...driftOf(layout.dir, index));
-
-	const passed = checks.every(c => c.ok) && drift.length === 0;
+	const passed = checks.every(c => c.ok);
 	return {
 		checks,
 		passed,
 		conclusion: passed
 			? `全部校验通过（${checks.length} 项）。${BOUNDARY}——验签过只说明来源与完整性，不说明代码无害。`
 			: `存在未通过项。${BOUNDARY}：未通过项须逐条排查后再发布。`,
-		drift: opts.rebuildCheck === true ? drift : undefined,
 	};
 }
 
-/** 读三级索引快照：catalog + 盘上 `shards/<n>.yaml` 全集（不含 .sig——签名在各 check 里按路径读） */
-function readIndexSnapshot(cdnDir: string): IndexSnapshot {
-	const shardsDir = path.join(cdnDir, "shards");
-	const shardTexts = new Map<number, string | null>();
-	if (fs.existsSync(shardsDir)) {
-		for (const f of fs.readdirSync(shardsDir).filter(f => /^\d+\.yaml$/.test(f)).sort()) {
-			const no = Number.parseInt(f, 10);
-			if (Number.isInteger(no) && no >= 1)
-				shardTexts.set(no, readOptional(path.join(shardsDir, f)));
-		}
-	}
-	const catalogPath = path.join(cdnDir, "catalog.yaml");
-	return { catalogPath, catalogText: readOptional(catalogPath), shardsDir, shardTexts };
-}
-
 /**
  * `.sig` 里验签只用到 public_key / value 两字段；缺任一即不可复核。
- * 抽成类型守卫：包级与索引级两处验签共用（DRY），也顺带让调用点的布尔式保持单行
- * （本仓 indent-binary-ops 与 no-mixed-spaces-and-tabs 对续行缩进的要求互相打架）。
+ * 抽成类型守卫让调用点的布尔式保持单行（本仓 indent-binary-ops 与 no-mixed-spaces-and-tabs
+ * 对续行缩进的要求互相打架）。
  */
 function hasSigFields(sig: { public_key?: string, value?: string, canon?: string, registry_id?: string }): sig is { public_key: string, value: string, canon?: string, registry_id?: string } {
 	return typeof sig.public_key === "string" && typeof sig.value === "string";
@@ -178,127 +117,10 @@ function signatureCheck(tgzPath: string, name: string, version: string, sha256:
 	}
 }
 
-/**
- * 索引级验签（REG-CS1①：fail-closed，缺签名即拒，不再「运行期容忍」）。
- *
- * 为什么不能容忍：容忍等于把「索引完整性」交给发布方的自觉——谁改了 catalog.yaml 都能装。
- * 规范串带 seq（`index:<kind>:<seq>:<sha256>`），故 `.sig` 必须带 seq 才可能验过。
- * 分片（kind=shard）的 seq 不取自正文（纯内容无元字段），由 catalog 的 `shards` 钉值在
- * 同代校验里核对；此处只验「签名本身与字节匹配且覆盖代次」。
- */
-function indexSigCheck(sigPath: string, label: string, kind: IndexKind, text: string | null): VerifyCheck {
-	if (text === null)
-		return { item: "索引签名", ok: true, detail: `${label} 不存在，跳过` };
-	if (!fs.existsSync(sigPath)) {
-		return {
-			item: "索引签名",
-			ok: false,
-			code: "index_sig_missing",
-			detail: `${label}.sig 缺失（index_sig_missing）——完整性无保障，安装侧会拒装。下一步：① ojm market build-index --id <publisher.id> 重建并签名；② 或对既有索引补签 ojm publish <目录> --id <publisher.id>`,
-		};
-	}
-	try {
-		const sig = JSON.parse(fs.readFileSync(sigPath, "utf-8")) as { public_key?: string, value?: string, seq?: unknown };
-		const seq = sigSeqOf(sig);
-		if (seq === null)
-			return { item: "索引签名", ok: false, code: "index_sig_mismatch", detail: `${label}.sig 缺 seq 字段——签名未覆盖代次，请用当前 ojm 重签` };
-		const ok = hasSigFields(sig) && verifyCanonical(sig.public_key, indexCanonical(kind, seq, text), sig.value);
-		return {
-			item: "索引签名",
-			ok,
-			code: ok ? undefined : "index_sig_mismatch",
-			detail: ok
-				? `${label} 验签通过（第 ${seq} 代）`
-				: `${label} 验签失败（index_sig_mismatch）——索引被改或签名不符`,
-		};
-	}
-	catch (error) {
-		return { item: "索引签名", ok: false, code: "index_sig_mismatch", detail: `${label}.sig 不可解析：${(error as Error).message}` };
-	}
-}
-
-/** `.sig` 的 seq 字段（非正整数即 null——代次必须是可比较的整数） */
-function sigSeqOf(sig: { seq?: unknown }): number | null {
-	const seq = sig.seq;
-	return typeof seq === "number" && Number.isInteger(seq) && seq >= 1 ? seq : null;
-}
-
-/**
- * REG-CS1② 同代校验（三级化）：代次真源 = **catalog**（顶层 `seq` + `shards` 钉值表）。
- *
- * 每片被 catalog 钉住一个代次，其 `.sig.seq` 必须等于钉值——不允许把「新总目录」和
- * 「对不上代的分册」拼起来用（红队 F2：写索引写到一半进程被杀就会留下这种中间态）。
- * 未变的片沿用旧代次是**设计允许**的（内容逐字节未动，拼起来永远同代同内容），
- * 判定口径因此是「签名代次 == catalog 钉值」而非「== catalog 代次」。
- * 这是**运维事故**不是安全事件，所以错误码与「签名不符」分开，提示也指向「稍后重试」。
- */
-export function generationCheck(index: IndexSnapshot): VerifyCheck {
-	const present = index.catalogText !== null;
-	if (!present && index.shardTexts.size === 0)
-		return { item: "索引同代", ok: true, detail: "索引文件缺失，跳过同代校验" };
-	if (!present) {
-		return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: `catalog.yaml 缺失但 shards/ 里有 ${index.shardTexts.size} 片——源正在重建索引或索引被手改，请稍后重试（index_generation_mismatch）` };
-	}
-	const catalogSeq = indexSeqOf(index.catalogText!);
-	if (catalogSeq === null)
-		return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: "catalog.yaml 缺顶层 seq 字段——用 ojm market build-index 重建索引" };
-	// catalog 正文代次与签名代次必须一致（防「改了正文没换签名」的半个写入）
-	const catalogSigSeq = sigSeqOf(readSigJson(`${index.catalogPath}.sig`));
-	if (catalogSigSeq !== catalogSeq)
-		return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: `catalog.yaml 正文是第 ${catalogSeq} 代、签名是第 ${String(catalogSigSeq ?? "无")} 代——源正在重建索引，请稍后重试（index_generation_mismatch）` };
-	const pins = shardPinsOf(index.catalogText!);
-	for (const [no, pinSeq] of pins) {
-		// 钉值分册的正文必须存在：catalog 引用了某分册但盘上缺失 → 安装会 404，须判失败而非放过。
-		if (!fs.existsSync(path.join(index.shardsDir, `${no}.yaml`))) {
-			return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: `shards/${no}.yaml 正文缺失（catalog 钉第 ${pinSeq} 代）——分册丢失或源正在重建索引，请稍后重试（index_generation_mismatch）` };
-		}
-		const sig = readSigJson(path.join(index.shardsDir, `${no}.yaml.sig`));
-		const sigSeq = sigSeqOf(sig);
-		if (sigSeq === null)
-			return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: `shards/${no}.yaml 签名代次不可判定（catalog 钉第 ${pinSeq} 代）——请用当前 ojm 重签` };
-		if (sigSeq !== pinSeq)
-			return { item: "索引同代", ok: false, code: "index_generation_mismatch", detail: `shards/${no}.yaml 签名是第 ${sigSeq} 代，catalog 钉的是第 ${pinSeq} 代——源正在重建索引，请稍后重试（index_generation_mismatch）` };
-	}
-	return { item: "索引同代", ok: true, detail: `catalog 第 ${catalogSeq} 代，${pins.size} 片代次与钉值一致` };
-}
-
-/** 读 .sig JSON（不可解析 → 空对象，由调用方按 fail-closed 处理） */
-function readSigJson(sigPath: string): { seq?: unknown } {
-	try {
-		return JSON.parse(fs.readFileSync(sigPath, "utf-8")) as { seq?: unknown };
-	}
-	catch {
-		return {};
-	}
-}
-
-/**
- * REG-CS2 索引时效：catalog 自带 `issued_at` / `expires_at`，过了失效时刻的索引不能再用来装。
- * 与站点 `market/api.ts guardCatalogFreshness` 同一判定（CLI/API 一致，D1）。
- */
-export function expiryCheck(text: string | null): VerifyCheck {
-	if (text === null)
-		return { item: "索引时效", ok: true, detail: "索引文件缺失，跳过时效校验" };
-	const times = indexTimesOf(text);
-	if (times === null)
-		return { item: "索引时效", ok: false, code: "index_expired", detail: "catalog.yaml 缺 issued_at / expires_at——索引未带时效，用 ojm market build-index 重建" };
-	const now = Math.floor(Date.now() / 1000);
-	const ok = now <= times.expires_at;
-	const at = new Date(times.expires_at * 1000).toISOString();
-	return {
-		item: "索引时效",
-		ok,
-		code: ok ? undefined : "index_expired",
-		detail: ok
-			? `索引有效至 ${at}`
-			: `索引已于 ${at} 失效（index_expired）——源未在其自声明的有效期内重建，请重建后再发布`,
-	};
-}
-
 /**
  * manifest 结构：必填字段 + 内嵌原生清单 desc 非空（等值要求已移除，见 §9.3）。
  *  必填不含 archive：契约 C2-29 允许 Form A 整体省略，`ojm build --bundle` 对真实方案的
- *  落盘形态即省略（fixture 会写 file 占位）——把它当必填会让一切真实工程包验包必红。
+ * 落盘形态即省略（fixture 会写 file 占位）——把它当必填会让一切真实工程包验包必红。
  */
 function structureCheck(bytes: Uint8Array, file: string): VerifyCheck[] {
 	let entries: ReturnType<typeof readTgz>;
@@ -376,81 +198,6 @@ function migrationConsistencyCheck(cdnDir: string, files: string[]): VerifyCheck
 	return out;
 }
 
-/** 扫描重建出的索引与盘上索引双向比对：检出「落了包没重建 / 索引被手改 / 索引多条目」 */
-function driftOf(cdnDir: string, index: IndexSnapshot): string[] {
-	const out: string[] = [];
-	const files = fs.readdirSync(cdnDir).filter(f => f.endsWith(".tgz")).sort();
-	const scanned: IndexedPackage[] = [];
-	for (const file of files) {
-		const bytes = new Uint8Array(fs.readFileSync(path.join(cdnDir, file)));
-		const entries = readTgz(bytes);
-		const root = entries.find(e => /^(?:[^/]+\/)?manifest\.yaml$/.test(e.name));
-		if (root === undefined)
-			continue;
-		const manifest = (yamlParse(root.content.toString("utf-8")) ?? {}) as Record<string, unknown>;
-		const name = String(manifest.name ?? "");
-		const version = String(manifest.version ?? "");
-		if (name === "" || version === "")
-			continue;
-		scanned.push({ name, version, file, sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.byteLength, manifest });
-	}
-	if (index.catalogText === null) {
-		if (scanned.length > 0)
-			out.push(`盘上没有 catalog.yaml，但目录里有 ${scanned.length} 个包——索引从未重建`);
-		return out;
-	}
-	// 三级化后版本明细住在分片里：全集 = 各片 solutions[].versions
-	const inIndex = new Set<string>();
-	for (const text of index.shardTexts.values()) {
-		if (text === null)
-			continue;
-		const doc = (yamlParse(text) ?? { solutions: [] }) as { solutions?: Array<Record<string, unknown>> };
-		for (const solution of doc.solutions ?? []) {
-			const name = String(solution.name ?? "");
-			for (const v of (solution.versions ?? []) as Array<Record<string, unknown>>)
-				inIndex.add(`${name}@${String(v.version ?? "")}`);
-		}
-	}
-	const onDisk = new Set(scanned.map(p => `${p.name}@${p.version}`));
-	for (const pkg of scanned) {
-		if (!inIndex.has(`${pkg.name}@${pkg.version}`))
-			out.push(`索引缺条目：${pkg.name}@${pkg.version}（${pkg.file}）——落了包但没跑 ojm market build-index`);
-	}
-	// 反向漂移：索引钉了某个版本、盘上却没有对应 tgz（包被删/被挤走没重建）——
-	// 只查正向会让「索引答应有、实际没有」悄悄漏过去，安装侧拉到 404 才知道
-	for (const key of inIndex) {
-		if (onDisk.has(key))
-			continue;
-		const [name, version] = key.split("@") as [string, string];
-		out.push(`索引多条目：${name}@${version}——索引声明了该版本但 cdn/ 里没有 ${name}-${version}.tgz，跑 ojm market build-index 重建`);
-	}
-	return out;
-}
-
-/** 索引声明的 `name@version → sha256`（三级化后声明住在分片正文的 archive.sha256） */
-function declaredHashes(index: IndexSnapshot): Map<string, string> {
-	const out = new Map<string, string>();
-	for (const text of index.shardTexts.values()) {
-		if (text === null)
-			continue;
-		const doc = (yamlParse(text) ?? { solutions: [] }) as { solutions?: Array<Record<string, unknown>> };
-		for (const solution of doc.solutions ?? []) {
-			const name = String(solution.name ?? "");
-			for (const v of (solution.versions ?? []) as Array<Record<string, unknown>>) {
-				const archive = v.archive as Record<string, unknown> | undefined;
-				const sha = archive?.sha256;
-				if (typeof sha === "string")
-					out.set(`${name}@${String(v.version ?? "")}`, sha);
-			}
-		}
-	}
-	return out;
-}
-
-function readOptional(file: string): string | null {
-	return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : null;
-}
-
 /** `<name>-<version>.tgz` → name（取最后一个 - 之前，版本段不含 -） */
 function nameOf(file: string): string {
 	const base = path.basename(file).replace(/\.tgz$/, "");

package/src/market/walkthrough.ts

@@ -6,9 +6,10 @@
  *
  * 输出是一张 AC 表 + 汇总行；有 FAIL 即退出码 1。`--strict` 首败即停（调试用）。
  *
- * T12 追加：upgrade / rollback（主链路）与 neg-tamper / nosig / badindex / stranger（负向）。
+ * T12 追加：upgrade / rollback（主链路）与 neg-tamper / nosig / stranger（负向）。
+ * A6：索引面负向（neg-badindex）随索引机制退役删除——写通道门禁（cdn-upload.spec）承接。
  * neg-* 统一用 0.0.9 版本（低于主链路 latest 0.2.0，永远成不了 latest）与主链路隔离；篡改的文件在 finally 里回抄原始字节（不重签），
- * 收尾摘包重铺索引——否则后续 op 全挂。
+ * 收尾摘包除目录行——否则后续 op 全挂。
  */
 
 import type { TaskRecord } from "../site";
@@ -20,11 +21,10 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { resolveLayout } from "../layout";
-import { writeIndexFile } from "../publish";
 import { signCommand } from "../sign";
 import { callApi, login, pollTask, tenantHeaders, unwrapEnvelope } from "../site";
 import { bootstrapIsolatedSite, derivePublisherKey } from "./bootstrap";
-import { buildIndex } from "./build-index";
+import { nullReleaseSig, removeMarketRelease, seedMarketRelease } from "./db-seed";
 import { FAILURE_PLAYBOOK } from "./failure-playbook";
 import { buildEvilZipSlipTgz, parseFixtureSpec } from "./fixture";
 import { publishPackage } from "./publish";
@@ -84,7 +84,7 @@ function installSucceeded(task: TaskRecord): boolean {
 /**
  * neg-* 专用版本：与主链路（0.1.0/0.2.0）完全隔离，收尾整包摘除。
  * 必须低于主链路 latest（0.2.0），否则发布后它会成为 latest，摘除时 REG-CS2 单调性守卫
- * 会把它判成「latest 回退」而拒建索引，导致负向用例的安装拒绝断言没机会跑（9.9.9 曾踩此坑）。
+ * 会让它成为 latest 干扰主链路，导致负向用例的安装拒绝断言没机会跑（9.9.9 曾踩此坑）。
  */
 const NEG_VERSION = "0.0.9";
 /** neg-* 独立方案名：与主链路 demo-solution 隔离，避免共享迁移账本（OJ-9 降级守卫会误拦 neg 包的低 seq 迁移）与 latest 守卫串扰 */
@@ -93,12 +93,13 @@ const NEG_NAME = "neg-solution";
 const OPS: Op[] = [
 	{
 		key: "index",
-		title: "市场索引出卡片",
+		title: "市场目录出卡片",
 		run: async (ctx) => {
-			const rows = await callApi<Array<Record<string, unknown>>>(fetch, ctx.base, ctx.token, "GET", "/api/_platform/market/index");
-			const hit = (rows ?? []).find(r => r.name === ctx.name);
+			const page = await callApi<{ list?: Array<Record<string, unknown>> }>(fetch, ctx.base, ctx.token, "GET", "/api/oj-market/index");
+			const rows = page?.list ?? [];
+			const hit = rows.find(r => r.name === ctx.name);
 			return hit === undefined
-				? { ok: false, detail: `索引里没有 ${ctx.name}（拿到 ${(rows ?? []).length} 张卡）` }
+				? { ok: false, detail: `目录里没有 ${ctx.name}（拿到 ${rows.length} 张卡）` }
 				: { ok: true, detail: `${ctx.name} 在列，latest=${String(hit.latest)}，available=${JSON.stringify(hit.available ?? [])}` };
 		},
 	},
@@ -126,10 +127,10 @@ const OPS: Op[] = [
 		title: "禁用 / 启用",
 		run: async (ctx) => {
 			await ensureInstalled(ctx);
-			const off = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/enable", { name: ctx.name, enabled: false });
+			const off = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/enable", { name: ctx.name, enabled: false });
 			if (off.ok !== true)
 				return { ok: false, detail: `禁用被拒：${off.message ?? "?"}` };
-			const on = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/enable", { name: ctx.name, enabled: true });
+			const on = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/enable", { name: ctx.name, enabled: true });
 			return on.ok === true
 				? { ok: true, detail: "disable → enable 双向成功" }
 				: { ok: false, detail: `启用被拒：${on.message ?? "?"}` };
@@ -158,7 +159,7 @@ const OPS: Op[] = [
 		key: "history",
 		title: "操作历史可读",
 		run: async (ctx) => {
-			const rows = await callApi<unknown[]>(fetch, ctx.base, ctx.token, "GET", "/api/_platform/market/history");
+			const rows = await callApi<unknown[]>(fetch, ctx.base, ctx.token, "GET", "/api/oj-market/history");
 			const n = Array.isArray(rows) ? rows.length : 0;
 			return n > 0 ? { ok: true, detail: `历史 ${n} 条` } : { ok: false, detail: "历史为空" };
 		},
@@ -228,7 +229,7 @@ const OPS: Op[] = [
 			if (installed === null)
 				await ensureInstalled(ctx); // 未装过：先装 ctx.version
 			const target = installed ?? ctx.version;
-			const res = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/uninstall", { name: ctx.name });
+			const res = await callApi<{ ok?: boolean, message?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/uninstall", { name: ctx.name });
 			if (res.ok !== true)
 				return { ok: false, detail: `卸载被拒：${res.message ?? "?"}` };
 			const dir = path.join(ctx.site.root, "api", "dist", `${ctx.name}-${target}`);
@@ -255,7 +256,7 @@ const OPS: Op[] = [
 				return {
 					ok,
 					detail: ok
-						? "failed@verifying（sha256 与索引不符，C2-29 fail-closed），零落盘"
+						? "failed@verifying（包体 sha256 与目录行不符，C2-29 fail-closed），零落盘"
 						: `status=${task.status} stage=${task.stage} noDrop=${noDrop}：${task.message}`,
 				};
 			}
@@ -267,47 +268,18 @@ const OPS: Op[] = [
 	},
 	{
 		key: "neg-nosig",
-		title: "负向：缺包级签名（sig_missing）",
+		title: "负向：目录行无签名（sig_missing）",
 		run: async (ctx) => {
 			await publishVersion(ctx, NEG_VERSION, NEG_NAME);
-			const tgz = path.join(ctx.site.cdnDir, `${NEG_NAME}-${NEG_VERSION}.tgz`);
-			const sig = `${tgz}.sig`;
-			const origSig = fs.readFileSync(sig);
 			try {
-				fs.rmSync(sig);
-				await buildIndex({ projectRoot: ctx.site.root, id: ctx.site.publisher.keyId, privateKeyPem: ctx.site.publisher.privateKeyPem }); // Form B 缺 archive.signature
+				// 遗留目录行形态（未经回填）：签名四列 NULL → 合成 Form B 缺 archive.signature
+				nullReleaseSig(ctx.site.dbPath, NEG_NAME, NEG_VERSION);
 				const task = await installOnce(ctx, NEG_VERSION, NEG_NAME);
 				const reason = task.error?.reason ?? task.message;
 				const ok = task.status === "failed" && reason.includes("sig_missing");
 				return { ok, detail: ok ? "failed，失败码 sig_missing（G4 硬 fail-closed）" : `status=${task.status}：${reason}` };
 			}
 			finally {
-				fs.writeFileSync(sig, origSig); // 回抄原始字节
-				await removeVersion(ctx, NEG_VERSION, NEG_NAME);
-			}
-		},
-	},
-	{
-		key: "neg-badindex",
-		title: "负向：索引篡改（验签拒载）",
-		run: async (ctx) => {
-			await publishVersion(ctx, NEG_VERSION, NEG_NAME);
-			const catalog = path.join(ctx.site.cdnDir, "catalog.yaml");
-			const orig = fs.readFileSync(catalog);
-			try {
-				fs.appendFileSync(catalog, "# tampered\n"); // 索引字节变、签名失配
-				let msg = "";
-				try {
-					await installOnce(ctx, NEG_VERSION, NEG_NAME);
-				}
-				catch (error) {
-					msg = (error as Error).message; // 预期：安装 POST 即 502，任务都未创建
-				}
-				const ok = msg.includes("签名校验失败");
-				return { ok, detail: ok ? "安装 POST 即 502 拒载（G4 fail-closed），任务未创建" : `未按预期拒装：${msg === "" ? "安装竟成功" : msg}` };
-			}
-			finally {
-				writeIndexFile(catalog, orig.toString("utf-8")); // 回抄原始字节（也走唯一写入口，不留下直写索引的路径）
 				await removeVersion(ctx, NEG_VERSION, NEG_NAME);
 			}
 		},
@@ -325,16 +297,16 @@ const OPS: Op[] = [
 			const before = await trustKeys(ctx); // 信任库快照（F3 diff 基线）
 			try {
 				signCommand(tgz, { id: "stranger.publisher", privateKeyPem: stranger.privateKeyPem, registryId: "trial.registry" }); // 覆盖侧车签名（REG-CS3 v2 规范串首段需 registry 身份）
-				await buildIndex({ projectRoot: ctx.site.root, id: "stranger.publisher", privateKeyPem: stranger.privateKeyPem });
+				seedMarketRelease(ctx.site.dbPath, { tgzPath: tgz }); // 重 seed：目录行换陌生 key（upsert 覆盖）
 				const first = await installOnce(ctx, NEG_VERSION, NEG_NAME);
 				if (first.status !== "needs_trust")
 					return { ok: false, detail: `未停 needs_trust：status=${first.status}：${first.message}` };
-				await callApi(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/trust", { task_id: first.id });
+				await callApi(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/trust", { task_id: first.id });
 				const second = await installOnce(ctx, NEG_VERSION, NEG_NAME);
 				if (!installSucceeded(second))
 					return { ok: false, detail: `确认后重装未 done：status=${second.status}：${second.message}` };
 				// 收尾（F3）：显式 revoke 陌生 key，快照 diff 断言无残留——不靠 uninstall 兜底（它本就不摘信任）
-				const del = await callApi<{ revoked?: boolean }>(fetch, ctx.base, ctx.token, "DELETE", `/api/_platform/market/trust/key?key_id=${encodeURIComponent("stranger.publisher")}`);
+				const del = await callApi<{ revoked?: boolean }>(fetch, ctx.base, ctx.token, "DELETE", `/api/oj-market/trust/key?key_id=${encodeURIComponent("stranger.publisher")}`);
 				const after = await trustKeys(ctx);
 				const revoked = del.revoked === true;
 				const noResidue = JSON.stringify(after) === JSON.stringify(before);
@@ -349,6 +321,9 @@ const OPS: Op[] = [
 			finally {
 				fs.writeFileSync(tgz, orig); // 回抄原始字节，不重签
 				fs.writeFileSync(sig, origSig);
+				// 目录行回滚为原发布者（摘除 + 重 seed 原字节），再走清场
+				removeMarketRelease(ctx.site.dbPath, NEG_NAME, NEG_VERSION);
+				seedMarketRelease(ctx.site.dbPath, { tgzPath: tgz });
 				await removeVersion(ctx, NEG_VERSION, NEG_NAME);
 			}
 		},
@@ -358,7 +333,7 @@ const OPS: Op[] = [
 		title: "负向：zip-slip 越界包（R1 拒收）",
 		run: async (ctx) => {
 			const evil = path.join(ctx.site.cdnDir, `${ctx.name}-evil.tgz`);
-			buildEvilZipSlipTgz(evil); // 成员含 ../evil.sql，无需发布进索引（file 源直传）
+			buildEvilZipSlipTgz(evil); // 成员含 ../evil.sql，无需进目录（file 源直传）
 			const distDir = resolveLayout(ctx.site.root).apiDist;
 			const before = fs.readdirSync(distDir).sort(); // 零副作用基线：0.0.9 目录可能是前序 neg-stranger 的合法产物
 			try {
@@ -435,7 +410,7 @@ export async function walkthrough(opts: WalkthroughOptions = {}): Promise<Walkth
 async function install(ctx: Ctx, version: string): Promise<TaskRecord> {
 	let task = await installOnce(ctx, version);
 	if (task.status === "needs_trust") {
-		await callApi(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/trust", { task_id: task.id });
+		await callApi(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/trust", { task_id: task.id });
 		task = await installOnce(ctx, version);
 	}
 	if (installSucceeded(task))
@@ -444,7 +419,7 @@ async function install(ctx: Ctx, version: string): Promise<TaskRecord> {
 }
 
 async function installOnce(ctx: Ctx, version: string, name: string = ctx.name): Promise<TaskRecord> {
-	const started = await callApi<{ task_id?: string, id?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/_platform/market/install", { name, version, source: "cdn" });
+	const started = await callApi<{ task_id?: string, id?: string }>(fetch, ctx.base, ctx.token, "POST", "/api/oj-market/install", { name, version, source: "cdn" });
 	const taskId = String(started.task_id ?? started.id ?? "");
 	if (taskId === "")
 		throw new Error("[ojm] 安装接口未返回 task id");
@@ -458,17 +433,17 @@ async function installFile(ctx: Ctx, tgzPath: string, version: string): Promise<
 	form.append("version", version);
 	form.append("source", "file");
 	form.append("file", new Blob([fs.readFileSync(tgzPath)], { type: "application/gzip" }), path.basename(tgzPath));
-	const res = await fetch(`${ctx.base}/api/_platform/market/install`, {
+	const res = await fetch(`${ctx.base}/api/oj-market/install`, {
 		method: "POST",
 		headers: { authorization: `Bearer ${ctx.token}`, ...tenantHeaders() },
 		body: form,
 	});
-	await unwrapEnvelope(res); // 非 0 code 抛人话（400 zip-slip / 502 索引等）
+	await unwrapEnvelope(res); // 非 0 code 抛人话（400 zip-slip 等）
 }
 
 /** 信任库 key_id 快照（GET /market/trust；neg-stranger 的 diff 断言用） */
 async function trustKeys(ctx: Ctx): Promise<string[]> {
-	const res = await callApi<{ keys?: Array<{ key_id?: string }> }>(fetch, ctx.base, ctx.token, "GET", "/api/_platform/market/trust");
+	const res = await callApi<{ keys?: Array<{ key_id?: string }> }>(fetch, ctx.base, ctx.token, "GET", "/api/oj-market/trust");
 	return (res.keys ?? []).map(k => k.key_id ?? "").filter(id => id !== "").sort();
 }
 
@@ -482,23 +457,23 @@ async function ensureInstalled(ctx: Ctx): Promise<void> {
 		throw new Error(`前置安装失败：status=${task.status}：${task.message}`);
 }
 
-/** 索引卡片（本方案一行；upgrade/rollback/uninstall 与 index op 同一消费面） */
+/** 目录卡片（本方案一行；upgrade/rollback/uninstall 与 index op 同一消费面） */
 async function indexCard(ctx: Ctx): Promise<Record<string, unknown> | undefined> {
-	const rows = await callApi<Array<Record<string, unknown>>>(fetch, ctx.base, ctx.token, "GET", "/api/_platform/market/index");
-	return (rows ?? []).find(r => r.name === ctx.name);
+	const page = await callApi<{ list?: Array<Record<string, unknown>> }>(fetch, ctx.base, ctx.token, "GET", "/api/oj-market/index");
+	return (page?.list ?? []).find(r => r.name === ctx.name);
 }
 
-/** 发布某版本 fixture 进隔离 CDN 并重铺索引（upgrade/rollback/neg-* 的共用前置） */
+/** 发布某版本 fixture 进隔离站点（落字节 + seed 目录行——upgrade/rollback/neg-* 共用前置） */
 async function publishVersion(ctx: Ctx, version: string, name: string = ctx.name): Promise<void> {
-	await publishPackage({ projectRoot: ctx.site.root, fixture: `${name}@${version}`, id: ctx.site.publisher.keyId, privateKeyPem: ctx.site.publisher.privateKeyPem, registryId: "trial.registry" });
-	await buildIndex({ projectRoot: ctx.site.root, id: ctx.site.publisher.keyId, privateKeyPem: ctx.site.publisher.privateKeyPem });
+	const published = await publishPackage({ projectRoot: ctx.site.root, fixture: `${name}@${version}`, id: ctx.site.publisher.keyId, privateKeyPem: ctx.site.publisher.privateKeyPem, registryId: "trial.registry" });
+	seedMarketRelease(ctx.site.dbPath, { tgzPath: published.tgzPath });
 }
 
-/** neg op 收尾：整包摘除（tgz + 侧车签名）并重铺索引，恢复主链路原状 */
+/** neg op 收尾：整包摘除（tgz + 侧车签名 + 目录行），恢复主链路原状 */
 async function removeVersion(ctx: Ctx, version: string, name: string = ctx.name): Promise<void> {
 	for (const file of [`${name}-${version}.tgz`, `${name}-${version}.tgz.sig`])
 		fs.rmSync(path.join(ctx.site.cdnDir, file), { force: true });
-	await buildIndex({ projectRoot: ctx.site.root, id: ctx.site.publisher.keyId, privateKeyPem: ctx.site.publisher.privateKeyPem });
+	removeMarketRelease(ctx.site.dbPath, name, version);
 }
 
 export const WALKTHROUGH_OPS = OPS.map(op => op.key);